Python Tutorial



Python Tutorial

Operator Precedence in Python


Understanding operator precedence in Python is essential for anyone striving for proficiency in Python programming. Neglecting this crucial concept can lead to unexpected behaviors in your code. In this tutorial, we offer a detailed examination of this topic and provide you with the tools to code more efficiently.


Get ready to dive deep into the intricacies of operator precedence in Python. This tutorial showcases key principles, an informative table, the PEMDAS rule, and the associativity of operators in Python.

What is Operator Precedence in Python? 

Operator precedence is a set of rules that govern the order in which operators are evaluated when performing an operation. It's essential to understand these rules to avoid ambiguity in expressions, which could lead to unexpected results. Let's say you have an expression like 3 + 4 * 2. Is it (3 + 4) * 2 or 3 + (4 * 2)? Operator precedence answers this by assigning priorities to operators.

In Python, operator precedence is not merely an academic topic; it's crucial for practical applications. Mistakes in understanding the precedence can lead to bugs that are difficult to diagnose. Unlike some other programming languages, Python has its own unique set of rules governing operator precedence. In machine learning algorithms, a wrong understanding of operator precedence could result in incorrect computations, ultimately affecting the model's efficiency and accuracy.

Python's rich set of operators includes arithmetic operators like +, -, *, /, comparison operators like ==, !=, >, <, and logical operators like and, or, not, among others. Each category has its own precedence levels, which are internally hardcoded into the Python interpreter.

Understanding the precedence of operators in Python is also beneficial when you're transitioning from another programming language. Every language has its own set of rules for operator precedence, and what holds in one language may not necessarily be true in Python. Mastering the rules of operator precedence in Python will not only make you a better programmer but also help you understand how to read and debug other people's code more effectively.

Python Operators Precedence Table 

Understanding the precedence of operators in Python is a cornerstone for writing clear and effective code. Before diving deeper into the rules and guidelines, it is crucial to familiarize yourself with the hierarchy of Python operators through a precedence table.

The following table is an indispensable resource for anyone wanting to understand how Python operator precedence works:



Arithmetic Operators

**, *, /, +, -

Comparison Operators

==, !=, <=, >=, <, >

Logical Operators

not, and, or

Bitwise Operators

&, |, ^

Assignment Operators

=, +=, -=

  • Arithmetic Operators: From highest to lowest precedence, these are ** (exponential), * (multiplication), / (division), + (addition), - (subtraction).

  • Comparison Operators: These include == (equal), != (not equal), <= (less than or equal to), >= (greater than or equal to), < (less than), > (greater than).

  • Logical Operators: not has the highest precedence, followed by and, and then or.

  • Bitwise Operators: Bitwise AND &, OR |, and XOR ^.

  • Assignment Operators: The assignment operator = is used to set values, while += and -= are compound assignment operators that perform an operation and an assignment in a single step.

The order of precedence in Python is not just arbitrary; it's designed to minimize ambiguity in expressions, offering a clear path for execution, which becomes crucial in complex programming scenarios.

Python Operators Precedence Rule - PEMDAS 

PEMDAS stands for Parentheses, Exponents, Multiplication and Division, and Addition and Subtraction. This acronym serves as a useful mnemonic to remember the order of operations in Python. Understanding PEMDAS is a must for any Python programmer who wants to write error-free code. Let's look at each component:


Rule Component









Multiplication and Division

*, /


Addition and Subtraction

+, -

  • Parentheses (): Anything in parentheses is evaluated first, offering you a way to override other precedence rules.

  • Exponents **: Exponential calculations are performed next.

  • Multiplication and Division *, /: These are processed from left to right. They have the same level of precedence, which is where the left-to-right rule comes in.

  • Addition and Subtraction +, -: These are the last to be performed, also from left to right.

In Python, PEMDAS ensures that operations are executed in a specific sequence, minimizing errors and unexpected outputs in your code. When writing complex expressions, the PEMDAS rule helps to eliminate ambiguity. Therefore, it's vital for any professional aiming to advance their skills in Python, whether in data science, web development, or automation.

By grasping the Python Operators Precedence Rule, you align your programming logic closely with how Python is designed to interpret expressions, thereby reducing the chances of bugs and logical errors.

Associativity Rule

After internalizing the PEMDAS rule and operator precedence in Python, the next critical topic is associativity. This rule describes how Python resolves expressions when operators have the same precedence level. Associativity is particularly crucial when dealing with multiple operations that have the same level of priority, as it governs the direction in which these operations are evaluated—either from left-to-right or right-to-left.

Associativity Type


Left-Associative Operators

+, -, *, /

Right-Associative Operators

**, =

  • Left-Associative Operators: These include addition +, subtraction -, multiplication *, and division /. In an expression with these operators, Python evaluates from left to right. For example, in 3 + 4 - 2, Python will first add 3 + 4 to get 7 and then subtract 2 to yield 5.

  • Right-Associative Operators: These are the exponent ** and assignment = operators. When using these operators, Python evaluates from right to left. For example, in the expression 3 ** 2 ** 1, Python first calculates 2 ** 1 to get 2 and then computes 3 ** 2 to give 9.

