Python基础语法（与C++对比）（持续更新ing）

代码块

|------------|-----------------|
| Python | 在统一缩进体系内，为同一代码块 |
| C++ | {...}内部的为同一代码块 |

注释

|------------|----------------------------|
| Python | 单行注释：#... 多行注释：'''...''' |
| C++ | 单行注释：//... 多行注释: /*...*/ |

数据类型

1. Python数据类型

Python中支持数字之间使用下划线 ' _ ' 分割数字，旨在查看方便

Python中为动态类型，不用显示给变量声明类型。若想声明类型：a:int = 10

|-------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
| int | （1）数据范围：无穷大 （2）默认为4字节大小 （3）支持动态扩容（内存足够大，就可以保存足够大的数据） （4）十六进制：0x开头 （5）八进制：0o开头 |
| float | （1）双精度浮点数 （2）默认为8字节大小 （3）科学计数法表示：1.23 * 10 ** 9 == 1.23e9 ; 1.23 * 10 ** (-3) == 1.23e-3 |
| str | （1）可以用单引号 ' .. ' 双引号 " ... " 三引号 ''' ... ''' （2）单引号、双引号、三引号可以相互嵌套使用，完成各种语境 （3）r "..." 表示 内部字符串默认不转义，就是普通字符 （4）'''line1 ...line2 ...linen ''' 表示多行内容，与\n效果一致 |
| bool | （1）True False （2）用于条件选择 while、if 中 （3）0为假、非0为真 |
| 空值 None | （1）不为0，为一个特殊值 |

2. C++数据类型

|---------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 整型类型： char short int long long long ... | （1）根据存放数据的大小由程序员自由选择 （2）不支持扩容，所以才会有这么多类型 （3）十六进制：0x开头 （4）八进制：0开头 |
| 浮点数类型： float double | （1）float：单精度浮点数，默认字节为4，只保留6位小数 （2）double：双精度浮点数：默认字节为8 （3）使用printf函数时如果没有指定精度，float与double都 是默认输出6位有效数字，此时使用.nf / .nlf来指定输 出的小数位数 （4）使用cout输出的时候，只保留五位小数（四舍五入） |
| 字符串 | （1）只能用双引号 " ... " （2）以 ' \0 ' 结尾，字符串结束的标志，不算字符串的内容 （3）strlen计算字符串长度，不算末尾的' \0 ' |
| bool类型 | （1）true、false （2）默认字节为 1字节 （3）true为1，false为0 （4）0为假，非0为真 |

变量

|-----------------------|--------------------------------------------------------------------------------------------------------------------------------|
| Python 动态类型语言 | （1）无需显示声明变量的数据类型，会根据赋值来自动推导数据类型，并且变量的类型可以动态改变 （2）Python中的变量必须初始化，因为变量为对象的引用，是别名，必须初始化 |
| C++ 静态类型语言 | （1）变量在使用之前必须声明类型，一旦确定类型，在其整个生命周期中，不允许被改变，也不允许其他数据类型进行赋值，但C++提供了强制类型转换的方法 （2）变量可以不初始化，被称为声明，旨在告诉编译器预留出一段空间来存放该数据类型的数据，以便后续进行赋值。 |

变量作用域

|-----------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Python 动态类型语言 | Python分为多级作用域，且只有函数和class类的代码块会涉及到作用域，if、else、elif、while、for的代码块定义的变量可以在外面使用，即属于全局变量 （1）Python的全局变量与局部变量同名时，优先匹配同级作用域的变量，若无，则找上级作用域的变量 （2）下级作用域若创建一个与上级作用域同名的变量，默认是创建一个新的数据对象，对下级作用域中的变量进行修改，不会影响上级作用域的同名变量。若想在下级作用域中修改上级变量，使用global关键字先标识上级变量，再对其进行修改 |
| C++ 静态类型语言 | 变量的作用域由大括号来决定，生命周期由自身的属性决定，但是其可以通过引用传参或指针传参来直接或间接访问变量 全局变量：作用域全局，生命周期随进程 栈变量：作用域和生命周期为所处大括号范围内 堆变量：作用域所处大括号范围内，生命周期随进程 静态局部变量：作用域所处大括号范围内 生命周期随进程 静态全局变量：作用域全局，生命周期随进程 |

