Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
48 views

Operator precedence in python

Uploaded by

Maaz Ansari
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
48 views

Operator precedence in python

Uploaded by

Maaz Ansari
Copyright
© © All Rights Reserved
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