06 python 运算符什么时运算符？ 4 和 5 被称为操作数，+ 称为运算符。 python 有以下运算符：算术

什么时运算符？

4 + 5 = 9

4 和 5 被称为操作数，+ 称为运算符。 python 有以下运算符：

算术运算符
比较（关系）运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符
运算符优先级

算术运算符

运算符	描述	实例（假设 `a=10，b=21`）	详细说明 & 使用场景 & 注意事项
`+`	加 - 两个对象相加	`a + b` → 31；`"abc"+"def"` → `"abcdef"`	1. 数值：普通加法运算（int/float/complex 均支持）；2. 字符串：拼接；3. 列表 / 元组：合并（如 `[1,2]+[3,4]` → `[1,2,3,4]`）；注意：不同类型（如 int + 字符串）直接相加报错。
`-`	减 - 求负数 / 一个数减去另一个数	`a - b` → -11；`-a` → -10；`2.5-1.2` → 1.3	1. 数值：普通减法运算；2. 单目运算：`-x` 求负数；3. 仅支持数值类型，字符串 / 列表等不支持减法；注意：浮点数减法可能有精度误差（如 `0.3-0.1≠0.2`）。
`*`	乘 - 两数相乘 / 序列重复指定次数	`a * b` → 210；`"ab"3` → `"ababab"`；`[1]3` → `[1,1,1]`	1. 数值：普通乘法（支持复数，如 `(1+2j)(3+4j)` → `-5+10j`）；2. 字符串 / 列表 / 元组：重复 n 次；注意：序列重复时，可变对象（如列表）是浅拷贝（`[[1]]2` 两个元素指向同一列表）。
`/`	除 - x 除以 y（结果恒为浮点数）	`b / a` → 2.1；`10/3` → 3.3333333333333335；`10/2` → 5.0	1. 结果必为浮点数（即使整除也带 `.0`）；2. 除数不能为 0（报错 `ZeroDivisionError`）；3. 支持负数除法（`-10/3` → -3.333...）。
`%`	取模 - 返回除法的余数（模运算）	`b % a` → 1；`10%3` → 1；`-10%3` → 2；`10%-3` → -2	1. 核心规则：`x = (x//y)*y + x%y`；2. 常用场景：判断奇偶（`x%2==0`）、循环周期（`x%n`）、取余数；注意：负数取模结果符号与除数一致（如 `-10%3=2`，除数 3 为正，结果为正）。
`**`	幂 - 返回 x 的 y 次幂	`ab` → 10²¹；`23` → 8；`40.5` → 2.0；`10-2` → 0.01	1. 支持整数 / 浮点数幂运算（如开平方 `x0.5`、倒数 `x-1`）；2. 复数也支持（如 `(1+2j)2` → `-3+4j`）；注意：超大数幂运算（如 `101000`）会生成大整数，占用内存。
`//`	取整除 - 向下取整（往小的方向取最接近的整数）	`9//2` → 4；`-9//2` → -5；`10//3` → 3；`-10//3` → -4；`10.5//2` → 5.0	1. 核心：无论正负，结果 “向下取整”（如 `-9//2` 取 - 5 而非 - 4）；2. 整数相除结果为 int，浮点数相除结果为 float；3. 除数不能为 0；场景：分页计算（总条数 // 每页条数）、整数拆分。

关键知识点

取整除 // 与普通除法 / 的核心区别