变量赋值

|-----------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Python 动态类型语言 | 在 Python 中，变量通过引用指向对象，当多个变量被赋值为相同的值时，它们实际上指向的是同一个对象。这种机制有助于提高内存使用效率和编程的便捷性，需要注意的是Python中赋与相同的值的对象必须是不可变对象，多个变量才会指向同一个对象，如果是list这种可变对象，则会开辟多个空间，因为Python不能确保我们后续是否会修改，若只开辟一个空间创建一个对象，则后续修改一个，其他变量也会被修改 |
| C++ 静态类型语言 | C++是一种静态类型语言，在编译时就需要确定变量的类型和大小，这是因为在编译的时候，就已经将变量名换成地址了，为的是在运行时，初始化进程地址空间。在 C++中，每个变量都有自己独立的内存空间，因此可以在不同的作用域中使用相同的变量名，而不会相互干扰。这是因为在编译的时候，就已经把变量名转换为地址来表示了，变量名只是给我们自己看的，即使变量名相同，但是底层的地址不同，就属于不同的变量 |

内存管理机制

|-----------------------|------------------------------------------|
| Python 动态类型语言 | 具有自动的内存管理机制，通过垃圾回收器来自动回收不再使用的对象所占用的内存 |
| C++ 静态类型语言 | 程序员需要手动管理内存，包括用new和delete操作符来分配和释放内存 |

常量

|------------|-----------------------------------------------------------------------------------------------------------|
| Python | Python没有真正意义的常量，通常用全大写的字母来表示常量，但是这些常量本质依旧是可以改变的变量，只不过是对程序员的一种非限制性约束，只要程序员看到全大写的变量，会默认这是一个不可修改的变量，即常量。 |
| C++ | （1）const修饰的常变量：给变量添加常属性 （2）enum枚举常量 （3）define定义的宏 （4）字面常量：1，3.14 |

运算符

|-----------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 算数运算符 | + - * / % ** // a ** b ：数学中的乘方运算，b可正、负，可整数、小数 a // b ：向下取整的除法（往小方向取整） （1）Python中除0或0.0都为除0异常 C++中只有除0会抛异常，除0.0会得到无穷大的数inf （2）Python中int / int ，除不尽得到小数，不会截断 C++中 int / int ，除不尽得到整数，会截断 |
| 关系运算符 | < <= > >= == != （1）比较整数、比较字符串（按照字典序比较） （2）比较浮点数：使用关系运算符比较浮点数的时候，存在一定的风险，因为浮点数载内存的存储和表示，是可能存在误差的，这样的误差会在进行算数运算的时候被放大，从而导致关系运算符的判断不准。 正确比较浮点数：作差，判断是否在误差范围 -0.000001 < a - b < 0.000001 在误差范围就是True，反之False （3）Python支持连续小于的写法，即Python支持连续的条件判断，而C/C++不支持 |
| 逻辑运算符 | （1）and：C++中的 && 并且 （2）or： C++中的 || 或者 （3）not： C++中的 ! 逻辑反 |
| 赋值运算符 | （1）赋值 a = 10 a = b = 10 a , b = 10 , 20 （2）交换 a, b = b, a |
| 身份运算符 | is 、is not ：用于判断两个对象是否为同一个对象 即它们是否具有相同的内存地址 【Python中若给两个变量赋同一个值，本质上这两个变量指向的是同一个内存地址，底层不会给两个变量开辟两个相同的值的空间，这属于一种浪费，所以在使用is来判断的时候，他们属于同一个对象；但是在C++中，是会给同一个值的两个变量开辟不同的空间存放，这是不同之处】 |
| 成员运算符 | in、not in：用于判断一个对象是否在可迭代对象中 |
| 位运算符 | &、｜、～、^、<<、>> |
| 混合运算符 | +=、-=、*=、/=、%=、**=、//= Pyhton不支持++、-- |

