Mastering Combined and Compound Operators in Python | 掌握 Python 组合与复合运算符

📚 Mastering Combined and Compound Operators in Python | 掌握 Python 组合与复合运算符

Operators are the building blocks of any programming language, allowing us to perform calculations, make decisions, and manipulate data. In Edexcel A‑Level Computer Science, a deep understanding of Python operators — especially how they can be combined into concise compound statements and the rules governing their evaluation — is essential for writing efficient, readable code. This article explores arithmetic, comparison, logical, and bitwise operators, with a strong focus on compound assignment operators (+=, -=, *=, etc.) and the critical concepts of operator precedence and associativity that determine the order of execution in complex expressions.

运算符是所有编程语言的基石，让我们能够进行计算、做出决策并操作数据。在 Edexcel A‑Level 计算机科学中，深刻理解 Python 运算符——尤其是它们如何组合成简洁的复合语句以及控制其求值的规则——对于编写高效、可读的代码至关重要。本文将探讨算术、比较、逻辑和位运算符，重点介绍复合赋值运算符（+=、-=、*= 等）以及运算符优先级和结合性等关键概念，这些概念决定了复杂表达式的执行顺序。

1. Arithmetic Operators and Their Compound Forms | 算术运算符及其复合形式

Python provides standard arithmetic operators: + (addition), - (subtraction), * (multiplication), / (true division), // (floor division), % (modulus), and ** (exponentiation). While these can be used independently, compound assignment operators combine an arithmetic operation with assignment, updating a variable in place. For instance, x += 5 is equivalent to x = x + 5. This not only reduces repetition but can also lead to more efficient execution in some cases.

Python 提供了标准的算术运算符：+（加）、-（减）、*（乘）、/（真除法）、//（整除）、%（取模）和 **（幂）。虽然它们可以独立使用，但复合赋值运算符将算术运算与赋值结合在一起，直接更新变量的值。例如，x += 5 等价于 x = x + 5。这不仅减少了重复，有时还能提高执行效率。

Consider a counter that needs to be incremented by a constant value repeatedly. Using count = count + 1 is valid, but count += 1 is both shorter and clearer. The same pattern applies to other operators: total -= discount deducts a discount from a total, score *= 2 doubles a score, and value %= 10 keeps a number within a single-digit range. Floor division and exponentiation work identically: num //= 3 performs integer division by 3 and stores the result, while base **= 2 squares a number.

考虑一个需要反复增加常数的计数器。使用 count = count + 1 是可行的，但 count += 1 更简洁、更清晰。同样的模式适用于其他运算符：total -= discount 从总额中扣除折扣，score *= 2 将分数翻倍，value %= 10 使数字保持在个位数范围内。整除和幂运算也类似：num //= 3 对 num 进行整除 3 并存储结果，而 base **= 2 对一个数进行平方。

The table below summarises the most common compound arithmetic operators:

下表总结了最常见的复合算术运算符：

Operator	Example	Equivalent to
+=	a += b	a = a + b
-=	a -= b	a = a - b
*=	a *= b	a = a * b
/=	a /= b	a = a / b
//=	a //= b	a = a // b
%=	a %= b	a = a % b
**=	a **= b	a = a ** b

---

2. Assignment Operators and Multiple Variable Update | 赋值运算符与多变量更新

Beyond compound arithmetic, Python allows multiple variables to be updated simultaneously using a single compound assignment. For example, x, y = y, x swaps two values without needing a temporary variable. When used with arithmetic, we can write a, b += 1, 2 — although this is less common and should be used carefully. The real power lies in managing state changes across multiple variables in one line, which is often seen in data structure algorithms. Compound assignments are expressions that return the new value, so they can be embedded in larger statements, but readability should always be the priority.

除了复合算术，Python 还允许使用单个复合赋值同时更新多个变量。例如，x, y = y, x 无需临时变量即可交换两个值。与算术结合使用时，我们可以写成 a, b += 1, 2——尽管不太常见且需谨慎使用。真正的威力在于能够在一行中管理多个变量的状态变化，这在数据结构算法中经常出现。复合赋值是返回新值的表达式，因此可以嵌入到更大的语句中，但可读性始终应该是首要考虑的因素。

