Skip to content

Demystifying Operator Precedence and Parentheses in Python

Updated: at 04:23 AM

Understanding operator precedence and proper parenthesization is key to writing correct and robust Python code, especially when dealing with complex expressions. This comprehensive guide will explain operator precedence, demonstrate through examples why it matters, overview the use of parentheses to control evaluation order, and provide actionable tips for Python developers at all levels.

Table of Contents

Open Table of Contents


In Python, the order in which expressions are evaluated depends on the precedence and associativity of the operators. Operators with higher precedence get evaluated first. For operators with the same precedence, associativity determines whether they are evaluated from left-to-right or right-to-left.

Failure to understand these rules can lead to unexpected results and bugs that are difficult to detect, since syntactically the code looks correct. Mastering the proper use of parentheses to control evaluation order is an essential Python skill.

This guide will cover:

Understanding these concepts will give you greater confidence in writing complex Python expressions correctly and robustly.

Operator Precedence in Python

Python defines operator precedence rules that determine the order in which operations are performed in an expression. Operators with higher precedence get evaluated before those with lower precedence.

For example:

2 + 3 * 4
# Output: 14, not 20

The multiplication is evaluated first since it has higher precedence than addition. The expression is treated as (2 + (3 * 4)) rather than ( (2 + 3) * 4).

The relative precedence of arithmetic operators in Python, from highest to lowest, is:

**        # Exponent
~ + -     # Unary plus/minus
* / % //  # Multiplication, division, modulo, floor division
+ -       # Addition, subtraction
>> <<     # Right and left bitwise shifts
&         # Bitwise AND
^ |        # Bitwise XOR and OR

Python also defines precedence levels for comparison operators (>, ==, etc.), Boolean operators (and, or, not) and assignment operators (=, +=, etc.).

Consult the official operator precedence table for a complete overview.

Associativity of Operators

Associativity determines the order in which operators with the same precedence are evaluated either from left-to-right or right-to-left.

Most Python operators are left-associative, meaning they are evaluated from left-to-right. For example:

100 - 10 - 5
# Evaluated as (100 - 10) - 5 = 85

The exceptions are the exponentiation (**) and assignment operators (=, +=, etc.) which are right-associative:

2 ** 3 ** 2
# Right-associative, evaluated as 2 ** (3 ** 2) = 512

x = y = z = 1
# Right-associative, z = 1, y = z, x = y
# All three variables take value 1

Understanding associativity avoids ambiguities in chained expressions.

Common Pitfalls with Operator Precedence

Misunderstanding precedence and associativity leads to subtle bugs and unintuitive results. Here are some common pitfalls to be aware of:

1. Mixed arithmetic and comparison operators

Comparison operators have higher precedence than arithmetic operators except exponentiation. So expressions like:

x + 1 > 2 + 3
# Evaluated as x + (1 > 2) + 3

Can give incorrect results. Use parentheses to make the intent clear.

**2. Confusion with Boolean operators **

The Boolean operators and and or have lower precedence than comparisons. So:

x > 0 and y > 0
# Evaluated as x > (0 and y) > 0

To get the expected behavior, use parentheses:

(x > 0) and (y > 0)

3. Assignment operator precedence

The assignment operator (=) has very low precedence. Chained assignments like:

x = y = z = 1

Are evaluated right-to-left due to right-associativity. Always use parentheses in assignment expressions for clarity.

4. Exponentiation precedence

The exponentiation operator ** has higher precedence than multiplication and division. Make sure to parenthesize properly when mixing exponents with other terms:

2 * x**3   # Precedence OK
x**3 / 2   # Precedence problem, fix with (x**3)/2

Using Parentheses to Control Order of Evaluation

Parentheses can explicitly control the order of evaluation, overriding the default precedence rules.

Proper use of parentheses removes ambiguity and makes the code easier to read and maintain.

Here are some cases where judicious use of parentheses is recommended:

1. Conflicting precedence

Use parentheses when operator precedence causes non-intuitive evaluation order:

x = 1 + 2 * 3
# By default evaluated as x = 1 + (2 * 3)

x = (1 + 2) * 3
# Parentheses change evaluation to expected result

2. Long or complex expressions

Parenthesize sub-expressions in long chains of operations for readability:

y = ((x ** 3 - 4) * (z - 2)) / (x + y)

3. Assignment expressions

Use extra parentheses around groups of assignments:

(x, y, z) = (1, 2, 3)

4. Boolean logic expressions

Add parentheses to Boolean expressions for explicit grouping:

if (x > 0) and (y > 0):

5. Function arguments

Parenthesize function arguments to avoid passing wrong values:

my_func(x, y + 1, (z ** 3))

Best Practices for Readability

Follow these practices in your code for clarity and readability:

Adhering to best practices removes uncertainty around precedence rules and makes your code less prone to bugs.


Understanding operator precedence and proper parenthesization is an essential Python skill. Failure to account for precedence can lead to unexpected behavior, hard-to-detect bugs, and unintuitive code. Use this guide to gain mastery over Python operator precedence and parentheses.

The key takeaways are:

With these skills, you can write Python code that is clear, robust, and communicates intention unambiguously. Mastering operator precedence will level up your Python programming abilities.