格式化打印

|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Python | 第一种： （1）采用与C语言一致的风格 （2）格式：print(" ...%d %s ... " %(123, ' hello ')) （3）%s可以把所有的数据类型转换为字符串类型 第二种： （1）format函数，通过{0}、{1}、{2}这种占位符来进行格式化打印 （2）占位符: 格式 -> 表示需要以哪种形式打印出来数据 { 0 : nd } { 0 : .nf } { 0 : ns } （3）与print配套使用 （4）print (" 我的名字是{ 0 }，我{ 1 }岁 ".format ( ' hh ',' 20 ' ) ) 第三种： （1）f-string ：使用以f开头的字符串，内部如果包含{变量名}，就会以对应的变量替换 （2）与print配套使用 |
| C++ | C语言printf格式化打印（%d、%md、%f、%c、%s、%o、%x、%p、%e、%E、%n等）_printf %d-CSDN博客 |

Python的列表 list 与 C++的 vector

Python的列表list（与C++的vector对比学习）-CSDN博客

Python的元组 tuple

【深入理解】元组tuple的底层实现（与C++进行对比）-CSDN博客

Python的dict

Python的dict与C++的unordered_map类似，用来存放键值对的数据结构，是高效的搜索结构

|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Python | （1）表示形式：以{ ... }包围，内部为key:value形式 （2）创建：d = {key:vlaue, key:value} （3）key不可以重复、且key为不可变对象，所以可以用做key的类型有：字符串、整数、浮点数、bool、元组 （4）查找：使用in / not in 来判断在或不在，这里是判断key d [key] 存在获得value，反之抛异常 d.get( )存在获取value，不存在获取None （5）插入：d [key] = value（key不存在） （6）修改：d [key] = value（key存在） （7）删除：d.pop(key) （8）遍历：for循环 d.keys( ) 获取所有key d.values( ) 获取所有values d.iitems( ) 获取所有的key：values |

Python的set

set是一组key的集合，但是不存储value，重复元素会被自动过滤，这与C++的unordered_set类似

|--------|---------------------------------------------------------------------------------------------------------------------|
| Python | （1）创建： s = { key, key, key, ... } （2）key必须是不可变对象 （2）插入：s.add( key ) （3）删除：s.remove( key ) （4）多个set可以做数学意义上的交集和并集等操作 |

Python的可变对象与不可变对象

不可变对象：对象调用自身方法，不会改变自身的内容，会创建新的方法并返回
可变对象：对象调用自身方法会改变自身的内容

条件判断

