运算符与表达式（Python 从精通到入门 · 23）

运算符是搭积木的接口。/ 和 // 差一个字，结果差一个世界；and 的短路能帮你写出又短又安全的判断。

上一篇我们认识了变量和类型，这一篇来看怎么把它们"运算"起来。运算符看着简单，但里面藏着不少新手会踩的坑。

你将学到

• 算术运算符 + - * / // % **，尤其是整除和取模
• 比较运算符，以及链式比较这种 Python 特色
• 逻辑运算 and / or / not，重点是短路求值
• 位运算简介（知道有这回事即可）
• 赋值运算符 += 等，以及运算符优先级速记
• 真值测试：哪些值会被当成 False
• input() 读入，以及必须做的类型转换

前置知识

先读 上一篇：变量与数据类型，本篇假设你已经理解什么是变量和类型。

算术运算符

a = 7
b = 2

print(a + b)   # 输出: 9     加法
print(a - b)   # 输出: 5     减法
print(a * b)   # 输出: 14    乘法
print(a / b)   # 输出: 3.5   除法，结果永远是 float
print(a // b)  # 输出: 3     整除，向下取整
print(a % b)   # 输出: 1     取模，余数
print(a ** b)  # 输出: 49    幂，7 的 2 次方

重点区分 / 和 //：

print(10 / 4)    # 输出: 2.5
print(10 // 4)   # 输出: 2     （向下取整）
print(-7 // 2)   # 输出: -4    （注意！向下取整，不是向零取整）
print(-7 % 3)    # 输出: 2     （余数符号跟着除数走）

// 对负数的行为常常让人意外，记住口诀：结果是"不超过真实商的最大整数"。

取模还能干这些事：

print(8 % 2 == 0)   # 输出: True，判断偶数

seconds = 3725
print(f"{seconds // 3600}小时{seconds % 3600 // 60}分{seconds % 60}秒")
# 输出: 1小时2分5秒

比较运算符

print(3 > 2)    # 输出: True
print(3 < 2)    # 输出: False
print(3 >= 3)   # 输出: True
print(3 == 3)   # 输出: True    相等用 ==（两个等号！）
print(3 != 2)   # 输出: True    不等用 !=

易错点：赋值是 =，比较是 ==。写成一个等号是新手最频繁的错误。

# ❌ 想要比较，却写成了赋值：SyntaxError: invalid syntax
# if x = 5: ...

# ✅ 比较用两个等号
x = 5
if x == 5:
    print("等于5")

链式比较

Python 允许像数学一样连着写：

score = 85

# 啰嗦写法
if score >= 60 and score < 90:
    print("及格但未优秀")

# ✅ 链式写法，更接近数学直觉
if 60 <= score < 90:
    print("及格但未优秀")

逻辑运算：and / or / not

print(True and False)   # 输出: False   两边都真才真
print(True or False)    # 输出: True    一个真就真
print(not True)         # 输出: False   取反

短路求值（非常重要）

and 和 or 有一个极其重要的特性：只要能确定结果，就不会再算右边。

• and：左边为假，直接返回左边，右边根本不执行。
• or：左边为真，直接返回左边，右边根本不执行。

def side_effect():
    print("我被执行了！")
    return True

print(False and side_effect())   # 输出: False（side_effect 没被调用）
print(True or side_effect())     # 输出: True （side_effect 没被调用）

利用短路，可以写出安全的判断：

data = {"name": "小明"}
key = "age"
if key in data and data[key] > 18:
    print("成年")
else:
    print("条件不成立")   # 输出: 条件不成立

注意 and / or 返回的不一定是布尔值，而是决定结果的那个操作数：

print(1 and 2)          # 输出: 2
print(0 or 2)           # 输出: 2
print("" or "默认值")    # 输出: 默认值（经典的兜底技巧）

位运算简介

位运算直接操作整数的二进制位，日常用得不多，看到别怕：

a = 0b1100   # 12
b = 0b1010   # 10

print(a & b)    # 输出: 8   按位与
print(a | b)    # 输出: 14  按位或
print(a ^ b)    # 输出: 6   按位异或
print(a << 1)   # 输出: 24  左移一位（乘 2）
print(a >> 1)   # 输出: 6   右移一位（除以 2）

赋值运算符

在赋值号前加运算符，可以就地更新变量：

x = 10
x += 5    # 等价于 x = x + 5，现在 x 是 15
x -= 3    # 12
x *= 2    # 24
x //= 5   # 4
x **= 2   # 16
print(x)  # 输出: 16

写法	等价于	写法	等价于
x += 1	x = x + 1	x /= 2	x = x / 2
x -= 1	x = x - 1	x //= 2	x = x // 2
x *= 2	x = x * 2	x %= 2	x = x % 2

运算符优先级速记

完整优先级表很长，入门阶段记住这几条就够（从高到低）：

1. 括号 ()——不确定就加括号，永远不吃亏
2. ** 幂运算
3. 一元 + -、not
4. * / // %
5. + -
6. 比较运算符 < > <= >= == !=
7. and → 8. or

print(2 + 3 * 4)      # 输出: 14，先乘后加
print((2 + 3) * 4)    # 输出: 20，括号改变顺序
print(2 ** 3 ** 2)    # 输出: 512，幂运算右结合，等于 2**(3**2)
print(not 1 == 2)     # 输出: True，先比较(False)，再 not

真值测试：哪些值算 False

在 if 和 while 里，任何对象都会被"翻译"成布尔值。下面这些会被当成 False：

falsey = [False, None, 0, 0.0, "", [], (), {}, set()]
for v in falsey:
    print(bool(v), end=" ")
# 输出: False False False False False False False False False

print(bool("0"))    # 输出: True，非空字符串就是 True！
print(bool([0]))    # 输出: True，非空列表就是 True！

利用这个特性，可以写得很简洁：

name = ""
if not name:                 # 空字符串自动为假
    print("名字不能为空")     # 输出: 名字不能为空

items = [1, 2, 3]
if items:
    print(f"共 {len(items)} 项")   # 输出: 共 3 项

input() 读入与类型转换

input() 从键盘读一行，返回值永远是字符串：

name = input("请输入你的名字：")
print(f"你好，{name}！")

读数字时必须手动转换：

# ❌ input 返回 "18"，"18" + 1 会报 TypeError
# age = input("年龄："); print(age + 1)

# ✅ 先转成 int
age = int(input("请输入年龄："))
print(f"明年你 {age + 1} 岁")

常见转换函数：

print(int("42"))       # 输出: 42       字符串转整数
print(float("3.14"))   # 输出: 3.14     字符串转浮点
print(str(42))         # 输出: 42       数字转字符串
print(int(3.9))        # 输出: 3        浮点转整数（截断，不是四舍五入）
print(int("ff", 16))   # 输出: 255      按 16 进制解析

常见坑

坑一：/ 结果总是 float

# ❌ 以为 6 / 2 得到整数 3
print(type(6 / 2))   # 输出: <class 'float'>，其实是 3.0

# ✅ 想要整数用 //
print(6 // 2)        # 输出: 3（int）

坑二：== 与 = 混淆

# ❌ 少写一个等号，变成赋值
# if n = 1: ...

# ✅
n = 1
if n == 1:
    print("对上了")

坑三：and / or 返回值不是布尔

x = 0
print(x or "空")          # 输出: 空（返回的是字符串！）
print(bool(x or "空"))    # 输出: True，要布尔值就显式转换

坑四：input 忘记转换

# ❌ 两个字符串相加会拼接，不是数学加法
# a = input(); b = input()   # 输入 3 和 5
# print(a + b)               # 输出: 35，不是 8

# ✅
a = int(input("第一个数："))
b = int(input("第二个数："))
print(a + b)                 # 输入 3 和 5，输出: 8

小结

• / 永远返回 float，// 是向下取整，% 取余，** 求幂。
• 比较用 ==，别和赋值 = 混了；18 <= age < 60 链式比较很优雅。
• and / or 短路求值，返回的是操作数本身；能用来做安全判断和默认值。
• 位运算平时少用，知道 <<、>>、& 即可。
• +=、-= 等复合赋值是语法糖，等价于 x = x + ...。
• 优先级记不住就加括号。
• False、None、0、""、[]、{} 等在布尔语境里都是假。
• input() 返回字符串，读数字必须 int() 或 float() 转换。

延伸阅读

• Python 官方文档：运算符优先级表
• 26-字符串与格式化：f-string 的格式化细节

---

上一篇：变量与数据类型 · 下一篇：控制流：if / for / while