语法：Python与C++对比_c++和python

import cmath

导入模块，每一个.py文件都可以认为是一个模块。Python中导入的模块可以是类的定义，函数的定义。

#include

引入头文件，头文件为类或函数的声明。

C++支持分离式编译，对源文件分别编译成目标文件，再链接生成可执行文件。通过头文件把源文件关联起来。

在cmakelist中设置include_directories()，即include时寻找相应头文件的路径

if __name__ == "__main__":

当模块被作为脚本直接运行时，执行之后的程序块；

当模块被其他模块导入时，不执行之后的程序块。

非常方便，可以直接将单元测试脚本写在if __name__ == "__main__":后，保证程序功能正常

一切皆对象（数据类型、函数、类都是对象)。对象包含identity（Python中即为对象的内存地址，一旦创建不再改变）、类型信息、值、引用计数（用于记录当前有多少个变量在引用这个对象。一旦引用计数器为0，那么该对象就会被系统自动回收）、。

可参见：Python 中的对象概述 - 知乎

在python中就是个name，Names refer to objects. Names are introduced by name binding operations.

没有类型信息，是通用的（增加python的灵活性），引用一个对象。

(即变量是对象内存地址的引用）

可参见：python中的变量、对象和引用_ColourfulPanda的博客-CSDN博客_python 引用对象

命了名的对象，即具名的、存储数据并具有某种类型的内存空间

（即变量有一个名字，并在内存中占据一定的存储单元，在该存储单元中存放变量的值）

name binding，名字绑定，变量存储对象的引用

对象分为可变对象和不可变对象，进行name binding时内存空间示意图可参见：Python中的变量、对象 - 汉尼拔草 - 博客园

Python

C++

O

备注：sys.maxsize \ -sys.maxsize-1 (跟计算机相关，可能是32位，也可能是64位)

sys.maxint \ -sys.maxint-1在python2中支持，在python3中不支持了

INT_MAX  \  (4Bytes，即32bits的最大值2^31-1)

INT_MIN  (-2^31)

float('inf')  \

float('-inf')

FLT_MAX  \

FLT_MIN

// 地板除，即向负无穷取整

8//3 结果为2

-8//3 结果为-3

% 取模（modulus）

-10%3 结果为2

-90%8结果为6

% 取余

-10%3 结果为-1

-90%8结果为-2

if condition1:
    statement1
elif condition2:
    statement2
else:
    statement

在if , elif, else中只要匹配上一个，后面的条件和代码块都不再执行，即便后面的elif条件也能匹配上。

if (condition1){
    statement1;

}
else if (condition2){
    statement2;

}
else (condition3){
    statement3;

}

for item in iterable:
    statement

iterable的可以是列表Occupationt=['teacher','student','driver','governer']、元组(1,2,3)、字典{"name":'Arnold',"Salary":10000}.items()、集合对象{100，‘ab’}、字符串 ‘abcdefg’。

for i in range(0,10):
    print(i)

for (init-state;condition;expression){
    statement;

}

C++范围for语句实现类似于Python的遍历序列：

for (auto item : iterable){
    statement;

}

iterable为一个序列，可以是数组、vector、string, 必须拥有能返回迭代器begin和end的成员。 

for (i=0;i<10;i++){
    print(i);

}

while (condition){
    statement;

}

switch(condition){

        case(constant-expression1):

                statement1;

        case(constant-expression2):

                statement2;

                break;

        case(constant-expression3):

                statement3;

                break;

        default:

                statement3;

}

判断满足条件的case后，后面的语句依次执行（不管后面的case是不是能匹配上），直到遇到break。在上面例子中，如果匹配了constant-expression1，则statement1和statement2都会执行。

传对象引用（pass by object reference): 传递的是对象的内存地址的引用；

实质与python的=意义相同。

传值(pass by value)：把实参的实际值赋值给函数的形参。在函数内修改形参，函数外的实参不改变。

传引用(pass by refrence)：把实参的引用赋值给形参。在函数内修改形参，函数外的实参随之变化。

函数内定义函数

（嵌套函数）

python的函数也是对象，因此可以将函数作为参数传递、可以将函数作为返回、可以将函数放入结构体中（如函数放入数组中）、可以在函数中定义函数；

def outer():

    x=5

   def inner():

         y=x+3   #内函数在自己作用域内查找局部变量失败后，会进一步向上一层作用域里查找。

         print(y)

    return inner  #闭包:内函数体内引用到外函数中定义的变量，return返回内函数的引用时把内函数和外部引用变量打包成整体返回， 这里inner函数和外部变量x组成闭包

不能在函数中定义函数，需要使用函数对象或者匿名函数实现需求

void foo(){

    //function object

    class InnerFunction{

        public:

            void operator()(){

                 std::cout<<"inner function object"<

            }

    };

    InnerFunction innerfunction;

    innerfunction();

    //lambda expression

    auto lambdafunc=[=]()->void{

        std::cout<<"inner lambda function"<

    }

    lambdafunc();

}

用于扩展函数功能：

def executetime(func):
   def wrapper(*args, **kwargs):
        time1=time.time()
        func(*args, **kwargs)
        time2=time.time()
        delta_t=time2-time1
        print('excecute_time is {}'.format(delta_t))
   return wrapper
 
@executetime
def myfunc(num):
    time.sleep(num)
 
#调用时：
myfunc(5)

生成器是包含yield语句的函数，是使用普通函数语法定义的迭代器。