For Edexcel candidates, it is important to note that compound operators are not just syntactic sugar. When working with mutable objects like lists, list += [item] modifies the list in place (similar to list.extend([item])), whereas list = list + [item] creates a new list. This distinction can affect memory usage and the behaviour of aliases. In contrast, for immutable types such as integers or strings, both forms always produce a new object.

对于 Edexcel 考生，重要的是要注意复合运算符不仅仅是语法糖。在处理可变对象（如列表）时，list += [item] 会原地修改列表（类似于 list.extend([item])），而 list = list + [item] 会创建一个新列表。这种区别会影响内存使用和别名行为。相比之下，对于整数或字符串等不可变类型，两种形式总是生成一个新对象。

---

3. Comparison Operators and Chained Comparisons | 比较运算符与链式比较

Comparison operators examine the relationship between two values and return a Boolean result. Python’s set includes ==, !=, <, >, <=, >=, and the identity operators is and is not. A unique Python feature is chained comparison, where multiple comparisons can be ‘and-ed’ together naturally. For instance, if 0 < x < 10 is equivalent to if x > 0 and x < 10, but the former is more concise and mirrors mathematical notation.

比较运算符检查两个值之间的关系，并返回布尔结果。Python 的比较运算符集包括 ==、!=、<、>、<=、>=，以及身份运算符 is 和 is not。Python 的一个独特功能是链式比较，可以将多个比较自然地“与”在一起。例如，if 0 < x < 10 等价于 if x > 0 and x < 10，但前者更简洁，也更接近数学表示法。

When combining comparison operators with arithmetic or logical operations, precedence rules must be understood. Comparison operators have lower precedence than arithmetic ones, so a + b > c * d is evaluated as (a + b) > (c * d). They also have higher precedence than Boolean operators, meaning x > 5 and y == 3 groups as (x > 5) and (y == 3). These rules allow complex conditions without excessive parentheses, though judicious use of brackets often improves clarity.

当比较运算符与算术或逻辑运算结合时，必须理解优先级规则。比较运算符的优先级低于算术运算符，因此 a + b > c * d 被求值为 (a + b) > (c * d)。它们的优先级高于布尔运算符，这意味着 x > 5 and y == 3 会被解析为 (x > 5) and (y == 3)。这些规则允许在不使用过多括号的情况下构造复杂条件，但明智地使用括号通常可以提高清晰度。

---

4. Logical Operators and Short‑Circuit Evaluation | 逻辑运算符与短路求值

Python’s logical operators — and, or, and not — are essential for constructing Boolean expressions. Unlike many languages that require bitwise operators for certain logical tasks, Python’s and/or operate directly on any object, returning one of the operands rather than simply True or False. This behaviour enables elegant patterns like fallback defaults: name = user_input or 'Guest' assigns user_input if it is truthy, otherwise 'Guest'.

Python 的逻辑运算符——and、or 和 not——对于构造布尔表达式至关重要。与许多要求特定任务使用位运算符的语言不同，Python 的 and/or 直接操作任何对象，返回其中一个操作数，而不仅仅是 True 或 False。这种行为实现了优雅的模式，例如后备默认值：name = user_input or 'Guest' 会在 user_input 为真值（truthy）时赋值该输入，否则赋值为 'Guest'。

A pivotal concept for A‑Level is short‑circuit evaluation: in a and b, if a is false, b is never evaluated; in a or b, if a is true, b is skipped. This is not just an optimisation — it prevents runtime errors. For example, if divisor != 0 and num / divisor > 10 avoids a division‑by‑zero error because the second operand is never reached when divisor is zero. Understanding short‑circuiting is often tested in trace‑table questions on the Edexcel specification.

A‑Level 的一个关键概念是短路求值：在 a and b 中，如果 a 为假，则永远不会计算 b；在 a or b 中，如果 a 为真，则跳过 b。这不仅仅是一种优化——它还能防止运行时错误。例如，if divisor != 0 and num / divisor > 10 可避免除以零错误，因为在 divisor 为零时永远不会执行第二个操作数。理解短路求值是 Edexcel 规范中常出现的状态表（trace table）题目经常考查的内容。

