第 6 章　运算符与表达式

6.1表达式：把数据「算」出新结果

上一章我们「存」数据，这一章我们「算」数据。算数据的写法，叫 表达式（expression）。

一个表达式，就是由值（数据）和运算符（运算符号）组合起来、最终能算出一个结果的式子。

5 + 3        # 表达式，算出 8
x * 2        # 表达式，算出 x 的两倍
age >= 18    # 表达式，算出 True 或 False

表达式无处不在：x = 5 + 3 里，右边的 5 + 3 就是表达式；print(x * 2) 里，x * 2 就是表达式。它的核心特征就一条：能「求值」——算出一个具体的结果。

运算符（operator）是表达式里的「动词」，它告诉计算机对数据做什么操作。根据「算什么」和「算出什么」，运算符分成三大类，下面逐一讲。

表达式可以套表达式：像洋葱一样剥开

看一个稍长的算式：2 * 3 + 4 * (1 + 2)。它不是「一整坨」，而是层层嵌套的表达式——最里层 1 + 2 先算出 3，这个 3 立刻变成外层 4 * 3 的一个操作数，算出 12；再外层 2 * 3 算出 6；最外层 6 + 12 收尾得 18。整个过程像剥洋葱：里层的值一层层「浮出」，供外层使用。子表达式算出的值，就是外层表达式的原料——这是「先求值再使用」在复杂表达式里的形态。

顺带立一个重要的概念边界：语句与表达式。表达式是「名词性」的——它代表一个值，能被求值；语句是「动词性」的——它是一个动作、一条指令。在 x = 5 + 3 里，整行是一条赋值语句（存入这个动作），而右边的 5 + 3 是表达式（被求出 8 的那个部分）。区分的试金石：「它能不能放进 print()？」print(5 + 3) 合法——表达式有值可打印；print(x = 5) 在 Python 里行不通——赋值语句是动作，没有「值」。往后的代码里，你会不断见到「大语句套小表达式」的构造，把这个边界刻在心里，读代码就不再是一团乱麻。

print(5 + 3)      # 8
print(type(5 + 3))  # <class 'int'>

print(5 / 2)        # 2.5
print(type(5 / 2))  # <class 'float'>

print(5 > 3)        # True
print(type(5 > 3))  # <class 'bool'>

放到工程现场，「表达式」就是计算书上的每一个算式：截面积、压差、当量载荷……区别只在——纸上的算式算完就扔，程序里的表达式随取随算、永不疲劳，数据一换，结果立刻跟着更新。也因此工程师验算的习惯在编程里原样成立：拿不准的式子，丢进 Python 里跑一遍就知道（第 3 章装好的交互环境正是为此准备的「电子计算书」）。

把「剥洋葱」落成一张逐步求值表，以 2 * 3 + 4 * (1 + 2) 为例：

步骤 1：1 + 2   →  3     先算最里层括号
步骤 2：4 * 3   →  12    子表达式算完，值「浮出」顶替原位
步骤 3：2 * 3   →  6     同级运算，从左往右
步骤 4：6 + 12  →  18    顶层收尾，整个表达式的最终值

注意一个关键习惯：算出的值会立刻「顶替」原来的子表达式——步骤 1 得到的 3，直接站进 4 * 3 的操作数位；步骤 2 的 12 站进加法右边。整个求值过程就是「子表达式不断被它的值替换，直到只剩一个值」——计算机算式的机械原理，和你手动验算的思路一模一样。

表达式算出的值有三个去处，往后的代码里天天见：存给变量（x = 5 + 3，右侧就是表达式）、直接打印（print(2 * 3 + 4)）、喂给判断（下一章的 if 后面跟的，正是一个算出 True/False 的表达式）。三种用法共用同一条规则——先求值，再使用；区别只在于「值算出来之后去哪」。认出代码里的表达式、能拆出它的求值顺序，是从「会读一行代码」到「会读一段代码」的分水岭。