当生成器被调用时不会执行函数体内的代码，而是返回一个迭代器。

每次使用next()请求值时都执行生成器的代码，直到遇到yield或return，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，并返回 yield 的值。在下一次执行 next() 方法时从当前位置继续运行。

Python 

序列（sequence ，包括列表、字符串和元组）

C++

顺序容器(sequential container，包括vector, deque, list, forward_list, , string, array)

例如：v=['dlsdkf', 60]

无需声明容器的类型以及容器内元素的类型：使用[]表示创建列表，()表示元组，“”或''表示字符串；

列表中可以放任意类型的元素，甚至在同一列表中可以包含不同类型的元素。

C c{a,b};

例如： std::vector v{2,3,5};

列表初始化

需要声明容器的类型和容器内元素的类型，容器内元素类型必须相同。

v[n]， n可为负数，-1表示倒数第一个

v[n]， n只能为正数

v[n:n+m]   (左闭右开）

v[n:n+m:k] 支持带步长的切片

v1+v2将两个序列拼接起来

v*5，重复序列v 5次 （乘法）

60 in v

Python 列表的方法

C++

顺序容器(sequential container，包括vector, deque, list, forward_list, array, string)

支持列表推导，通过列表及简洁语法生成新的列表。例如，创建二维列表：

dp=[[0]*dim2 for _ in range(dim1)]

或

dp=[[0 for _ in range(dim2)] for _ in range(dim1)]

三维列表：

dp=[[[0 for _ in range(dim3)] for _ in range(dim2)] for _ in range(dim1)]

创建二维列表：

vector<vector<int>> v(dim1, vector<int>(dim2,0);

创建三维列表：

vector<vector<vector<int>>> v(dim1, vector<vector<int>>(dim2, vector<int>(dim3, 0)));

v.count(60)

v.index(60)

v2=v1.copy()

v.reverse()

v.sort()

v.append(20)

v1.extend(v2)

v.insert(2, 69)

del v[1]

v.pop()

v.pop(0)

v.pop_back()

v.pop_front()

v.remove(60)

v.clear()

Python

C++

s[2:6]

s.sub(2,8);

s.find(sb) 返回子串首次出现的位置，若查找不到返回-1

s.index(sb) 返回子串首次出现的位置，若查找不到抛出异常

string::size_type res=s.find(sb);

如果找到则返回首次出现的位置，否则res==s.npos

d=dict()

if 5 in d:

        statements

unordered_map<int, int> d;

if(d.find(5)!=d.end()){

        statements;

}

class Foobar:

    def __init__(self):

    def __del__(self):

使用魔法（特殊）方法机制，魔法方法是以__开头和__结尾的方法，在特定情况下自动被Python调用，而无需手动直接调用

class Foobar{

    Foobar(){};

    ~Foobar(){};

};

和类同名的函数，无返回类型，

self

类定义中成员函数的第一个参数必须显式为self；

对象调用成员函数时不用传入该参数，python解释器会自己把实例变量传进去。

this  常量指针，指向对象地址

类的成员函数通过this的隐式形参访问调用它的对象。类中定义成员函数时和对象调用成员函数时都不用显式传入this。

在成员函数中return *this返回的正是调用该函数的对象

python中称为对象的数据成员

在类的构造函数内直接定义：

class Example:

    def __init__（self）:

        self.mymember=1

也可以在对象中直接添加或删除对象的数据成员：

example=Example()

example.mysecondmember=2.

del example.mymember

这充分体现了Python的灵活性。

在类的方法外声明数据成员，随后对类实例化，每一个对象拥有数据成员；在对象中无法再添加或删除数据成员

class Example{

    Example(int x):member(x){};

    int mymember;

};

Example example;

C++的数据成员一目了然，非常清晰。

python中称为类的数据成员

class Example:

    classmember=4

在类中但不在类的方法中定义的数据成员为类的数据成员，所有类的实例化对象共享类的数据成员，在类内或类外可以通过Example.classmember获取类的数据成员

class Example{

    static init mymember;

};

int x;

x=Example::mymember;

class Example:

    classmember=4

    @classmethod

    def getclassmember(cls):

        return cls.classmember

静态成员函数

(类的静态成员函数不与任何对象绑定在一起，不包含this指针)

class Example:

    @staticmethod

    def  initsample():

           pass

直接调用：Example.initsample()

也可实例化后调用:

example=Example()

example.initsample()

class Example{

    static double initsample();

};

直接调用：

double r;

r=Example::initsample();

也可实例化后调用:

Example example;

example.initsample();

class Fathertarget:

    def __init__(self, Parameter1,Parameter2):

class Target（ Fathertarget）:

    def __init__(self, P1, P2):

          super().__init__(P1 =Parameter1,P2=Parameter2)

class Fathertarget{

Fathertarget(int Parameter1, int Parameter2){};}

class Target:public Fathertarget{

Target(int P1, int P2):Fathertarget{P1,P2}{}

}

在子类的构造函数初始化列表中调用父类的构造函数初始化

抽象基类

（作为接口）

class Example:

    @abstractmethod

    def  examplemethod(self):

        pass

class Example{

    void examplemethod()=0;

};

class Sample:

    def __call__(self):

        print("!!!!!")

sample=Sample()  #实例化

sample()

对象遵守特定的协议，协议指定需要实现哪些方法以及这些方法应做什么。不基于类的继承关系。