2.3.2 Operator precedence

Operator precedence determines the order in which operators are evaluated in an expression. When multiple operators are used in an expression, Python follows a set of rules to decide the order of operations. Operators with higher precedence are evaluated first.

If operators have the same precedence, their associativity (whether they are evaluated from left to right or right to left) decides the order.

Operator Precedence Hierarchy

Here’s the general hierarchy of operator precedence in Python, from highest to lowest:

1. Parentheses (())
   • Parentheses have the highest precedence. Any expression inside parentheses is evaluated first, regardless of the operators involved.
   • Example: 2 * (3 + 4) will first evaluate (3 + 4) = 7, then multiply it by 2.
2. Exponentiation (**)
   • Exponentiation has a higher precedence than multiplication or addition.
   • Example: 2 + 3 ** 2 will first calculate 3 ** 2 = 9, then add 2, resulting in 11.
3. Unary plus and minus (+, -) and Bitwise NOT (~)
   • These operators modify a single operand, such as changing the sign of a number or inverting bits.
   • Example: -5 (negation) and ~5 (bitwise negation).
4. Multiplication, Division, Floor Division, Modulus (*, /, //, %)
   • These operators have higher precedence than addition or subtraction.
   • Example: 5 + 2 * 3 will first multiply 2 * 3 = 6, then add 5, resulting in 11.
5. Addition and Subtraction (+, -)
   • Addition and subtraction have the same level of precedence and are evaluated after multiplication and division.
   • Example: 5 + 2 - 3 is evaluated from left to right as (5 + 2) - 3 = 4.
6. Comparison operators (==, !=, <, <=, >, >=)
   • These operators compare two values and return True or False.
   • Example: 5 < 10 results in True.
7. Logical NOT (not)
   • not has higher precedence than and or or.
   • Example: not True and False is evaluated as (not True) and False = False.
8. Logical AND (and)
   • and has higher precedence than or.
   • Example: True and False or True is evaluated as (True and False) or True = True.
9. Logical OR (or)
   • or has the lowest precedence.
   • Example: False or True and False is evaluated as False or (True and False) = False.

Associativity

• Most operators in Python are left-associative, meaning they are evaluated from left to right.
  • Example: 5 - 3 - 1 is evaluated as (5 - 3) - 1 = 1.
• The exponentiation operator (**) is right-associative, meaning it is evaluated from right to left.
  • Example: 2 ** 3 ** 2 is evaluated as 2 ** (3 ** 2) = 2 ** 9 = 512.

Example: Understanding Operator Precedence

Consider the following expression:

result = 5 + 2 * 3 ** 2 / 2 - 1

Here’s how Python evaluates it based on operator precedence:

1. Exponentiation (3 ** 2): 3 ** 2 = 9
2. Multiplication (2 * 9): 2 * 9 = 18
3. Division (18 / 2): 18 / 2 = 9.0
4. Addition (5 + 9.0): 5 + 9.0 = 14.0
5. Subtraction (14.0 - 1): 14.0 - 1 = 13.0

Thus, the final value of result is 13.0.

Example with Parentheses:

Using parentheses can alter the precedence:

result = (5 + 2) * 3 ** 2 / 2 - 1

1. Parentheses (5 + 2): (5 + 2) = 7
2. Exponentiation (3 ** 2): 3 ** 2 = 9
3. Multiplication (7 * 9): 7 * 9 = 63
4. Division (63 / 2): 63 / 2 = 31.5
5. Subtraction (31.5 - 1): 31.5 - 1 = 30.5

Thus, the final value of result is 30.5.

Summary

• Operator precedence determines the order of operations in an expression.
• Parentheses () have the highest precedence and are always evaluated first.
• Exponentiation ** is evaluated before multiplication, division, and modulus.
• Multiplication, division, and modulus are evaluated before addition and subtraction.
• Logical operators (and, or, not) have lower precedence compared to arithmetic and comparison operators.