Python Operator Precedence

What does 2 + 3 * 4 give in Python: 20 or 14? The answer is 14, and the reason is Python operator precedence, the rules that decide which part of an expression runs first. In this lesson, you'll see the complete precedence table, learn a few surprising cases like -2 ** 2, and find out why good programmers use parentheses even when they don't strictly need them.

What is operator precedence in Python?

Precedence is the priority of an operator. When an expression contains several operators, Python runs the ones with higher precedence first. Multiplication has higher precedence than addition, so in 2 + 3 * 4, Python multiplies first:

print(2 + 3 * 4)
print((2 + 3) * 4)

14
20

Parentheses have the highest priority of all, so they let you choose the order yourself.

Python operator precedence table

Here are the operators you've learned in this chapter, from highest priority (runs first) to lowest (runs last):

Python also has bitwise operators (like &, | and ^) that sit between arithmetic and comparisons, but you won't need them as a beginner. The plain assignment operators (=, += and friends) aren't in the table because they're statements, not operators inside an expression: they always happen last.

How Python evaluates an expression step by step

Let's watch Python work through 10 + 2 * 3 ** 2 - 4. At each step, it finds the operator with the highest precedence and replaces that part with its result:

print(10 + 2 * 3 ** 2 - 4)

24

What happens when operators have the same precedence?

When operators share a level, Python uses associativity, the direction it reads them in. Almost every operator is left-associative: it runs from left to right.

print(100 / 10 / 2)    # (100 / 10) / 2
print(20 - 5 - 3)      # (20 - 5) - 3
print(12 // 5 * 5)     # (12 // 5) * 5

5.0
12
10

Why is ** right-associative?

The exponent operator is the exception: it runs from right to left, just like stacked exponents in math.

print(2 ** 3 ** 2)      # 2 ** (3 ** 2) = 2 ** 9
print((2 ** 3) ** 2)    # 8 ** 2

512
64

Why is -2 ** 2 equal to -4 in Python?

This one surprises almost everyone. ** has higher precedence than the minus sign in front of a number, so Python squares first and applies the minus afterwards:

print(-2 ** 2)      # -(2 ** 2)
print((-2) ** 2)

temperature = -3
print(temperature ** 2)

-4
4
9

Notice the last example: when the negative number is stored in a variable, the minus sign is part of the value, so squaring gives 9 as you'd expect. The trap only appears when you type the minus sign directly in front of the number.

In what order do not, and and or run?

Among the logical operators, not runs first, then and, then or. This can change the meaning of a condition completely:

is_vip = True
has_ticket = False
door_open = False

print(is_vip or has_ticket and door_open)     # is_vip or (has_ticket and door_open)
print((is_vip or has_ticket) and door_open)

True
False

Same three values, different answers. In the first line, and runs first, so a VIP gets in even though the door is closed. Also remember that comparisons run before logic, so age >= 18 and age < 65 needs no extra brackets.

print(not 5 > 3)       # not (5 > 3)
print(1 + 1 == 2 and 3 > 2)

False
True

Real-world example: price with discount and tax

A jacket costs $80. It's 25% off, and then 8% sales tax is added. Here's a version without enough parentheses, and the fixed version:

price = 80
discount = 0.25
tax = 0.08

wrong = price - price * discount * 1 + tax
right = (price - price * discount) * (1 + tax)

print("Wrong:", wrong)
print("Right:", round(right, 2))

Wrong: 60.08
Right: 64.8

The wrong version is just the right formula with the parentheses removed. Multiplication runs first and then + tax just adds 8 cents to the discounted price. The parentheses make Python apply the discount first and multiply the whole discounted price by 1.08.

When should you use parentheses?

Use them whenever a reader might have to stop and think. Parentheses never slow your program down, and they make your intent obvious:

hours = 3
minutes = 45

total_minutes = hours * 60 + minutes          # correct, but you must know the rules
total_minutes = (hours * 60) + minutes        # same result, clearer
print(total_minutes)

225

Common mistakes with operator precedence

1. Calculating an average without parentheses

score1 = 80
score2 = 90
print(score1 + score2 / 2)
print((score1 + score2) / 2)

125.0
85.0

Without parentheses, only score2 is divided by 2.

2. Expecting -2 ** 2 to be 4

Write (-2) ** 2 when you want to square a negative number.

3. Mixing and and or without parentheses

a or b and c means a or (b and c). If you meant (a or b) and c, say so with parentheses.

4. Forgetting that ** reads right to left

2 ** 3 ** 2 is 512, not 64.

Practice exercise

print(5 + 4 * 2)
print(20 / 4 * 2)
print(3 ** 2 ** 2)
print(-3 ** 2)
print(not 4 > 2 or 1 == 1)

print(5 + 4 * 2)            # 4 * 2 first, then + 5
print(20 / 4 * 2)           # left to right: (20 / 4) * 2
print(3 ** 2 ** 2)          # right to left: 3 ** 4
print(-3 ** 2)              # -(3 ** 2)
print(not 4 > 2 or 1 == 1)  # (not True) or True

13
10.0
81
-9
True

What's next?

Congratulations, you've finished the Operators chapter! You can now calculate, update, compare and combine values in Python. Next, dive into one of the most used data types in any program, text, in Python strings.