# Precedence and Associativity of Operators in Python

Last Updated : 01 Jul, 2023

In Python, operators have different levels of precedence, which determine the order in which they are evaluated. When multiple operators are present in an expression, the ones with higher precedence are evaluated first. In the case of operators with the same precedence, their associativity comes into play, determining the order of evaluation.

## Operator Precedence and Associativity in Python

Please see the following precedence and associativity table for reference. This table lists all operators from the highest precedence to the lowest precedence.

Precedence Operators Description Associativity

1

()

Parentheses

Left to right

2

x[index], x[index:index]

Subscription, slicing

Left to right

3

await x

Await expression

N/A

4

**

Exponentiation

Right to left

5

+x, -x, ~x

Positive, negative, bitwise NOT

Right to left

6

*, @, /, //, %

Multiplication, matrix, division, floor division, remainder

Left to right

7

+,

Left to right

8

<<, >>

Shifts

Left to right

9

&

Bitwise AND

Left to right

10

^

Bitwise XOR

Left to right

11

|

Bitwise OR

Left to right

12

in, not in, is, is not, <, <=, >, >=, !=, ==

Comparisons, membership tests, identity tests

Left to Right

13

not x

Boolean NOT

Right to left

14

and

Boolean AND

Left to right

15

or

Boolean OR

Left to right

16

if-else

Conditional expression

Right to left

17

lambda

Lambda expression

N/A

18

:=

Assignment expression (walrus operator)

Right to left

## Precedence of Python Operators

This is used in an expression with more than one operator with different precedence to determine which operation to perform first.

Example

`10 + 20 * 30`

`10 + 20 * 30 is calculated as 10 + (20 * 30)and not as (10 + 20) * 30`

Python Code of the above Example

## Python3

 `# Precedence of '+' & '*'` `expr ``=` `10` `+` `20` `*` `30`   `print``(expr)`

Output

`610`

### Precedence of Logical Operators in Python

In the given code, the ‘if‘ block is executed even if the age is 0. Because the precedence of logical ‘and‘ is greater than the logical ‘or‘.

## Python3

 `# Precedence of 'or' & 'and'` `name ``=` `"Alex"` `age ``=` `0`   `if` `name ``=``=` `"Alex"` `or` `name ``=``=` `"John"` `and` `age >``=` `2``:` `    ``print``(``"Hello! Welcome."``)` `else``:` `    ``print``(``"Good Bye!!"``)`

Output

`Hello! Welcome.`

Hence, To run the ‘else‘ block we can use parenthesis( ) as their precedence is highest among all the operators.

## Python3

 `# Precedence of 'or' & 'and'` `name ``=` `"Alex"` `age ``=` `0`   `if` `(name ``=``=` `"Alex"` `or` `name ``=``=` `"John"``) ``and` `age >``=` `2``:` `    ``print``(``"Hello! Welcome."``)` `else``:` `    ``print``(``"Good Bye!!"``)`

Output

`Good Bye!!`

## Associativity of Python Operators

If an expression contains two or more operators with the same precedence then Operator Associativity is used to determine. It can either be Left to Right or from Right to Left.

Example

In this code, ‘*’ and ‘/’ have the same precedence and their associativity is Left to Right, so the expression “100 / 10 * 10” is treated as “(100 / 10) * 10”.

Code

## Python3

 `# Left-right associativity` `# 100 / 10 * 10 is calculated as` `# (100 / 10) * 10 and not` `# as 100 / (10 * 10)` `print``(``100` `/` `10` `*` `10``)`   `# Left-right associativity` `# 5 - 2 + 3 is calculated as` `# (5 - 2) + 3 and not` `# as 5 - (2 + 3)` `print``(``5` `-` `2` `+` `3``)`   `# left-right associativity` `print``(``5` `-` `(``2` `+` `3``))`   `# right-left associativity` `# 2 ** 3 ** 2 is calculated as` `# 2 ** (3 ** 2) and not` `# as (2 ** 3) ** 2` `print``(``2` `*``*` `3` `*``*` `2``)`

Output

`10060512`

## Operators Precedence and Associativity in Python

Operators Precedence and Associativity are two main characteristics of operators that determine the evaluation order of sub-expressions in the absence of brackets.

Example

`100 + 200 / 10 - 3 * 10`

`100 + 200 / 10 - 3 * 10 is calculated as 100 + (200 / 10) - (3 * 10)and not as (100 + 200) / (10 - 3) * 10`

Python Code of the above Example

## Python3

 `expression ``=` `100` `+` `200` `/` `10` `-` `3` `*` `10` `print``(expression)`

Output

`90.0`

### Non-associative Operators

In Python, most operators have associativity, which means they are evaluated from left to right or right to left when they have the same precedence. However, there are a few operators that are non-associative, meaning they cannot be chained together.

Example

## Python3

 `a ``=` `5` `b ``=` `10` `c ``=` `15`   `a ``=` `b ``=` `(a < b) ``+``=` `(b < c)`

Output

`a = b= (a < b) += (b < c)                   ^^SyntaxError: invalid syntax`

Previous
Next