# 正数场景 
print(10/3) # 3.3333333333333335（浮点数，保留小数） 
print(10//3) # 3（向下取整，整数）

# 负数场景（重点！新手易踩坑） 
print(-10/3) # -3.3333333333333335（浮点数） 
print(-10//3) # -4（向下取整，比-3.33更小的整数是-4）

取模 % 的实用场景示例

x = 7 
if x % 2 == 0: 
    print("偶数") 
else: 
    print("奇数") # 输出：奇数 

# 场景2：循环周期（如0-9循环） 
for i in range(15):
    print(i % 10, end=" ") # 输出：0 1 2 3 4 5 6 7 8 9 0 1 2 3 4

# 场景3：拆分数字（如123拆为1、2、3） 
num = 123 
units = num % 10 # 个位：3 
tens = (num // 10) % 10 # 十位：2 
hundreds = num // 100 # 百位：1

幂运算 ** 的特殊用法

# 开平方（等价于math.sqrt()）
print(16**0.5) # 4.0 # 开立方 
print(8**(1/3)) # 2.0 # 倒数（等价于1/x） 
print(5**-1) # 0.2

小结

核心运算符规则：
- +/-/* 支持数值 + 序列（仅特定场景），/ // % ** 仅支持数值；
- // 是向下取整（负数场景需注意），/ 结果恒为浮点数；
- % 取模结果符号与除数一致，而非被除数。
实用场景：
- % 用于奇偶判断、循环周期；
- // 用于分页、整数拆分；
- ** 用于幂 / 开方运算；
- +/* 用于字符串 / 列表拼接 / 重复。

比较运算符

运算符	描述	实例（假设 `a=10，b=21`）	详细说明 & 实战场景 & 注意事项
`==`	等于 - 比较两个对象的值是否相等（值比较）	`a == b` → False；`10 == 10.0` → True；`"abc" == "abc"` → True	1. 核心：仅比较 “值”，不比较类型（如 int 和 float 值相等则返回 True）；2. 实战场景：- 判断用户输入是否为指定值（`input_num == 0`）；- 验证函数返回值是否符合预期；3. 注意：- 列表 / 字典等可变对象：`[1,2] == [1,2]` → True（值相等）；- `None == 0` → False（None 仅等于自身）。
`!=`	不等于 - 比较两个对象的值是否不相等	`a != b` → True；`10 != 10.0` → False；`"a" != "A"` → True	1. 是 `==` 的反向操作；2. 实战场景：- 判断用户输入是否为非法值（`user_input != ""`）；- 循环终止条件（`count != 10`）；3. 注意：`!=` 优先级低于算术运算符（如 `10+2 != 11` → True，先算 10+2=12，再比较）。
`>`	大于 - 判断左值是否大于右值	`a > b` → False；`21 > 10` → True；`3.14 > 3` → True	1. 仅支持可比较类型（数值、字符串、有序序列）；2. 实战场景：- 判断数值范围（`score > 60` 判定及格）；- 字符串比较（按 Unicode 编码：`"b" > "a"` → True）；3. 注意：不同类型（如 int 和字符串）直接比较报错（`10 > "20"` → TypeError）。
`<`	小于 - 判断左值是否小于右值	`a < b` → True；`-5 < 0` → True；`"abc" < "abd"` → True	1. 字符串 / 列表比较规则：逐元素对比（如 `"abc" < "abd"` 先比 a==a，再比 b==b，最后 c<d → True）；2. 实战场景：- 分页判断（`page < total_page` 继续翻页）；- 列表排序辅助（自定义比较逻辑）；3. 注意：浮点数比较需考虑精度（`0.1+0.2 < 0.3` → False，因 0.1+0.2≈0.30000000000000004）。
`>=`	大于等于 - 判断左值是否大于或等于右值	`a >= b` → False；`10 >= 10` → True；`21 >= 10` → True	1. 包含 “等于” 的情况（`>=` = `>` + `==`）；2. 实战场景：- 判断年龄是否成年（`age >= 18`）；- 数据筛选（`salary >= 5000`）；3. 注意：`>=` 是连续符号，不能拆分（如 `a > = b` → 语法错误）。
`<=`	小于等于 - 判断左值是否小于或等于右值	`a <= b` → True；`10 <= 9` → False；`0 <= 0` → True	1. 包含 “等于” 的情况（`<=` = `<` + `==`）；2. 实战场景：- 限流判断（`request_count <= 1000` 允许请求）；- 数值边界校验（`0 <= num <= 100` 判定合法范围）；3. 注意：Python 支持连续比较（`0 < a < 20` 等价于 `a>0 and a<20`，更简洁）。

实战技巧

连续比较

a = 15 # 常规写法（其他语言）：
if a > 10 and a < 20: 
# Python优化写法： 
if 10 < a < 20: 
    print("a在10-20之间") 
    # 输出：a在10-20之间 
    # 支持混合运算符 
if 0 <= score <= 100: 
    print("分数合法") 
else: 
    print("分数非法")

2.字符串 / 列表的比较

# 1. 字符串比较（按Unicode编码，常用于排序、筛选）
str1 = "python" 
str2 = "Java"
print(str1 > str2) # True（'p'的编码112 > 'J'的编码74） 
# 2. 列表比较（逐元素对比，常用于自定义排序） 
list1 = [1, 3, 2] 
list2 = [1, 2, 3] 
print(list1 > list2) # True（第2个元素3>2，后续无需比较） 
# 实战：筛选出列表中比指定值大的元素 
nums = [5, 12, 8, 20, 3] 
target = 10 
result = [num for num in nums if num > target] print(result) # 输出：[12, 20]

3.浮点数比较

浮点数因精度问题，直接用 == 比较易出错，需通过 “差值小于极小值” 判断：

# 错误示例：
a = 0.1 + 0.2 b = 0.3 
print(a == b) # False（a≈0.30000000000000004） 
# 正确方案：判断差值是否小于1e-9（极小值） 
if abs(a - b) < 1e-9: 
    print("a和b相等") # 输出：a和b相等 
else:
    print("a和b不相等")

4.is 与 == 的区别

很多新手会混淆 is（身份比较）和 ==（值比较），补充实战对比：

x = [1, 2] 
y = [1, 2] 
z = x 
print(x == y) # True（值相等） 
print(x is y) # False（不同对象，内存地址不同）
print(x is z) # True（同一对象，内存地址相同） 
# 特殊情况：小整数/短字符串会被缓存，is也返回True a = 10 b = 10 
print(a is b) # True（Python缓存-5~256的整数）

小结

核心规则：
- 比较运算符返回布尔值（True/False），可直接用于条件判断；
- Python 支持连续比较（a < b < c），简化多条件逻辑；
- == 比 “值”，is 比 “内存地址”，新手勿混淆。
实战要点：
- 浮点数比较需用 “差值小于极小值” 避免精度坑；
- 字符串 / 列表比较是 “逐元素对比”，按 Unicode / 元素值排序；
- 不同类型（如 int 和字符串）直接比较会报错，需先类型转换。
避坑提醒：
- 不要用 == 比较 None，用 is None（更高效且规范）；
- 比较运算符优先级低于算术运算符，高于赋值运算符。

赋值运算符

运算符	描述	实例（假设 `c=10，a=5`）	详细说明 & 实战场景 & 注意事项
`=`	简单赋值运算符 - 将右侧值 / 表达式结果赋给左侧变量	`c = a + b`（b=3 → c=8）；`d = [1,2]`	1. 核心：左侧必须是 “变量”（不能是常量 / 表达式，如 `10 = c` 报错）；2. 实战场景：- 初始化变量（`age = 18`）；- 接收函数返回值（`result = func()`）；3. 注意：- 可变对象赋值是 “引用传递”（`lst1 = [1,2]`，`lst2=lst1` 指向同一列表）；- 不可变对象赋值是 “值传递”（`a=10`，`b=a` 是独立值）。
`+=`	加法赋值运算符 - 左侧变量 += 右侧值 → 等价于变量 = 变量 + 右侧值	`c += a` → c=15；`s="ab"`，`s+="cd"` → s="abcd"`	1. 支持数值、字符串、列表（元组不可变，不支持）；2. 实战场景：- 循环累加（`total += num` 计算总和）；- 字符串拼接（避免 `s = s + "x"` 的低效写法）；3. 注意：`+=` 对列表是原地修改（`lst += [3]` 比 `lst = lst + [3]` 更高效）。
`-=`	减法赋值运算符 - 左侧变量 -= 右侧值 → 等价于变量 = 变量 - 右侧值	`c -= a` → c=5；`x=2.5`，`x-=1.2` → x=1.3`	1. 仅支持数值类型；2. 实战场景：- 计数递减（`count -= 1` 循环终止）；- 数值调整（`price -= discount` 计算折后价）；3. 注意：浮点数 `-=` 可能有精度误差（如 `x=0.3`，`x-=0.1` → 0.19999999999999998）。
`*=`	乘法赋值运算符 - 左侧变量 = 右侧值 → 等价于变量 = 变量右侧值	`c = a` → c=50；`s="ab"`，`s=3` → s="ababab"`	1. 支持数值、字符串、列表（重复）；2. 实战场景：- 批量生成序列（`lst = [0]`，`lst = 5` → [0,0,0,0,0]）；- 数值倍增（`num = 2` 实现翻倍）；3. 注意：列表 `=` 是浅拷贝（`lst=[[1]]`，`lst=2` → [[1],[1]]，两个元素指向同一列表）。
`/=`	除法赋值运算符 - 左侧变量 /= 右侧值 → 等价于变量 = 变量 / 右侧值	`c /= a` → c=2.0；`x=10`，`x/=3` → x≈3.3333`	1. 结果恒为浮点数（即使整除也带 `.0`）；2. 实战场景：- 平均值计算（`avg /= total`）；- 比例调整（`rate /= 100` 转百分比）；3. 注意：除数不能为 0（报错 `ZeroDivisionError`）。
`%=`	取模赋值运算符 - 左侧变量 %= 右侧值 → 等价于变量 = 变量 % 右侧值	`c %= a` → c=0；`x=11`，`x%=3` → x=2`	1. 核心：结果符号与除数一致；2. 实战场景：- 循环周期控制（`index %= len(lst)` 避免越界）；- 奇偶判断（`num %= 2` 后判断是否为 0）；3. 注意：负数取模 `x=-10`，`x%=3` → x=2（除数为正，结果为正）。
`**=`	幂赋值运算符 - 左侧变量 = 右侧值 → 等价于变量 = 变量右侧值	`c = a` → c=100000；`x=4`，`x=0.5` → x=2.0`	1. 支持整数 / 浮点数幂运算；2. 实战场景：- 开方计算（`x=16`，`x=0.5` → 4.0）；- 指数增长（`num = 1.05` 模拟年化收益）；3. 注意：超大数幂运算会占用大量内存（如 `x=10`，`x**=1000`）。
`//=`	取整除赋值运算符 - 左侧变量 //= 右侧值 → 等价于变量 = 变量 // 右侧值	`c //= a` → c=2；`x=-9`，`x//=2` → x=-5`	1. 核心：向下取整（负数场景需注意）；2. 实战场景：- 分页计算（`page_count //= page_size` 总页数）；- 整数拆分（`num //= 10` 去掉个位）；3. 注意：浮点数 `//=` 结果仍为浮点数（`x=10.5`，`x//=2` → 5.0）。
`:=`	海象运算符（Python3.8+）- 表达式中赋值并返回值	示例 1：`if (n := len(lst)) > 10: print(f"列表过长：{n}个元素")`；示例 2：`while (line := input("输入：")) != "quit": print(line)`	1. 核心：避免重复计算 / 重复调用函数；2. 实战场景（重点）：- 减少函数调用次数；- 循环中实时赋值；- 列表推导式中赋值；3. 注意：- 必须用括号包裹（如 `if n := len(lst)` 报错，需 `if (n := len(lst))`）；- 仅在表达式中使用，不能单独赋值（如 `(x := 10)` 合法，`x := 10` 语法错误）。