一、前言：为什么用 C++ 的视角学 Python
很多同学是先从 C / C++ 入门，再来学 Python 的。这两门语言的设计哲学差异非常大：
- C++ 强调性能与控制，变量的类型在编译期就固定死了，编译器替你"把关"，写错了直接编译报错。
- Python 强调简洁与开发效率，变量的类型在运行时才确定，怎么写都行，写错了运行时报错。
| | 维度 | Python | C++ | 简单解释 | |---------|------------|------------------|------------------------------| | 编译 / 解释 | 解释型 | 编译型 | Python 逐行翻译执行；C++ 先整体编译成机器码 | | 类型绑定 | 动态类型 | 静态类型 | Python 运行时才定类型还能中途变；C++ 声明定死 | | 类型检查 | 强类型 | 偏强（有隐式转换） | Python 不自动转类型；C++ 会偷偷帮你转 | | 编程范式 | 面向对象为主、多范式 | 面向过程 + 面向对象 + 泛型 | Python 隐藏底层细节；C++ 能直接操作指针内存 | |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
正因为差异大，学 Python 最忌讳"照着 C++ 的思维硬套"。这篇文章把课程笔记里每一个知识点都和 C++ 做对比，哪里有区别，就同时给出**Python 和 C++**两段代码，让你"边找不同边记语法"。对于课程里一句带过的内容（位运算、身份运算符、成员运算符等），我也做了补充，保证覆盖全面。
先看一张总览对比表，后面再逐个展开：
| 知识点 | Python | C++ |
|---|---|---|
| 定义变量 | a = 10（不用写类型） |
int a = 10;（必须写类型） |
| 类型系统 | 动态类型（运行时可变） | 静态类型（编译期固定） |
| 整数范围 | 无上限（内存够就行） | 固定范围（一般 4 字节） |
| 除法 | 1 / 2 结果是 0.5 |
1 / 2 结果是 0（整数截断） |
| 整除 | //（向下取整） |
直接 /（向零截断） |
| 乘方 | ** |
没有运算符，用 pow() |
| 逻辑运算符 | and or not |
&& ` |
| 逻辑运算结果 | 返回操作数本身（不一定是布尔） | 只返回 bool |
| 字符串比较 | 直接 == |
std::string 可 ==；C 风格字符串要 strcmp |
| 连续比较 | a < b < c 直接写 |
必须拆开 a < b && b < c |
| 自增自减 | 不支持 ++ --，用 += 1 |
支持 ++ --（还有前置后置之分） |
| 变量交换 | a, b = b, a |
用临时变量或 std::swap |
| 控制台输入 | input() 返回字符串 |
std::cin >> 直接读进类型化变量 |
| 控制台输出 | print(a, b) |
std::cout << a << " " << b; |
| 布尔值写法 | True False |
true false |
二、常量和表达式
2.1 什么是"表达式"
在编程里，1 + 2 - 3 这种算式称为表达式 ，算出来的结果叫表达式的返回值 ；其中 1、2、3 这种直接写出来的数据叫字面值常量 ，+ - * / 这种符号叫运算符（操作符）。
Python 可以直接把解释器当计算器用：
python
print(1 + 2 - 3) # 0
print(1 + 2 * 3) # 7 先乘除后加减
print((1 + 2) * 3) # 9 括号改变优先级注意：Python 里运算符和数字之间有没有空格、有几个空格都无所谓（1+2 和 1 + 2 等价），但为了美观，习惯上写一个空格。
2.2 关键差异：除法 /
这一条 C 系选手最容易踩坑。在 C++ 里，两个整数相除，小数部分直接截断 ；在 Python 里，/ 永远返回浮点数，更符合日常直觉。
python
# Python
print(1 / 2) # 0.5 不会截断成 0
print(5 / 2) # 2.5
print(10 / 4) # 2.5
cpp
// C++
int a = 1, b = 2;
std::cout << a / b << std::endl; // 0 整数除法，小数截断
std::cout << 5.0 / 2 << std::endl; // 2.5 只要有一边是浮点数，结果就是浮点数记忆口诀 ：Python 的
/永远做"真除法"；C++ 的/只有在两边都是整数时才做"整数除法"。
2.3 示例：求平均值
python
# Python：四个分数求平均
print((67.5 + 89.0 + 12.9 + 32.2) / 4) # 50.400000000000006（为什么会多个小尾巴？这就是后面 6.2.2 节要讲的浮点数精度问题，先留个印象。）
cpp
// C++：同样的逻辑
double avg = (67.5 + 89.0 + 12.9 + 32.2) / 4;
std::cout << avg << std::endl; // 50.4三、变量和类型
3.1 变量是什么
计算稍微复杂一点时，需要把中间结果保存下来，这就用到了变量 。比如求四个分数的方差，得先算出平均值 avg 存起来：
python
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg) ** 2
result = total / 3
print(result)可以把变量理解成内存里的一块空间 （就像宿舍楼里的房间），每个房间有名字、能存数据。avg、total、result 就是三个变量。
3.2 定义变量：类型声明是最大区别
Python 定义变量极其简单，不需要写类型：
python
a = 10 # 不用写 int，解释器自己知道是整数
name = 'Tom' # 不用写 stringC++ 必须先声明类型：
cpp
int a = 10; // 必须写 int
std::string name = "Tom"; // 必须写 std::string为什么？ C++ 要在编译期就知道变量占几个字节、能做什么操作；Python 是解释执行的，运行时看到赋了什么值再"猜"类型，所以可以省掉类型声明。
3.3 变量命名规则
两门语言的硬性规则基本一致：
- 变量名由数字、字母、下划线构成
- 数字不能开头
- 不能和关键字重复
- 大小写敏感 （
num和Num是两个变量）
软性规范也相通：名字要"见名知义"，多个单词组合起来（totalCount、personInfo）。
补充小知识 ：Python 官方规范 PEP 8 更推荐用
snake_case（全小写 + 下划线，如total_count），而 C++ 习惯用驼峰（totalCount）。课程里示例用驼峰也没问题，但面试或写正式项目时，Python 风格请尽量用下划线命名。
3.4 使用变量：读取与修改
python
a = 10
print(a) # 读取：10
a = 20 # 修改：直接再赋一次值
print(a) # 20注意：Python 里定义变量和修改变量用的都是 =，语法上没区别，这点和 C++ 一样。也支持用一个变量给另一个变量赋值：
python
a = 10
b = a
print(b) # 103.5 数据类型对比
Python 内置的几种基本类型：
python
# Python：用 type() 查看类型
a = 10
print(type(a)) # <class 'int'>
a = 0.5
print(type(a)) # <class 'float'>
a = 'hello'
print(type(a)) # <class 'str'>
a = True
print(type(a)) # <class 'bool'>
cpp
// C++：类型写在声明里，编译器会校验
int a = 10; // 4 字节，范围约 -21 亿 ~ 21 亿
float f = 0.5f; // 单精度，约 4 字节
double d = 0.5; // 双精度，约 8 字节
bool flag = true; // 小写 true/false3.5.1 重点差异一：Python 的 int 没有上限
C++ 的 int 一般占 4 字节，最大值约 21.47 亿，超出就溢出（甚至属于未定义行为）：
cpp
// C++：int 溢出
int a = 2147483647;
a = a + 1; // 溢出，结果变成 -2147483648（未定义行为）Python 的 int 只要内存够，想多大就多大：
python
# Python：任意大整数
print(10 ** 30) # 1000000000000000000000000000000，照算不误3.5.2 重点差异二：Python 没有单独的"字符类型"
C++ 里有 char，一个字符占一字节；Python 里 'a' 和 "hello" 都是 str，没有单字符类型。而且 Python 的单引号和双引号完全等价，'hello' 和 "hello" 没有任何区别。字符串拼接用 +：
python
a = 'hello'
b = 'world'
print(a + b) # helloworld
print(len(a)) # 5
cpp
// C++
std::string a = "hello";
std::string b = "world";
std::cout << a + b << std::endl; // helloworld
std::cout << a.size() << std::endl; // 5注意：两门语言里字符串都不能直接和整数相加 。Python 的 'a' + 10 会直接抛 TypeError；C++ 的 std::string + 整数 则是编译报错（没有对应的 operator+ 重载）。C++ 里 std::string 可以 + 单个字符（s + 'a' 合法），这算是小差异。
3.6 动态类型 vs 静态类型
这是 Python 和 C++ 最本质的区别之一。
Python 是动态类型：一个变量的类型在程序运行过程中可以改变。
python
a = 10
print(type(a)) # <class 'int'>
a = 'hello'
print(type(a)) # <class 'str'> ← 类型变了！合法C++ 是静态类型：变量一旦定义，类型就固定了，再赋别的类型直接编译报错。
cpp
int a = 10;
a = "hello"; // 编译错误：不能把 const char* 赋给 int动态类型是一把双刃剑：
- 优点：中小型程序写起来快，一段代码能同时处理多种类型（比如一个函数既能传整数又能传字符串）。
- 缺点：大型项目里，A 同事写的代码 B 同事看不懂到底传进来什么类型，协作成本高。所以很多大型 Python 项目后来都引入了"类型注解"（type hints）。
3.7 类型转换
Python 用内置函数转类型：int()、float()、str()、bool()。
python
s = "10"
num = int(s) # 字符串 → 整数，num = 10
f = float("3.14") # 字符串 → 浮点数
t = str(123) # 整数 → 字符串 "123"C++ 用强制类型转换或流方式：
cpp
std::string s = "10";
int num = std::stoi(s); // C++11，字符串 → 整数
int num2 = static_cast<int>(3.99); // 浮点 → 整数，结果是 3（截断）注意**
int("3.14")**在 Python 里会报错（无法直接转换带小数点的字符串），要先用float()。C++ 的static_cast<int>(3.99)则是直接截断小数位。
四、注释
注释不会被程序执行，只是给人看的，帮自己和别人理解代码。两门语言的单行注释符号不同：
python
# Python：井号注释
# 计算四个数字的方差
avg = 10
cpp
// C++：双斜杠注释
// 计算四个数字的方差
int avg = 10;多行注释 / 文档注释：
python
# Python：三引号（文档字符串，也可以当作多行注释）
"""
这里是多行说明
可以写很多行
"""
cpp
/* C++：块注释
这里是多行说明
可以写很多行 */补充两条写注释的规范（两门语言通用）：
- 内容要准确：注释必须和代码一致，代码改了注释要同步改。
- 篇幅要合理：既不能不写，也不要长篇大论；中文团队一般要求用中文写。
五、输入输出
5.1 输出：print vs std::cout
Python 用 print() 输出，可以一次打印多个值，默认用空格分隔：
python
print(1, 2, 3) # 1 2 3
print('hello') # hello
num = 10
print(num) # 10C++ 用流输出，每个值之间要靠 << 手动连接，分隔符也要自己写：
cpp
std::cout << 1 << " " << 2 << " " << 3 << std::endl; // 1 2 3Python 的 print 还支持自定义分隔符和结尾：
python
print(1, 2, 3, sep='-') # 1-2-3
print(1, 2, 3, sep='-', end='!\n') # 1-2-3!对应记忆 ：
print(a, b)≈ C++ 的std::cout << a << " " << b;。
5.2 格式化输出：f-string vs C++
Python 最常用的是 f-string ，在字符串前加 f，用 {} 内嵌变量或表达式：
python
num = 10
print(f'num = {num}') # num = 10
print(f'3 的平方是 {3 ** 2}') # 3 的平方是 9C++ 对应写法（printf 或流）：
cpp
int num = 10;
printf("num = %d\n", num); // C 风格
std::cout << "num = " << num << std::endl; // C++ 流风格5.3 输入：input vs std::cin
这是新手最常踩的坑 ：Python 的 input() 返回的一定是字符串，想做算术运算必须先转类型！
python
num = input('请输入一个整数: ') # 用户输入 10，num 是字符串 "10"
print(f'你输入的是 {num}')
# 下面这样是错的：字符串拼接，不是加法
a = input('请输入第一个整数: ')
b = input('请输入第二个整数: ')
print(f'a + b = {a + b}') # 输入 3 和 4，结果是 "34" 不是 7
# 正确写法：先转换类型
a = int(input('请输入第一个整数: '))
b = int(input('请输入第二个整数: '))
print(f'a + b = {a + b}') # 7C++ 的 std::cin 会根据变量的类型自动转换，不需要手动转：
cpp
int num;
std::cin >> num; // 直接读成 int，无需转换
int a, b;
std::cin >> a >> b; // 一次读两个，空格/回车分隔
std::cout << "a + b = " << a + b << std::endl; // 7总结差异 ：C++ 的
cin >>是"喂给类型化变量"，读进来就是那个类型；binpt()永远给字符串，一切类型转换都得自己动手。这也体现了 Python "少魔法、多显式"的设计。
5.4 综合示例：输入 4 个小数求平均值
python
a = float(input('请输入第一个数字: '))
b = float(input('请输入第二个数字: '))
c = float(input('请输入第三个数字: '))
d = float(input('请输入第四个数字: '))
avg = (a + b + c + d) / 4
print(f'平均值: {avg}')
cpp
#include <iostream>
int main() {
double a, b, c, d;
std::cin >> a >> b >> c >> d;
double avg = (a + b + c + d) / 4;
std::cout << "平均值: " << avg << std::endl;
return 0;
}六、运算符
6.1 算术运算符
两门语言共有的：+ - * / %（取余）。Python 独有：**（乘方）和 //（整除）。
| 运算符 | Python | C++ | 说明 |
|---|---|---|---|
+ - * |
支持 | 支持 | 用法一致 |
/ |
真除法，结果一定是浮点数 | 整数/整数截断 | 见 2.2 节 |
% |
取余（结果符号跟除数） | 取余（结果符号跟被除数） | 负数时结果不同！见下 |
** |
乘方，支持小数次方 | 没有 ，用 pow() |
Python 独有 |
// |
向下取整整除 | 没有 ，整数 / 是向零截断 |
Python 独有 |
乘方对比：
python
# Python
print(4 ** 2) # 16
print(4 ** 0.5) # 2.0 还能算小数次方
cpp
// C++
#include <cmath>
std::cout << std::pow(4, 2) << std::endl; // 16
std::cout << std::sqrt(4) << std::endl; // 2 开方整除 // 的"向下取整"到底是什么意思？
// 是地板除（floor division） ，结果是往负无穷 方向取整，而不是往零取整。这和 C++ 的整数除法（往零截断）在负数场景下结果完全不同，是高频考点：
python
# Python
print(7 // 2) # 3
print(-7 // 2) # -4 注意！不是 -3
cpp
// C++：整数除法向零截断
int x = -7 / 2; // x = -3 （不是 -4！）为什么不一样？
-7 / 2的数学结果是-3.5。Python 的//向负无穷取整 →-4；C++ 的整数除法向零取整 →-3。 同理，取余%的负数结果也两套逻辑：
python# Python：结果符号跟随除数 print(-7 % 2) # 1 因为 -7 = 2 * (-4) + 1 print(7 % -2) # -1
cpp// C++：结果符号跟随被除数 std::cout << -7 % 2 << std::endl; // -1 因为 -7 = 2 * (-3) - 1两门语言都满足恒等式
a == (a // b) * b + (a % b)，只是对"整除"的定义不同。记住 Python 的结果永远非负（当除数为正时）即可。
除数为 0 的报错机制：两门语言都不允许除 0。
python
print(10 / 0) # ZeroDivisionError: division by zero
cpp
int x = 10 / 0; // 运行时崩溃 / 未定义行为6.2 关系运算符
< <= > >= == !=，两门语言写法完全一样，返回布尔值。
python
a, b = 10, 20
print(a < b) # True
print(a == b) # False
print(a != b) # True
cpp
int a = 10, b = 20;
std::cout << (a < b) << std::endl; // 1（C++ 的 bool 打印为 0/1）
std::cout << (a == b) << std::endl; // 06.2.1 字符串可以比较大小（字典序）
Python 直接支持字符串比较，规则是字典序（按字符的编码逐个比较，和查英语词典一个道理）：
python
print('hello' == 'world') # False
print('abc' < 'abd') # True 前两个字符相同，第 3 个 c < dC++ 的 std::string 也支持 == 和 <；但 C 风格的 char[] 必须用 strcmp：
cpp
#include <string>
std::string s1 = "hello", s2 = "world";
std::cout << (s1 == s2) << std::endl; // 0
// C 风格字符串：不能直接 ==（比的是地址），要 strcmp
char c1[] = "abc";
char c2[] = "abd";
int r = strcmp(c1, c2); // 负/0/正，对应小于/等于/大于易错点 ：C 语言里
char s1[] = "abc"; char s2[] = "abc"; s1 == s2比的是地址 而不是内容，永远是false。很多 C 系出身的同学在 Python 里一对比就懵，其实 Python 和 C++ 的std::string的==都是按内容比较的。
6.2.2 浮点数比较：千万不要用 ==（重点）
浮点数在计算机里是近似存储的（IEEE 754 标准），运算会产生极小的误差：
python
print(0.1 + 0.2) # 0.30000000000000004
print(0.1 + 0.2 == 0.3) # False ← 坑！数学上明明相等C++ 一样：
cpp
double a = 0.1 + 0.2;
double b = 0.3;
std::cout << (a == b) << std::endl; // 0（false）正确做法：比较差值是否在误差范围内，而不是严格相等。
python
# Python
a = 0.1 + 0.2
b = 0.3
print(abs(a - b) < 1e-9) # True
print(-0.000001 < (a - b) < 0.000001) # True ← 注意：Python 支持连续比较！
cpp
// C++
#include <cmath>
double a = 0.1 + 0.2, b = 0.3;
std::cout << (std::abs(a - b) < 1e-9) << std::endl; // 1（true）6.2.3 Python 独有的"连续比较"
Python 可以直接写 a < b < c，一次比较三个数，相当于"夹在中间"的判断：
python
a, b, c = 10, 20, 30
print(a < b < c) # TrueC++ 不支持 这种写法，必须拆开用 && 连接：
cpp
int a = 10, b = 20, c = 30;
std::cout << (a < b && b < c) << std::endl; // 16.3 逻辑运算符（重点）
6.3.1 写法对比
| 语义 | Python | C++ |
|---|---|---|
| 并且（一假则假） | and |
&& |
| 或者（一真则真） | or |
` |
| 取反 | not |
! |
python
# Python
a, b, c = 10, 20, 30
print(a < b and b < c) # True
print(a < b and b > c) # False
print(a > b or b > c) # False
print(not a < b) # False
cpp
// C++
int a = 10, b = 20, c = 30;
std::cout << (a < b && b < c) << std::endl; // 1
std::cout << (a < b && b > c) << std::endl; // 0
std::cout << (a > b || b > c) << std::endl; // 0
std::cout << (!(a < b)) << std::endl; // 06.3.2 短路求值（重点）
两门语言都遵循短路求值规则：
and/&&：左侧为假，结果必假，右侧不再执行。or/||：左侧为真，结果必真，右侧不再执行。
最经典的验证方法：让右侧写一个除以 0，如果被短路了就不会报错。
python
# Python：右侧 10/0 永远不会执行，所以不报错
print(4 > 7 and 10 / 0 == 1) # False（10/0 没被求值）
print(4 < 7 or 10 / 0 == 1) # True（10/0 没被求值）
cpp
// C++：同理，右侧被短路
bool r1 = (4 > 7) && (10 / 0 == 1); // false，不会触发除零
bool r2 = (4 < 7) || (10 / 0 == 1); // true，不会触发除零短路求值非常实用，常用于先判断、再取值 ，比如
if x is not None and x > 0:，保证不会因为x为空而报错。
6.3.3 深度差异：and / or 返回的是操作数，不是布尔值！
这是 Python 和 C++ 一个非常隐蔽、又很重要的区别。
- C++ 的
&&/||结果永远是bool（true/false）。 - Python 的
and/or返回的是某个参与运算的对象本身 ：a and b：a为假返回a，a为真返回ba or b：a为真返回a，a为假返回b
python
print(0 and 5) # 0 0 是假，返回 0
print(3 and 5) # 5 3 是真，返回 5
print(0 or 5) # 5 0 是假，返回 5
print('a' or 'b') # 'a' 'a' 非空即真，返回 'a'这个特性经常被用来写"默认值"：
python
name = input('请输入姓名: ') or '匿名用户'
print(f'你好，{name}') # 用户没输入，就显示"匿名用户"6.3.4 深度差异：Python 里的"真值"概念
C++ 里 && || ! 严格要求 bool 操作数（其它类型要自己转）；
Python 里任何对象都可以直接当布尔用，有一套"真值判定"规则：
- 判定为假 的常见对象：
0、0.0、''（空字符串）、[]（空列表）、None - 其余基本都判定为真
python
if '': # 空字符串 → False，不执行
print('不会执行')
if 'hello': # 非空 → True，执行
print('会执行')
if []: # 空列表 → False
print('不会执行')C++ 则要显式写条件，比如判断指针/容器是否为空：
cpp
int* p = nullptr;
if (p) { } // C++ 指针可以直接当 bool 用（nullptr 为假）
std::string s = "";
if (!s.empty()) { } // 字符串要调用 empty()6.4 赋值运算符
6.4.1 链式赋值：a = b = 10
Python 和 C++ 都支持，把同一个值赋给多个变量，从右往左依次赋值：
python
# Python
a = b = 10
print(a, b) # 10 10
cpp
// C++
int a, b;
a = b = 10; // 先 b = 10，再 a = 106.4.2 多元赋值：a, b = 10, 20（Python 独有）
Python 可以一行给多个变量赋不同的值，左边是变量元组，右边是对应的值元组：
python
a, b = 10, 20
print(a, b) # 10 20C++ 没有 这个语法，只能分开写或用 std::tie：
cpp
int a = 10, b = 20;
// 或者
std::tie(a, b) = std::make_tuple(10, 20);6.4.3 变量交换（重点）
传统写法（借助临时变量，两门语言通用）：
python
# Python
tmp = a
a = b
b = tmp
cpp
// C++
int tmp = a;
a = b;
b = tmp;
// 或者用标准库
std::swap(a, b);Python 特有写法（利用多元赋值，一行搞定）：
python
a, b = b, a # 右侧先把 (b, a) 打包，再解包给 a, b
print(a, b)这个写法能生效的原理：右边的
b, a会先求值打包成一个元组，再整体赋给左边。所以不存在"先改了 a 导致 b 取错"的问题，也不需要临时变量。
6.4.4 复合赋值运算符
+= -= *= /= %= 等，两门语言含义一致：a += 1 等价于 a = a + 1。
python
# Python
a = 10
a += 1
print(a) # 11
cpp
// C++
int a = 10;
a += 1;
std::cout << a << std::endl; // 116.4.5 重点差异：Python 不支持 ++ --！
C++ 里 ++ / -- 有前置 和后置之分，极易混淆：
cpp
int a = 10;
int x = a++; // 后置：先取 a 的值 10 赋给 x，再自增 → x = 10, a = 11
int y = ++a; // 前置：先自增再取 a 的值 → a = 12, y = 12Python 故意砍掉了 ++ --，因为前置后置太容易出错，不符合 Python 追求简洁直观的理念。需要自增自减时，直接用复合赋值：
python
# Python：不支持 a++ 或 ++a，会语法报错
a += 1 # 正确
a -= 1 # 正确注意一个坑：Python 里
++a不会报语法错 ，但它是+(+a)，也就是对a连续取两次正号，值不变！新手看到不报错就以为自增成功了，其实a根本没变。调试时尤其要小心。
6.5 位运算符
两门语言的位运算符符号完全一样 ：&（按位与）、|（按位或）、~（按位取反）、^（按位异或）、<<（左移）、>>（右移）。
以 a = 5（二进制 0101）、b = 3（二进制 0011）为例：
python
# Python
a, b = 5, 3
print(a & b) # 1 0101 & 0011 = 0001
print(a | b) # 7 0101 | 0011 = 0111
print(a ^ b) # 6 0101 ^ 0011 = 0110（相同为0，不同为1）
print(~a) # -6 按位取反：~5 = -6
print(a << 1) # 10 左移1位：0101 → 1010，相当于 ×2
print(a >> 1) # 2 右移1位：0101 → 0010，相当于 ÷2
cpp
// C++
int a = 5, b = 3;
std::cout << (a & b) << std::endl; // 1
std::cout << (a | b) << std::endl; // 7
std::cout << (a ^ b) << std::endl; // 6
std::cout << (~a) << std::endl; // -6
std::cout << (a << 1) << std::endl; // 10
std::cout << (a >> 1) << std::endl; // 2常用技巧（面试高频）：
- 判断奇偶：
x & 1（为 1 是奇数，为 0 是偶数），比x % 2更快。 - 乘 2 / 除 2：
x << 1/x >> 1。 - 交换两个数：
a ^= b; b ^= a; a ^= b;（了解即可，实际开发用多元赋值更清晰）。
位运算对比小差异 ：Python 的整数是无限位宽 的，对负数做
>>是算术右移（高位补 1），C++ 对有符号负数的右移行为由实现决定（现代编译器基本也是算术右移）。日常正数运算两者表现一致，不必深究，知道有这回事即可。
6.6 身份运算符 is / is not
is 比较的是是不是同一个对象（内存地址），和比较值相等 的 == 是两码事：
python
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b) # True 值相等（内容一样）
print(a is b) # False 不是同一个对象（内存地址不同）
c = a
print(a is c) # True 指向同一个对象
cpp
// C++ 的对应概念：比较地址 与 比较值
int x = 5;
int* p1 = &x;
int* p2 = &x;
std::cout << (p1 == p2) << std::endl; // 1 指向同一块地址
std::cout << (*p1 == *p2) << std::endl; // 1 指向的值相等经典坑 ：
a is None判断是否为空；a == None判断值是否相等。判空习惯用is None。另外小整数在 Python 里会被缓存，a = 1; b = 1; a is b可能为True，但这属于实现细节，不要依赖is比较整数 ，要判断值就用==。
6.7 成员运算符 in / not in（补充）
判断某个元素在不在一个容器（字符串、列表、元组）里：
python
print('a' in 'hello') # False
print('l' in 'hello') # True
print(3 in [1, 2, 3]) # True
print(5 not in [1, 2, 3]) # TrueC++ 没有 in 关键字，需要自己查找：
cpp
#include <string>
#include <algorithm>
std::string s = "hello";
bool has_l = s.find('l') != std::string::npos; // true
int arr[] = {1, 2, 3};
bool has_3 = std::find(std::begin(arr), std::end(arr), 3) != std::end(arr); // true6.8 运算符优先级
整体优先级和 C++ 高度相似，从高到低大致为：
| 优先级 | Python | C++ |
|---|---|---|
| 高 | ** 乘方 |
++ -- ! ~ |
~ + -（一元） |
* / % |
|
* / // % |
+ - |
|
+ - |
<< >> |
|
<< >> |
< <= > >= |
|
& ^ ` |
` | |
< <= > >= |
& ^ ` |
|
== != |
&& |
|
| 低 | not |
` |
and |
赋值 | |
or |
逗号 |
差别最大的一个：Python 里
**优先级高于一元负号，所以-3 ** 2的结果是-9（先算3**2再取负），而 C++ 里没有乘方运算符，不存在这个纠结。 实战建议：别硬背优先级，拿不准就加括号，代码可读性永远第一。
七、总结：一张表记住所有差异
| 场景 | Python | C++ |
|---|---|---|
| 定义变量 | a = 10 |
int a = 10; |
| 类型是否可变 | 动态，运行时可变 | 静态，编译期固定 |
| 整数范围 | 无上限 | 固定范围，会溢出 |
| 浮点类型 | 只有 float（≈ double） |
float / double 都有 |
| 字符类型 | 没有，单字符也是 str |
有 char |
除法 / |
永远真除法，返回浮点数 | 整数/整数截断为 0 |
| 整除 | // 向下取整 |
整数 / 向零截断 |
| 取余（负数） | 符号跟除数（结果非负） | 符号跟被除数 |
| 乘方 | ** |
pow() |
| 字符串比较 | 直接 ==，字典序 |
std::string 可 ==；char* 用 strcmp |
| 浮点相等 | 用误差范围判断 | 同左 |
| 连续比较 | a < b < c |
a < b && b < c |
| 逻辑运算符 | and / or / not |
&& / ` |
| 逻辑返回 | 返回操作数本身 | 只返回 bool |
| 短路求值 | 有 | 有 |
| 链式赋值 | a = b = 10 |
支持 |
| 多元赋值 | a, b = 10, 20 |
不支持，要 std::tie |
| 交换变量 | a, b = b, a |
std::swap(a, b) |
| 自增自减 | 不支持 ++ -- |
支持，有前置后置 |
| 位运算 | `& | ~ ^ << >>` |
| 身份比较 | is / is not |
指针比较地址 |
| 成员判断 | in / not in |
std::find / find() |
| 输入 | input() 返回字符串 |
std::cin >> 自动转类型 |
| 输出 | print(a, b) 默认空格分隔 |
std::cout << a << " " << b; |
| 格式化输出 | f-string：f'{x}' |
printf / 流拼接 |
| 布尔写法 | True / False |
true / false |
| 注释 | # 与 """ """ |
// 与 /* */ |
一句话总结两门语言的哲学差异：
C++ 是"铁板钉钉"------类型、内存、运算符行为都在编译期定死，性能可控但写起来啰嗦、容易踩底层坑；Python 是"随遇而安"------类型动态推断、语法追求简洁直观，砍掉了
++ --这种容易混淆的特性，开发效率高，适合把精力放在解决问题本身。
八、自测练习（答案见文末）
-
（多选）以下关于变量加法的说法，正确的是？
- A. Python 中字符串之间可以相加（拼接）
- B. Python 中字符串可以和整数相加
- C. Python 中整数可以和浮点数相加
- D. Python 中整数可以和布尔值相加
-
（单选）以下关于类型的说法，正确的是？
- A. Python 中既有字符串类型，也有字符类型
- B. Python 中既有
float，也有double - C. Python 中既有
int，也有long - D. Python 中的整数表示范围无上限
-
（单选）以下 Python 代码，合法的是？
- A.
int a = 10 - B.
a = 10; - C.
a = true - D.
a = 'aaa' + 10
- A.
-
（单选）
print(-7 // 2)的输出是？- A.
-3 - B.
-4 - C.
-3.5 - D.
-4.0
- A.
-
（单选）
print(4 > 7 and 10 / 0 == 1)的运行结果是？- A. 抛出除零异常
- B.
False - C.
True - D.
None
-
（单选）执行
a, b = 10, 20后，a, b = b, a，此时a和b的值是？- A.
10, 20 - B.
20, 10 - C.
10, 10 - D. 报错
- A.
参考答案
-
ACD （B 错：字符串不能和整数相加，
'a' + 10抛TypeError。D 对：因为bool是int的子类，整数和布尔可以相加，1 + True结果是2）# A 对：'ab' + 'cd' → 'abcd' # C 对：1 + 0.5 → 1.5 # D 对：1 + True → 2（bool 是 int 的子类） # B 错：'a' + True → TypeError -
D （A 错：Python 没有
char；B 错：Python 只有float，没有double；C 错：Python 只有int，没有long） -
B （A 错：Python 不用写类型；B 对：
a = 10;完全合法，分号可有可无；C 错：布尔要写True大写；D 错：字符串不能加整数） -
B （
//向下取整，-3.5往负无穷方向取整是-4，和 C++ 的向零截断-3不同） -
B （
and左侧4 > 7为假，短路求值，右侧10 / 0不执行，结果直接是False） -
B （右侧
(b, a)先打包成元组再解包，交换成功）
下篇预告 ：学完变量和运算符，下一章就是逻辑判断（
if/elif/else）和循环（for/while），到时候我们继续和 C++ 对比着学。