The associativity rule is an indispensable part of understanding how Python evaluates expressions. Failure to understand this can lead to subtle, hard-to-catch errors in your code. It's crucial for a professional developer or data scientist to have a firm grip on these rules to write logical and error-free code effectively.

Understanding both operator precedence and associativity allows you to write expressions in Python that are not only syntactically correct but also logically sound. These rules ensure that your Python code behaves as expected, which is especially crucial when working with complex mathematical and logical operations. So, the next time you come across a complex expression, you'll know exactly how Python will interpret it, making debugging and problem-solving significantly easier.

Examples of Comparison Operators

x = 5
y = 10
# Equality
result1 = x == y  # False
# Inequality
result2 = x != y  # True
# Less than
result3 = x < y   # True
# Greater than or equal to
result4 = x >= y  # False

Examples of Logical Operators

x = True
y = False
# Logical AND
result1 = x and y  # False
# Logical OR
result2 = x or y   # True
# Logical NOT
result3 = not x    # False

Examples of Arithmetic Operators

a = 10
b = 3
# Addition
addition_result = a + b  # 13
# Subtraction
subtraction_result = a - b  # 7
# Multiplication
multiplication_result = a * b  # 30
# Division
division_result = a / b  # 3.3333333333333335
# Modulus
modulus_result = a % b  # 1
# Exponentiation
exponentiation_result = a ** b  # 1000
# Floor Division
floor_division_result = a // b  # 3

Examples of Bitwise Operators

x = 5  # 0b101 (binary representation)
y = 3  # 0b011 (binary representation)
# Bitwise AND
bitwise_and_result = x & y  # 1 (binary: 0b001)
# Bitwise OR
bitwise_or_result = x | y  # 7 (binary: 0b111)
# Bitwise XOR
bitwise_xor_result = x ^ y  # 6 (binary: 0b110)
# Bitwise NOT (inverts all bits)
bitwise_not_result = ~x  # -6 (binary: 0b11111111111111111111111111111010)
# Left Shift
left_shift_result = x << 2  # 20 (binary: 0b10100)
# Right Shift
right_shift_result = x >> 1  # 2 (binary: 0b10)

Examples of Assignment Operators

x = 10
# Addition Assignment
x += 5  # Equivalent to x = x + 5, x is now 15
# Subtraction Assignment
x -= 3  # Equivalent to x = x - 3, x is now 12
# Multiplication Assignment
x *= 2  # Equivalent to x = x * 2, x is now 24
# Division Assignment
x /= 4  # Equivalent to x = x / 4, x is now 6.0
# Modulus Assignment
x %= 5  # Equivalent to x = x % 5, x is now 1.0
# Exponentiation Assignment
x **= 3  # Equivalent to x = x ** 3, x is now 1.0
# Floor Division Assignment
x //= 2  # Equivalent to x = x // 2, x is now 0.0

Operator Precedence in Python With Examples

In Python, operators have different precedence levels. The precedence determines the order in which these operators are evaluated in complex expressions. For example, the general precedence for logical operators from highest to lowest is:

1. not

2. and

3. or

You can use parentheses to control the order of evaluation if needed.

Here is an example:


x = True
y = False
z = True
result = x or y and not z  # Equivalent to: x or (y and (not z))

In this example, not has the highest precedence, followed by and, and then or. Therefore, y and not z is evaluated first, and then the result is combined with x using or.

Using parentheses allows us to explicitly specify the order of evaluation and helps in retaining operator precedence. This is especially useful in complex expressions to ensure the desired behavior.

Here is another example:

x = True
y = False
z = True
result1 = (x or y) and not z  # Equivalent to: (x or y) and (not z)
result2 = x or (y and not z)  # Equivalent to: x or (y and (not z))

In this example as well, parentheses are again used to clarify the order of evaluation for the logical operators, ensuring that the desired precedence is retained.


Mastering operator precedence in Python will significantly enhance your coding skills and reduce bugs in your programs. For those keen on mastering Python and taking their skills to the next level, upGrad has a range of courses tailored to the needs of professionals. Take your next step in becoming an expert Python programmer by enrolling in one of these comprehensive courses.


1. What is the Order of Precedence in Python?

Python's built-in rules define the order, as detailed in our Python operator precedence Table.

2. Is operator precedence in Python different from other languages?

Yes, Python has unique rules, unlike languages like C++ or Java.

3. How does PEMDAS work in Python?

PEMDAS is a rule set for remembering the order of operations in Python.

4. What is the associativity rule in Python?

Associativity rules dictate the sequence in which operators with the same precedence level are evaluated.

5. Are there advanced Python courses?

Absolutely, upGrad offers a variety of advanced Python courses designed for professionals.

Leave a Reply

Your email address will not be published. Required fields are marked *