6.2算术运算符：加减乘除与取余

算术运算符做的是「数学计算」，输入数字，输出数字：

有两个运算符需要特别理解：

// 整除 vs / 除法

/ 永远给你精确的小数结果（5/2 = 2.5）；// 则把结果向下取整，丢掉小数部分（5//2 = 2）。想得到「完整的几份」，用整除。

% 取余：小学除法的「余数」

5 除以 2，商 2 余 1，那个「余 1」就是 5 % 2 的结果。取余非常有用，最常见的两个场景：

• 判断奇偶：x % 2 等于 0 就是偶数，等于 1 就是奇数。
• 循环往复：比如「每隔 3 个做一次」，就用 x % 3 == 0 判断。

先给 // 补一条重要脚注：它叫「整除」，但准确说是向下取整——结果取「不大于真商的最大整数」。正数时无害：7//2=3；负数时就反直觉了：-7 // 2 得 -4（因为 −3.5 向下取整是 −4，不是 −3）。配套的余数也跟着变：-7 % 2 得 1（不是 −1）。看似别扭，背后却有一条铁的恒等式：a == (a // b) * b + a % b 永远成立（127 = 10×12+7 ✓；−7 = −4×2+1 ✓）。Python 里余数的符号永远跟除数一致，这条恒等式就是保证——商和余数配合，不多不少正好还原被除数。

total = 127
box = 12