|--------|------------------------------------------------------------|
| Python | if <条件判断>: <代码块> elif<条件判断>: <代码块> else: <代码块> |
| C++ | if (条件判断) { //代码块 } else if（条件判断） { //代码块 } else { //代码块 } |

模式匹配

有关变量的条件：match / switch 到的变量在每个case中是否匹配，匹配就执行

|--------|---------------------------------------------------------------------------------|
| Python | match 变量： case 有关变量的条件： <代码块> case 有关变量的条件： <代码块> case _： # 匹配到其他情况 <代码块> |
| C++ | switch (变量) { case 有关变量的条件: { // 代码块 } ... default: { // 代码块 } } |

循环

break：退出循环；

continue：提前结束本轮循环，直接进入下一轮循环

两者通常搭配if语句使用
可迭代对象：list/tuple/dict/set等数据结构，range内建函数

|--------|------------------------------------------------------------------------------------------------------------------------------------|
| Python | （1）while循环 while 条件： 循环体 （2）for循环 for 循环变量 in 可迭代对象： 循环体 |
| C++ | （1）while while（循环条件） { // 循环体 } （2）do-while do { //循环体 } while（循环条件） （3）for for(循环变量初始值；循环条件；循环变量下一次进入循环的值) { // 循环体 } |

空语句

Python要保证语法格式的正确，提供一个空语句起占位功能

a = 10
if a < 10:
    pass

函数

Python函数语法详解（与C++对比学习）【未完】-CSDN博客

切片

用于取列表 list 、元组 tuple 、字符串str 的部分元素的操作符

使用方法：定义一个列表list

|-------------------|---------------------------|
| list [ n : m ] | 代表区间 [ n, m ) |
| list [ n : ] | 代表区间 [ n , len( list ) ) |
| list [ : m ] | 代表区间 [ 0, m ) |
| list [ n : -m ] | 代表区间 [ n , 倒数m ) |
| list [ : ] | 代表列表自身 |

切片时指定步长：

list [ n : m : L ] -> L为步长，不写默认为1，可正可负

【注】：当切片中的范围超出有效下标之后，不会抛异常，而是尽可能地把符合要求的元素获取到

迭代

通过for ... in 来完成迭代，in后面必须是可迭代对象

类似于C中的：

std::vector<int> v = {1, 2, 3, 4};
for(int i = 0; i < v.size(), ++i)
{
    //...
}

类似于C++的：

std::vector<int> v = {1, 2, 3};
for(auto e : v)
{
    //...
}

如何判断是否为可迭代对象？

如果是，输出True，反之输出False

from collections.abc import Iterable
isinstance(变量名, Iterable)

Python支持同时迭代两个及以上变量：

for x, y in [(1, 2), (3, 4), (5, 6)]:
    print(x, y)

生成器（generator ）表达式与列表推导式

生成器表达式用（），列表推导式用 [ ]

（expression for item in iterable if condition）

• expression 是对每个 item 进行的操作（可以是条件判断）或计算。
• item 是从 iterable 中取出的元素。
• iterable 是一个可迭代对象，如列表、元组、字符串、range等。
• condition （可选）是一个用于筛选 item 的条件。（不可有else）

【注】：

生成器表达式在需要时才生成值，不会一次性生成所有的值并存储在内存中。这样的好处在于，当我们认为需要100w个数据的时候，但一次性只使用几个，此时若用list列表来创建，则会浪费大量的空间，而生成器则是按需分配，不会浪费空间，大大提高了内存的利用率。

生成器表达式支持两层循环：可以完成全排列

lis = [x + y for x in 'ABC' for y in 'XYZ']
print(lis)

next()

调用一次next，就可以获取下一个生成器对象的值，但是通常使用for循环来获取

生成器函数

函数定义中包含yield关键字，调用一个生成器函数将返回一个生成器，可想而知，生成器函数也是按需分配的，通常与for循环搭配使用

【注】：

1. 普通函数是顺序执行，遇到return语句或者最后一行函数语句就返回。
2. generator的函数，在每次拿生成器函数的生成器对象中的值的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行

def obs():
    yield (i for i in range(1, 11))
    yield (i for i in 'asbcd')


for a in obs():
    for b in a:
        print(b)

迭代器与可迭代对象

可迭代对象（ Iterable ）：

可以直接作用于for循环的对象，如list、tuple、dict、set、str、range、generator（生成器对象）

迭代器（Iterator ）：

可以被next()函数调用并不断返回下一个值的对象，如generator（生成器对象）

判断是否为可迭代对象或迭代器：

isinstance(变量名, Iterable) #是否为可迭代对象
isinstance(变量名, Iterator) #是否为迭代器

iter()函数

将 可迭代对象Iterable变成 迭代器Iterator，不改变原来的可迭代对象的属性，是通过可迭代对象重新创建一个新的迭代器

模块 与 C++的头文件

|----------------------------------------------------|-------------------------------------------------------------------------|
| Python | C++ |
| import module_name m = module_name.method | #include <iostream> std::cout << " hello " << std::endl; |
| from module_name import module_name m = method | #include <iostream> using namespace std; cout << "hello" << endl; |
| import module_name as new_name m = new_name.method | #include <iostream> #define S std; S::cout << "hello" << S::endl; |

【注】：

在编写一个模块的时候，如果有的函数不希望被外部访问，就要设置前缀为_或者__，但是这也是给程序员一个非强制性约束，只是不希望你用，而不是不可以使用。

Python的类和对象

Python的类和对象（与C++对比学习）-CSDN博客