📚 Operators Combined: Precedence, Associativity, and Expression Evaluation in A-Level Programming | 运算符组合：A-Level 编程中的优先级、结合性与表达式求值
Programming is built upon expressions – sequences of operators and operands that compute values. Understanding how operators are combined is critical for writing correct and predictable code. In the Edexcel A-Level curriculum, you are expected to master the rules that govern operator precedence (which operator gets evaluated first), associativity (the direction of evaluation for operators of equal precedence), and the overall order of evaluation. This knowledge helps you avoid common bugs and ensures that complex logical or arithmetic expressions behave as intended. In this article, we explore operator combinations in depth, using clear examples and formal rules to solidify your understanding.
编程建立在表达式之上——即一系列用于计算值的运算符与操作数。理解运算符如何组合对于写出正确且可预测的代码至关重要。在 Edexcel A-Level 课程中，你需要掌握决定运算符优先级（哪个运算符先被求值）、结合性（同优先级运算符的求值方向）以及整体求值顺序的规则。这些知识能帮你避免常见错误，并确保复杂的逻辑或算术表达式按预期工作。本文深入探讨运算符组合，用清晰的示例和正式规则巩固你的理解。
1. The Role of Operators in Expressions | 运算符在表达式中的角色
An expression is any valid combination of values, variables, constants, operators, and function calls that can be evaluated to produce a single value. Operators are the symbols that specify which operation to perform, such as +, -, *, ==, &&, and so on. Operands are the data items on which the operators act. For example, in the expression 3 + 5 * 2, + and * are operators, while 3, 5, and 2 are operands. The result depends on the order in which the operators are applied.
表达式是值、变量、常量、运算符和函数调用的任意有效组合，经求值后能产生一个单一值。运算符是指定执行何种操作（如 +、-、*、==、&& 等）的符号。操作数是运算符作用的数据项。例如，在表达式 3 + 5 * 2 中，+ 和 * 是运算符，3、5 和 2 是操作数。其结果取决于应用运算符的顺序。
If we simply scan from left to right, we would first add 3 and 5 to get 8, then multiply by 2 to get 16. However, standard mathematical rules dictate that multiplication has higher precedence than addition, so 5 * 2 is evaluated first to give 10, and then 3 is added, yielding 13. This simple example reveals the necessity of precedence rules. Without them, expressions would be ambiguous and unpredictable.
如果简单地从左到右扫描，我们会先计算 3 加 5 得 8，再乘以 2 得 16。但标准数学规则规定乘法优先级高于加法，因此先计算 5 * 2 得 10，再加 3 得 13。这个简单示例揭示了优先级规则的必要性。没有它们，表达式将是二义且不可预测的。
2. Categories of Operators in A-Level Programming | A-Level 编程中的运算符类别
In the Edexcel specification, you primarily work with Python or pseudo-code that mirrors Python’s operator set. Operators can be broadly categorised as:
在 Edexcel 考纲中，你主要使用 Python 或反映 Python 运算符集的伪代码。运算符可大致分类为：
- Arithmetic operators:
+,-,*,/,//(integer division),%(modulus),**(exponentiation) - Comparison (relational) operators:
==,!=,<,>,<=,>= - Logical operators:
and,or,not - Assignment operators:
=,+=,-=,*=,/=, etc. - Bitwise operators (often used in more advanced tasks):
&,|,^,~,<<,>> - Membership and identity operators:
in,not in,is,is not
算术运算符：+、-、*、/、//（整除）、%（取模）、**（指数）
比较（关系）运算符：==、!=、<、>、<=、>=
逻辑运算符：and、or、not
赋值运算符：=、+=、-=、*=、/= 等
位运算符（常用于较高级任务）：&、|、^、~、<<、>>
成员与身份运算符：in、not in、is、is not
Each category has its own precedence level and associativity rules. By understanding these, you can correctly combine operators from different categories. For example, arithmetic operators generally have higher precedence than comparison operators, which in turn have higher precedence than logical operators.
每一类都有自身的优先级和结合性规则。通过理解这些规则，你就能正确混合来自不同类别的运算符。例如，算术运算符一般比比较运算符优先级高，而比较运算符又比逻辑运算符优先级高。
3. Operator Precedence: The Hierarchy of Evaluation | 运算符优先级：求值层级
Precedence determines the order in which operators of different types are evaluated when an expression contains multiple operators without explicit parentheses. Higher precedence means an operator is evaluated earlier. In most programming languages including Python, the following table summarises the precedence from highest to lowest (not an exhaustive list, but the key ones for A-Level):
优先级决定了当表达式中含有多个未加括号的运算符时，不同类型运算符的求值顺序。优先级高意味着该运算符更早被求值。在包含 Python 在内的大多数编程语言中，下表从高到低总结了优先级（非详尽列表，仅 A-Level 核心内容）：
| Precedence Level | Operator(s) | Description |
|---|---|---|
| 1 (highest) | ** |
Exponentiation |
| 2 | +x, -x, ~x |
Unary plus/minus, bitwise NOT |
| 3 | *, /, //, % |
Multiplication, division, floor division, modulus |
| 4 | +, - |
Addition, subtraction |
| 5 | <<, >> |
Bitwise shifts |
| 6 | & |
Bitwise AND |
| 7 | ^ |
Bitwise XOR |
| 8 | | |
Bitwise OR |
| 9 | ==, !=, <, >, <=, >=, is, is not, in, not in |
Comparisons and membership tests |
| 10 | not |
Logical NOT |
| 11 | and |
Logical AND |
| 12 (lowest) | or |
Logical OR |
Note that assignment operators (including =) have the lowest precedence of all; however, they are not strictly part of expression evaluation in the same sense because they produce a statement rather than a value. Still, within expressions used in conditions or return values, the above hierarchy applies.
注意，赋值运算符（包括 =）具有所有运算符中最低的优先级；不过它们并不完全属于表达式的求值范畴，因为它们产生的是语句而非值。但在条件或返回值中使用的表达式内，上述层级仍然适用。
Using this table, you can predict the evaluation of an expression like 3 + 4 * 2**2 / 2. Exponentiation is first (2**2 = 4), then multiplication and division (same precedence, left-to-right due to associativity, see next section), giving 4*4 = 16, then 16/2 = 8, and finally 3+8 = 11.
利用该表，你可以预测表达式 3 + 4 * 2**2 / 2 的求值过程。首先是指数运算（2**2 = 4），接着是乘除（同优先级，由于结合性从左到右，参见下节），得到 4*4 = 16，然后 16/2 = 8，最后 3+8 = 11。
4. Associativity: When Precedence Alone Isn’t Enough | 结合性：仅凭优先级不够时
Associativity determines the direction in which operators of the same precedence are grouped. In most programming languages, arithmetic operators are left-associative: they group left to right. This means 10 - 3 - 2 is interpreted as (10 - 3) - 2, resulting in 5, not as 10 - (3 - 2) which would give 9. Similarly, assignment operators are right-associative, so a = b = c = 0 is processed from right to left, assigning 0 to c, then b, then a.
结合性决定了相同优先级运算符的分组方向。在大多数编程语言中，算术运算符是左结合的：它们从左向右分组。这意味着 10 - 3 - 2 被解释为 (10 - 3) - 2，结果是 5，而不是 10 - (3 - 2) 会得到的 9。类似地，赋值运算符是右结合的，因此 a = b = c = 0 从右向左处理，先将 0 赋给 c，然后是 b，最后是 a。
Below is a summary of associativity for the main operator groups in Python (and most pseudo-code):
下面总结了 Python（及大多数伪代码）中主要运算符组的结合性：
| Operator Category | Associativity |
|---|---|
Exponentiation (**) |
Right-associative |
Unary (+x, -x, ~x) |
Right-associative |
Multiplicative (*, /, etc.) |
Left-associative |
Additive (+, -) |
Left-associative |
| Bitwise shifts | Left-associative |
| Bitwise AND, XOR, OR | Left-associative |
| Comparisons and identity | Left-associative |
| Logical NOT | Right-associative |
| Logical AND | Left-associative |
| Logical OR | Left-associative |
A common pitfall is the exponentiation operator: 2**3**2 is right-associative, so it is evaluated as 2**(3**2) = 2**9 = 512, not as (2**3)**2 = 64. Understanding this distinction is essential for exam questions that test subtle expression evaluation.
一个常见陷阱是指数运算符：2**3**2 是右结合的，因此它被求值为 2**(3**2) = 2**9 = 512，而不是 (2**3)**2 = 64。理解这一区别对于应对考查微妙表达式求值的考试问题至关重要。
5. Evaluation Order and Short-Circuiting in Logical Expressions | 求值顺序与逻辑表达式的短路求值
Logical operators and and or employ short-circuit evaluation, which means the second operand is only evaluated if the first operand does not determine the outcome. This is not only a performance optimisation but also influences the execution of functions with side effects.
逻辑运算符 and 和 or 采用短路求值，这意味着只有在第一个操作数不能决定结果时，第二个操作数才会被求值。这不仅是性能优化，还会影响具有副作用的函数的执行。
For and: if the left operand evaluates to False, the whole expression is False without evaluating the right operand. For or: if the left operand is True, the whole expression is True, and the right side is skipped.
对于 and：如果左操作数求值为 False，整个表达式即为 False，无需计算右操作数。对于 or：如果左操作数为 True，整个表达式为 True，右侧被跳过。
Consider this example in pseudo-code:
考虑以下伪代码示例：
y = 5
result = (x > 0) and (y / x > 1)
If x is 0, the first part is False, so the second part y / x is never attempted, thus avoiding a division-by-zero error. This demonstrates how short-circuiting can make code safer.
如果 x 为 0，第一部分为 False，因此第二部分 y / x 根本不会执行，从而避免了除零错误。这展示了短路求值如何使代码更安全。
In the context of combined operators, short-circuiting affects evaluation order in a different way from precedence. Even if and has lower precedence than comparisons, the left-to-right evaluation still respects the short-circuiting rules. For instance, a and b or c is evaluated as (a and b) or c because and has higher precedence than or, but if a is false, b is not evaluated, and then c is evaluated.
在组合运算符的语境中，短路求值以不同于优先级的方式影响求值顺序。即使 and 的优先级低于比较运算符，从左到右的求值仍然遵循短路规则。例如，a and b or c 被求值为 (a and b) or c，因为 and 优先级高于 or，但如果 a 为假，b 不被求值，然后计算 c。
6. The Impact of Parentheses | 括号的影响
Parentheses () override the default precedence and associativity, grouping a sub-expression to force earlier evaluation. They are the most powerful tool for making expressions unambiguous, both for the compiler and for human readers.
括号 () 可覆盖默认的优先级和结合性，将子表达式分组以强制提前求值。它们是最强大的工具，无论对编译器还是对读者，都能使表达式清晰无歧义。
For example, (3 + 5) * 2 yields 16 instead of 13. In modular arithmetic or bitwise mask operations, parentheses are often essential to correct logic. Even when not strictly required, adding parentheses can clarify intent: (x > 0) and (y < 10) is easier to read than x > 0 and y < 10, though they are identical by precedence.
例如，(3 + 5) * 2 会得到 16 而不是 13。在模运算或位掩码操作中，括号往往对正确逻辑至关重要。即使语法上并非必需，添加括号也能清晰表达意图：(x > 0) and (y < 10) 比 x > 0 and y < 10 更易读，尽管按优先级二者等价。
When debugging an expression that produces unexpected results, your first step should be to insert parentheses to isolate the steps. This practice often reveals misinterpreted precedence.
当调试产生意外结果的表达式时，你的第一步应是插入括号以隔离各个步骤。这种做法常常能揭示被误解的优先级。
7. Combining Arithmetic and Comparison Operators | 算术与比较运算符的组合
Arithmetic operators have higher precedence than comparison operators. This means that in an expression like a + b < c * d, both additions and multiplications are computed before the comparison takes place. No parentheses are needed, but the expression is equivalent to (a + b) < (c * d).
算术运算符的优先级高于比较运算符。这意味着在 a + b < c * d 这样的表达式中，加法和乘法都在比较之前计算。无需括号，但该表达式等价于 (a + b) < (c * d)。
A common error is to write something like if x & 3 == 0 in languages where bitwise AND has lower precedence than equality; in Python, == has higher precedence than &, so x & 3 == 0 is interpreted as x & (3 == 0), which is probably not intended. Knowing the precedence table helps you avoid such pitfalls.
一个常见错误是写出类似 if x & 3 == 0 的代码，在某些语言中，按位 AND 的优先级低于等号；在 Python 里，== 的优先级高于 &，因此 x & 3 == 0 被解释为 x & (3 == 0)，这很可能并非本意。熟悉优先级表可帮你避开此类陷阱。
Always consider using explicit parentheses when mixing bitwise with comparison: (x & 3) == 0 is clear and correct.
混合使用按位和比较运算符时，始终考虑使用显式括号：(x & 3) == 0 清晰且正确。
8. Chaining Comparison Operators | 比较运算符的链式写法
Python and some pseudo-code allow chaining of comparison operators, such as a < b < c. This is not syntactic sugar for two separate comparisons with an and; it is evaluated as a single collaborative expression that yields a < b and b < c but evaluates b only once. This is semantically equivalent to a mathematical inequality.
Python 和某些伪代码允许比较运算符的链式写法，如 a < b < c。这并非两个独立比较加 and 的语法糖；它被作为一个单一协作表达式求值，等同于 a < b and b < c，但只会对 b 求值一次。这在语义上等同于数学不等式。
The precedence and associativity of such chains follow left-to-right grouping, but with an internal optimisation. You can also use other comparison operators in the chain, e.g., a <= b == c > d, though readability may suffer. It is important to note that the chain is equivalent to combining the pairwise comparisons with and, respecting that b is shared.
这种链式的优先级和结合性遵循从左到右分组，但带有内部优化。你也可以在链中使用其他比较运算符，如 a <= b == c > d，但可读性可能变差。重要的一点是，该链等价于用 and 连接两两比较，并且 b 是共享的。
When exam questions ask you to evaluate 5 > 3 < 10 == 10, remember to break it into (5 > 3) and (3 < 10) and (10 == 10), all of which are true, so the expression evaluates to True.
当考题要求你求值 5 > 3 < 10 == 10，记得将其拆分为 (5 > 3) and (3 < 10) and (10 == 10)，所有部分均为真，因此表达式结果为 True。
9. Assignment Combined with Expressions | 赋值与表达式结合
Assignment operators (=, +=, etc.) have the lowest precedence, so they are performed after everything else in a statement. However, they can still interact with expressions when used in comprehensions or return values. Consider the statement total = sum = 0 in a single line: due to right-associativity, it assigns 0 to sum and then to total. In an exam, you might be asked to trace the values.
赋值运算符（=、+= 等）优先级最低，因此在语句中它们最后执行。不过，当它们用在推导式或返回值中时，仍会与表达式交互。考虑单行语句 total = sum = 0：由于右结合性，先将 0 赋给 sum，再赋给 total。在考试中，你可能会被要求追踪这些值。
Augmented assignments like x += 3 * 2 are equivalent to x = x + (3 * 2) because the right-hand side is evaluated first as an expression. The associativity and precedence on the right-hand side remain unchanged.
增强赋值语句如 x += 3 * 2 等价于 x = x + (3 * 2)，因为右侧首先作为表达式求值。右侧的优先级和结合性保持不变。
You must be careful when combining assignment with logical operators: a = b and c assigns the outcome of b and c to a. Because and has higher precedence than =, this is not (a = b) and c (which would be illegal). Thus, knowing precedence prevents syntax errors.
将赋值与逻辑运算符组合时必须当心：a = b and c 会把 b and c 的结果赋给 a。由于 and 的优先级高于 =，这并非 (a = b) and c（后者非法）。因此，了解优先级可避免语法错误。
10. Bitwise Operators in Logical Masks | 位运算符用于逻辑掩码
Bitwise operators (&, |, ^, etc.) are often combined to create masks and flags. Their precedence relative to arithmetic operators and comparisons is important. For example, the expression flags & MASK == MASK in Python does not work as expected because == is evaluated first. The correct form is (flags & MASK) == MASK.
位运算符（&、<
Published by TutorHao | A-Level 编程 Revision Series | aleveler.com
更多咨询请联系16621398022（同微信）
屏轩国际教育cambridge primary/secondary checkpoint, cat4, ukiset,ukcat,igcse,alevel,PAT,STEP,MAT, ibdp,ap,ssat,sat,sat2课程辅导，国外大学本科硕士研究生博士课程论文辅导Cancel reply