print(total // box)   # 10：整箱数
print(total % box)    # 7：装不下、剩下的件数

# 验证恒等式：商×除数 + 余数 == 被除数
print(total // box * box + total % box == total)   # True ✓

# 奇偶判断
n = 46
print(n % 2)    # 0：余 0，偶数
m = 127
print(m % 2)    # 1：余 1，奇数

给 % 再扫一次雷：它不是百分号。生活里「30%」读「百分之三十」，Python 里根本没有百分数这种写法——想表达百分之三十，写 0.3 或 30 / 100。% 在 Python 里只干一件事：取余。新手最常犯的两个错——把 rate = 5% 当合法语句（会当场报错：SyntaxError），把 x % 2 误读成「x 的百分之二」——都是把生活的百分号带进了代码。记住：代码里的 %，念「余」不念「百分比」。

取余在工程上的用处比想象中大得多：奇偶校验位（数据位按 2 取余算校验值）、分组轮检（设备第 k 次轮到谁，用 k % 组数）、时钟换算（25 点是几点？25 % 12 得 1，凌晨 1 点）。凡是周期性重复的事情，几乎都藏着一个取余——「转了一圈回到哪」，正是 % 的本义。

除法家族的分工：/、//、round() 各管一段

「算除法」看起来是一件事，实际上分成三个需求：要精确结果（真除法 /）、要整数份（整除 //）、要四舍五入（round()）。Python 为三个需求各配了一把钥匙：

print(5 / 2)        # 2.5 ：真除法——精确值，结果永远是 float
print(5 // 2)       # 2   ：整除——向下取整，丢掉小数
print(round(5 / 2)) # 2   ：舍入——2.5 向偶数靠（第 5 章讲过的「银行家舍入」）
print(round(7 / 2)) # 4   ：3.5 向偶数靠，得 4

三把钥匙混用是新手事故高发区：算「能装几箱」误用 / 得 10.58 箱（箱数哪有小数）；算「平均值」误用 // 把 4.7 平均成 4，白白丢了 0.7。选钥匙的口诀就一句：问自己「结果该带小数吗」——该带小数用 /；要整数份用 //；要四舍五入用 round()。另外记得 / 永远出 float（哪怕 4/2 也得 2.0），拿它当整数用还得再转一道——工程上多数场合直接 // 更省心。

取余还有个工程上极常用的姿势——周期采样。传感器每秒读一次数，程序不必每次都处理：每逢序号 k % 100 == 0 的读数才落盘一次，等于把连续的数据流按每 100 个一组分组，只取每组的「排头」。同理，仪表巡检每轮 % N 决定查哪台，定时任务按 % 60 对齐分钟……「按周期取点」的背后全是取余——第 8 章写循环时这个套路还会正式登场。

6.3比较运算符：得出「是/否」

比较运算符做的是「比较判断」，输入两个值，输出一个 布尔值（True 或 False）。它们回答的永远是「是/否」式的问题。

比较运算的结果（True/False）是下一章「条件分支」的燃料。没有比较，程序就不知道「该走哪条路」。

比较运算符的本质值得点破：它是一个问句，而 bool 是它的答案。「压强 > 上限吗？」「长度 == 标称值吗？」——每个比较表达式都在向机器提一个只有是/否两种答案的问题，机器如实回答 True 或 False。这直接接上第 5 章的布尔：True/False 不是凭空存在的摆设，它们诞生于比较，将在第 7 章成为 if 分支的「燃料」——没有比较，程序永远做不了决定。

print(5 == 5.0)    # True：值相等就相等，类型可以不同
print("5" == 5)     # False：文字 "5" 和数字 5 不是一个世界的东西
print(True == 1)    # True：布尔是整数家族特例，True 就是 1

再认识一位 == 的孪生兄弟——is。== 问的是「值相等吗」，is 问的是「是不是同一个对象吗」——后者正是第 4 章 id() 的知识落地处：is 相当于比较两个名字挂的是不是同一块内存。数字 5 和 5.0 值相等（== True）但显然不是同一个对象（is False）。is 的正式戏份在第 10 章（列表共享）才开演，今天先认个脸，记住口诀：== 问值，is 问身份。

既然比较是「问句」，工程上最常见的问法就是「读数在不在正常区间内」。Python 有个贴心的写法——链式比较，允许把「下限 ≤ 读数 ≤ 上限」写成跟数学作业一模一样的样子：

upper = 8.0
lower = 6.0
reading = 7.3

print(reading > upper)               # False：没超上限
print(reading < lower)               # False：没低于下限
print(lower <= reading <= upper)   # True：链式比较，数学式直接写

in_range = lower <= reading <= upper
print(in_range)                       # True：结论存进布尔变量，随时可用

最后一步值得注意：比较的结果（布尔值）可以存进变量——in_range 今后就是一个「结论」，可以被打印、被引用、被下一步判断。这是表达式「先求值再使用」的又一次现身：比较算出 True/False，True/False 又成为新变量的值。数据和结论在程序里流动起来，这就是「处理数据」最朴素的形态。

6.4逻辑运算符：组合多个判断

现实中的判断往往不止一条：「年龄满 18 且 有驾照，才能开车」。这里「且」把两个判断组合了起来。逻辑运算符就是干这个的：

逻辑运算符的规则，用一张「真值表」最清楚：

一个实际例子，把比较和逻辑串起来：

age = 20
has_license = True
can_drive = (age >= 18) and has_license   # True and True = True

and/or 的隐藏技能：短路求值

and 和 or 求值时有个隐藏机制，叫短路求值（short-circuit evaluation）：Python 从左到右逐个看操作数，一旦结果已经注定，就不再往后看。对 and：左边是 False，全式必为 False，右边根本不求值；对 or：左边是 True，全式必为 True，右边同样被跳过。「已经能定案，何必审下一个」——像一场能提前结束的评审。

这个机制最好的证据，是 1/0——正常情况它必报错（除数不能为零）。但把它放进被短路的右侧，它就根本没被执行，连报错的机会都没有。这既解释了现象，也暴露出工程价值：短路求值让你能安排「安全检查的顺序」——先确认「有没有数据」，再去看「数据是多少」，顺序本身就是保护。

print(False and 1 / 0)   # False：and 左边已定案，右边 1/0 没被执行
print(True or 1 / 0)     # True：or 左边已定案，右边 1/0 没被执行
# print(False or 1 / 0) # 这行若执行：ZeroDivisionError: division by zero

# 工程写法：先检查「有没有」，再检查「是多少」
count = 0
safe = count > 0 and 100 / count > 5
print(safe)              # False：count>0 不成立，除法没被碰到，不报错

最后看一个进阶小知识，看不懂可以跳过、混个脸熟即可：Python 的 and/or 返回的其实是「定案的那个操作数」，并不总是 True/False。0 and 'x' 得 0（0 为假，定案的就是它）、3 or 'x' 得 3（3 为真，定案的就是它）。在需要布尔值的地方（比如 if 条件），Python 会按第 5 章的「空与零为假」规则自动解读——所以平时感觉不到差别。今天记结论就够：and/or 返回「决定结果的那一方」，深究留给后面章节。

逻辑运算在工程现场的名字叫联锁（interlock）：设备要动作，得同时满足若干条件，缺一不可；报警要响起，若干条件满足其一即可。写成代码就是 and / or 的直接翻译：

pressure_ok = True      # 液压压力正常
door_locked = False      # 舱门已锁定

can_actuate = pressure_ok and door_locked
print(can_actuate)       # False：门没锁——任一条件不满足，坚决不动作

need_alarm = pressure_ok or door_locked
print(need_alarm)        # True：至少一个条件成立

and 对应「全部满足才放行」的串联联锁，or 对应「满足其一即触发」的并联报警——第 4 章说过的「与门、或门、非门」，在设计图纸上就是这样的逻辑电路。今天的 and/or/not，本质是同一套布尔逻辑在两处现身：电路里叫门电路，代码里叫逻辑运算符。这套「与或非」的数学由 19 世纪的布尔（George Boole）建立——所以真值只有 True 和 False 的这个类型，就用他的名字命名。

6.5优先级与结合性：先算谁

当一个表达式里有好几种运算符挤在一起，计算机按什么顺序算？答案和小学数学的「先乘除后加减」一样，叫 优先级（precedence）。

2 + 3 * 4    # 先算 3*4=12，再算 2+12=14，而不是 5*4=20

Python 的优先级从高到低，大致是：

还有一个概念：结合性（associativity），即「同级运算符谁先算」。比如 10 - 3 - 2，是从左往右算（(10-3)-2 = 5），还是从右往左？Python 的算术运算符大多是从左到右结合。

但别急着背表。真正实用的建议只有一条：

优先级表不用死记，因为它的本质只有一句话：每个表达式都是一棵「运算树」——运算符是枝干、值是叶子；优先级决定的是「谁先和谁结合成子树」。以 2 + 3 * 4 为例：乘法优先级高，3 和 4 先「抱团」成子树算出 12；加法只能等子树出结果再收尾，6+12 一线贯穿最终得 14。把表达式画成树，先算哪步一目了然——树的下层先算、上层后算，顶层运算是最后一步。

结合性回答的是另一个问题：同优先级的运算符，谁跟谁先抱团。绝大多数运算符「左结合」——从左往右依次算：10 - 3 - 2 是 (10−3)−2 = 5，先算左边的减法。唯一显眼的例外是幂运算 **，它「右结合」：2 ** 3 ** 2 是 2**(3**2) = 2⁹ = 512（不是 (2³)² = 64），从右往左算。为什么幂要特立独行？数学上「2 的 3 的 2 次方」习惯上就是这么读的——Python 顺着数学惯例走。

print(2 + 3 * 4 ** 2 % 5)          # 5：幂→乘→余→加
print(not True or False and True)  # False：not→and→or
print(2 ** 3 ** 2)                 # 512：右结合，2 的 9 次方
print(10 - 3 - 2)                  # 5：左结合，(10-3)-2

工程现场的真实做法也印证这一点：重要的算式宁可多一层括号，也要让读的人不用查表。计算书里 (P1 - P2) * A 永远直接写成带括号的式子——不是怕 Python 算错，是怕「三个月后的自己」和「审阅的同事」读错。括号是写给人的注释，零成本高回报。

括号改变的是树的形状。把 2 + 3 * 4 和 (2 + 3) * 4 的树并排画出来，差别一目了然：

2 + 3 * 4 的树：            (2 + 3) * 4 的树：

        +                          *
      /   \                      /   \
     2     *                    +     4
         / \                  / \
        3   4                 2   3

  右子树 3*4 先算 → 2+12 = 14    左子树 2+3 先算 → 5*4 = 20

两棵树的叶子完全相同（2、3、4），形状却不同：括号把 + 提到了上层、把 * 压到了下层——运算顺序就是树的层次。这张图也回答了「为什么 2+3*4 不写成 2+(3*4)」：乘法优先级本来就高，树自然长成那样，括号可以省；但 (2+3)*4 的括号一个都不能省，省了树就变形、结果就变味。

6.6字符串的「加法」与「乘法」

最后补一个有趣的细节：+ 和 * 用在字符串上时，有完全不同的含义——这叫「运算符重载」。

"Hello" + " World"   # 拼接 → "Hello World"
"Ha" * 3              # 重复 → "HaHaHa"

同一个 + 号，用在数字上是「相加」，用在字符串上是「拼接」。为什么？因为 Python 会根据两边数据的类型，决定 + 该干什么。数字加数字=求和，字符串加字符串=拼接。

「同一个 + 号，两种行为」——这件事值得用第 5 章的知识再点透一层。运算符的行为从来不由运算符自己决定，而由操作数的类型决定：两个 int 相加，做算术；两个 str 相加，做拼接。第 4 章说过「类型是内存的说明书」，现在看到说明书的第一条「使用效果」：类型不仅决定数据怎么存，还决定运算符怎么干。这不是 + 号任性，而是一门叫「运算符重载」的语言机制——同一个名字的运算符，在不同类型上有各自的实现，就像同一个「打」字，打电话、打报告、打地基各有各的意思。

print("-" * 30)            # ------------------------------：30 字符分隔线

temp = 23.5
print("温度" + str(temp) + "℃")   # 温度23.5℃：str() 先把 23.5 变成文字

# print("5" + 3)           # 若执行：TypeError: can only concatenate
#                           # str (not "int") to str
print("5" + str(3))         # 53：修好——3 先转文字再拼接

拼字符串在真实程序里的戏份极重：生成报告行、组装提示语、给日志加时间戳——只要「往文字里嵌数字」，就绕不开 str() 这座桥。所以第 5 章那句「Python 从不偷偷转类型」在这里结出了果实："5" + 3 当场报错，不是 Python 不聪明，是它把「类型混用」的隐患在最早的时刻、最响地炸给你看——错得早，好过错得晚。顺带预告：Python 还有更顺手的拼字符串工具（f-string），第 8 章讲字符串时正式介绍，今天这招「str() 过桥」已经够用。

拼接在真实程序里通常一拼就是一整段报告行，套路是「文字块 + str(数字) + 文字块」交替铺开，中间用分隔线隔开：

part = "阀组件"
count = 12

print("-" * 30)
print(part + "：入库 " + str(count) + " 件")
print("合计入库 " + str(count) + " 件")
print("-" * 30)

输出三行报告、两条分隔线——分隔线正是字符串乘法的经典用武之地。往后你写任何「带数据的提示语」「带读数的日志行」，都是这个模式的变奏。

顺带认识比较运算符在字符串上的行为：按编码逐字符比较。"apple" < "banana" 是 True——两个词先比第一个字符，a 和 b 的编号分别是 97 和 98（第 5 章的 ord() 查过），97 < 98，分出胜负就停。第 5 章说「字符在机器里是编号」，这条规则正是那句话的又一次兑现：字符串比大小，本质是拿编号在比。同样，"apple" == "apple" 为 True、== "Apple" 为 False（大小写编号不同）——字符串的比较、判断，用的都是同一套编号逻辑。