Combining logical operators with comparisons often yields concise conditional statements. Consider: if 18 <= age <= 65 and (has_id or verified). Here chained comparison first evaluates age bounds, then logical operators determine the final Boolean. The order is governed by precedence: not binds tightest, then and, then or. Thus not a or b and c is read as (not a) or (b and c).

将逻辑运算符与比较结合常常产生简洁的条件语句。考虑：if 18 <= age <= 65 and (has_id or verified)。在这里，链式比较首先评估年龄界限，然后逻辑运算符确定最终的布尔值。顺序由优先级决定：not 结合性最强，然后是 and，最后是 or。因此 not a or b and c 被解读为 (not a) or (b and c)。

---

5. Bitwise Operators and Compound Bitwise Assignment | 位运算符与复合位赋值

Bitwise operators act on integer values at the level of individual bits. Python supports & (AND), | (OR), ^ (XOR), ~ (NOT), << (left shift), and >> (right shift). These are invaluable in low‑level programming, cryptography, and performance‑sensitive applications. For A‑Level computer science, candidates must be able to read and write bitwise expressions, understand their truth tables, and predict the outcome of shift operations.

位运算符在单个比特的层面上处理整数值。Python 支持 &（与）、|（或）、^（异或）、~（非）、<<（左移）和 >>（右移）。这些在底层编程、密码学和对性能敏感的应用中非常有价值。对于 A‑Level 计算机科学，考生必须能够读写位运算表达式，理解其真值表，并预测移位操作的结果。

Just as with arithmetic operators, compound bitwise assignment operators (&=, |=, ^=, <<=, >>=) combine a bitwise operation with assignment. For example, flags |= 0b100 sets the third bit of a flags variable, while value &= ~0b100 clears it. Bitwise shifts offer fast multiplication or division by powers of two: x <<= 3 multiplies x by 2³ (=8), and y >>= 2 performs integer division by 4.

与算术运算符一样，复合位赋值运算符（&=、|=、^=、<<=、>>=）将位运算与赋值相结合。例如，flags |= 0b100 设置标志变量的第三位，而 value &= ~0b100 则清除该位。位移操作可实现快速的 2 的幂次乘除：x <<= 3 将 x 乘以 2³（即 8），y >>= 2 则进行除以 4 的整数除法。

The table below summarises compound bitwise operators:

下表总结了复合位运算符：

Operator	Example	Meaning
&=	a &= b	a = a & b
|=	a |= b	a = a | b
^=	a ^= b	a = a ^ b
<<=	a <<= n	a = a << n
>>=	a >>= n	a = a >> n

---

6. Operator Precedence: The Hidden Hierarchy | 运算符优先级：隐藏的层次结构

When multiple operators appear in a single expression, Python uses a precise order known as operator precedence. Failing to respect this hierarchy leads to logical bugs. At the top (tightest binding) are exponentiation **, then unary plus/minus and bitwise NOT ~, followed by multiplication/division/modulus, then addition/subtraction, shifts, bitwise AND, XOR, OR, comparisons, and finally logical operators (not, and, or). Assignment operators (including compound) have the lowest precedence, ensuring that the right‑hand side is fully evaluated before assignment.

当单个表达式中出现多个运算符时，Python 会使用一种精确的顺序，称为运算符优先级。不遵循这一层次结构会导致逻辑错误。最顶层（结合性最强）是乘方 **，然后是一元加/减和按位取反 ~，接着是乘/除/模，然后是加/减、移位、按位与、异或、或、比较，最后是逻辑运算符（not、and、or）。赋值运算符（包括复合赋值）的优先级最低，这确保了右侧表达式在赋值前被完全求值。

Consider a classic pitfall: result = a & b == 0 is interpreted as result = a & (b == 0) because equality has higher precedence than bitwise AND. The correct way to check if both a and b are zero using bitwise would be (a | b) == 0. Being aware of precedence helps avoid such mistakes. When in doubt, parentheses can and should be used to clarify intent.

