Python Operator Precedence and Evaluation Order

Basic

Python can combine several operators in one expression. To read such an expression correctly, you need to know two different rules: operator precedence decides how the expression is grouped, while evaluation order decides when its parts are evaluated.

Precedence decides the grouping

1
2
3
4
5

total = 2 + 3 * 4
with_parentheses = (2 + 3) * 4

print(total)
print(with_parentheses)

Precedence is about which operators bind more tightly. A higher-precedence operator is grouped before a lower-precedence operator unless parentheses change the grouping. Python's reference lists the complete precedence table from the most binding forms to the least binding ones.

Parentheses make intent explicit

1
2
3
4
5
6
7
8

items = 4
unit_price = 12
discount = 10

# Read as: subtract the discount from the price, then multiply.
total = items * (unit_price - discount)

print(total)

When a calculation matters to the reader, explicit parentheses can be better than relying on memory of the precedence table. They turn an implicit grouping rule into visible intent.

Some operators group right-to-left

1
2
3
4
5
6
7

power = 2 ** 3 ** 2
first = 2 ** (3 ** 2)
second = (2 ** 3) ** 2

print(power)
print(first)
print(second)

Most binary operators at the same precedence group from left to right. Exponentiation is an important exception, and conditional expressions also have their own right-to-left grouping rule. The conditional-expression lesson owns that syntax; here the important idea is that grouping direction is part of the language definition.

Unary minus and exponentiation

1
2
3
4
5

a = -2 ** 2
b = (-2) ** 2

print(a)
print(b)

This is a classic place where parentheses help. If the negative number itself is meant to be the base, write `(-2) ** 2` so the intended grouping is unmistakable.

Same precedence is not the same as same operation

1
2
3
4
5

result = 20 / 5 * 2
other = 20 / (5 * 2)

print(result)
print(other)

A useful habit is to identify the precedence level first, then apply the grouping direction for operators at that level. Parentheses can always make a different grouping explicit.

Precedence is different from evaluation order

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

events = []

def mark(name, value):
    events.append(name)
    return value

result = mark("left", 10) + mark("middle", 20) * mark("right", 30)

print(result)
print(events)

This distinction matters whenever evaluating an expression has an observable effect, such as calling a function. Precedence answers “how is the expression grouped?” Evaluation order answers “which subexpression runs first?” Python specifies left-to-right evaluation of expressions.

Function-call arguments are evaluated before the call

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

events = []

def make(label, value):
    events.append(label)
    return value

def add(left, right):
    return left + right

result = add(make("first", 2), make("second", 3))

print(result)
print(events)

Do not use precedence to predict side-effect order. A subexpression can belong to a lower-precedence part of the final grouping and still be evaluated before another subexpression that is grouped more tightly.

A practical reading method

1
2
3
4
5

score = 8 + 4 * 3
bonus = 10 if score >= 20 else 0
total = score + bonus

print(total)

When an expression looks dense, break it mentally into smaller parts. Decide which operators bind first, note any left-to-right or right-to-left grouping rule, then follow Python's evaluation order. If you need to explain the result to someone else, add parentheses or split the expression into named intermediate values.