Scribd
Upload
49 views

Operator precedence in python

Uploaded by

Maaz Ansari
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
49 views

Operator precedence in python

Uploaded by

Maaz Ansari
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 3

In Python, operators have a specific order of precedence, which determines how

expressions are evaluated. Operators with higher precedence are evaluated before
operators with lower precedence. Here's the order of precedence from highest to lowest:

1. **Parentheses**: `()`
Used to override the default precedence and explicitly specify the order of evaluation.

2. **Exponentiation**: `**`
Evaluates from right to left.

3. **Unary Operators**: `+`, `-`, `~`


Unary plus, minus (negation), and bitwise NOT.

4. **Multiplication, Division, Modulus, Floor Division**: `*`, `/`, `%`, `//`

5. **Addition, Subtraction**: `+`, `-`

6. **Bitwise Shift Operators**: `<<`, `>>`


Left and right shifts.

7. **Bitwise AND**: `&`

8. **Bitwise XOR**: `^`

9. **Bitwise OR**: `|`

10. **Comparison Operators**: `==`, `!=`, `>`, `>=`, `<`, `<=`, `is`, `is not`, `in`, `not in`

11. **Boolean NOT**: `not`


Negates a Boolean expression.

12. **Boolean AND**: `and`

13. **Boolean OR**: `or`

14. **Assignment Operators**: `=`, `+=`, `-=`, `*=`, `/=`, `%=`, `//=`, `**=`, `&=`, `|=`, `^=`,
`>>=`, `<<=`

15. **Lambda Operator**: `lambda`


Used to define anonymous functions.

examples that demonstrate the precedence of operators in Python:

### 1. **Exponentiation vs Multiplication**


```python
result = 2 ** 3 * 2 # Exponentiation happens first
# Equivalent to: (2 ** 3) * 2
print(result) # Output: 16
```

### 2. **Multiplication vs Addition**


```python
result = 2 + 3 * 4 # Multiplication happens before addition
# Equivalent to: 2 + (3 * 4)
print(result) # Output: 14
```

### 3. **Parentheses Override Precedence**


```python
result = (2 + 3) * 4 # Parentheses change the order
print(result) # Output: 20
```

### 4. **Unary Minus vs Exponentiation**


```python
result = -3 ** 2 # Exponentiation happens before negation
# Equivalent to: -(3 ** 2)
print(result) # Output: -9
```

### 5. **Division vs Subtraction**


```python
result = 10 - 2 / 2 # Division happens before subtraction
# Equivalent to: 10 - (2 / 2)
print(result) # Output: 9.0
```

### 6. **Comparison vs Addition**


```python
result = 3 + 2 > 4 # Addition happens before comparison
# Equivalent to: (3 + 2) > 4
print(result) # Output: True
```

### 7. **Logical NOT vs AND**


```python
result = not True and False # NOT happens before AND
# Equivalent to: (not True) and False
print(result) # Output: False
```

### 8. **Bitwise AND vs OR**


```python
result = 2 | 3 & 1 # Bitwise AND happens before OR
# Equivalent to: 2 | (3 & 1)
print(result) # Output: 2
```

### 9. **Assignment and Arithmetic**


```python
x=5
x += 3 * 2 # Multiplication happens before assignment addition
# Equivalent to: x += (3 * 2)
print(x) # Output: 11
```

These examples illustrate how Python evaluates expressions based on operator


precedence, helping you understand which operations are performed first.

You might also like