考虑一个经典的陷阱：result = a & b == 0 被解释为 result = a & (b == 0)，因为相等性检查的优先级高于按位与。使用位运算检查 a 和 b 是否都为零的正确方式是 (a | b) == 0。了解优先级有助于避免此类错误。当有疑虑时，可以使用并且应该使用括号来阐明意图。

The precedence chart below lists Python operators from highest to lowest priority (same row indicates equal precedence):

下面的优先级表按从高到低的顺序列出了 Python 运算符（同一行表示优先级相同）：

Priority	Operators
1	() (parentheses)
2	**
3	+x, -x, ~x (unary)
4	*, /, //, %
5	+, - (addition/subtraction)
6	<<, >>
7	&
8	^
9	|
10	==, !=, <, <=, >, >=, is, is not, in, not in
11	not
12	and
13	or
14	=, +=, -=, *=, etc.

---

7. Associativity: Left to Right or Right to Left? | 结合性：从左到右还是从右到左？

When operators share the same precedence level, associativity determines the evaluation direction. Most operators are left‑associative: they group from left to right. For example, 100 / 10 * 2 evaluates as (100 / 10) * 2 giving 20.0, not 100 / (10 * 2) which would be 5.0. The only right‑associative operators are the unary operators (e.g., ** exponentiation) and assignment. Thus, a = b = 5 is processed as a = (b = 5), and 2 ** 3 ** 2 is treated as 2 ** (3 ** 2) = 2 ** 9 = 512.

当运算符具有相同的优先级时，结合性决定求值方向。大多数运算符是左结合的：它们从左到右分组。例如，100 / 10 * 2 求值为 (100 / 10) * 2，结果为 20.0，而不是 100 / (10 * 2) 会得到 5.0。唯一的右结合运算符是一元运算符（例如 ** 乘方）和赋值。因此，a = b = 5 被处理为 a = (b = 5)，而 2 ** 3 ** 2 被视为 2 ** (3 ** 2) = 2 ** 9 = 512。

Compound assignment operators follow right‑to‑left associativity as well: a += b += 1 is valid (though obscure) and first increments b by 1, then adds the new b to a. In practice, clarity demands avoiding such tangled expressions, but Edexcel exam questions may present them in trace‑table exercises, so students must be able to unpick them step by step.

复合赋值运算符也遵循从右到左的结合性：a += b += 1 是有效的（尽管晦涩），首先将 b 增加 1，然后将新的 b 加到 a 上。在实践中，为了清晰起见，应避免这种混乱的表达式，但 Edexcel 考试题目可能会在状态表练习中呈现它们，因此学生必须能够逐步拆解它们。

---

8. Combined Expressions in Selection and Iteration | 选择与迭代中的组合表达式

Control flow statements commonly combine multiple operators. A while loop like while low <= high and not found: uses comparison, logical, and membership operators together. For‑loops can employ compound assignment inside the body: total += item * price accumulates a running total. Complex conditions in if‑elif chains often mix Boolean operators with arithmetic: if score >= 90 and extra_credit != 0:.

控制流语句通常组合多个运算符。像 while low <= high and not found: 这样的 while 循环使用了比较、逻辑和成员运算符。for 循环体内部可以使用复合赋值：total += item * price 累加一个运行总和。if-elif 链中的复杂条件经常混合布尔运算符和算术：if score >= 90 and extra_credit != 0:。

A common Edexcel‑style question asks students to evaluate an expression such as x <<= 2; y += x % 5; z = y > 10 or x == 8 starting from given initial values. This requires recognising that the semicolons simply separate statements (not part of Python syntax outside the shell), and that each statement must be processed in sequence, respecting precedence and side effects of compound assignments. Building a trace table helps track variable states.

一个常见的 Edexcel 风格的问题是，要求学生从给定的初始值开始，求值诸如 x <<= 2; y += x % 5; z = y > 10 or x == 8 的表达式。这需要认识到分号只是分隔语句（在 shell 之外不是 Python 语法的一部分），并且每个语句必须按顺序处理，同时尊重复合赋值的优先级和副作用。构建状态表有助于跟踪变量状态。

Let’s simulate: if x = 3, y = 4. After x <<= 2, x becomes 12 (shift left twice multiplies by 4). Then y += x % 5 → <

Published by TutorHao | A-Level 编程 Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）