Python operators allow us to do common processing on variables. We will look into different types of python operators with examples and also operator precedence.

Table of Contents

## Python Operators

Python Operators are the special symbols that can manipulate values of one or more operands.

## Python Operator Types

Python operators can be classified into several categories.

- Arithmetic Operators
- Logical Operators
- Comparison Operators
- Bitwise Operators
- Assignment Operators

## Python Arithmetic Operators

Operator | Description | Example |
---|---|---|

+ | used to add two numbers | sum = a + b |

– | used for subtraction | difference = a – b |

* | used to multiply two numbers. If a string and int is multiplied then the string is repeated the int times. | mul = a*b
>>> “Hi”*5 |

/ | used to divide two numbers | div = b/a |

% | modulus operator, returns the remainder of division | mod = a%b |

** | exponent operator |

```
#create two variables
a=100
b=200
# addition (+) operator
print(a+b)
# subtraction (-) operator
print(a-b)
# multiplication (*) operator
print(a*b)
# division (/) operator
print(b/a)
# modulus (%) operator
print(a%b) # prints the remainder of a/b
# exponent (**) operator
print(a**b) #prints a^b
```

Output:

## Python Comparison Operators

Operator | Description | Example |
---|---|---|

== | returns True if two operands are equal, otherwise False. | flag = a == b |

!= | returns True if two operands are not equal, otherwise False. | flag = a != b |

> | returns True if left operand is greater than the right operand, otherwise False. | flag = a > b |

< | returns True if left operand is smaller than the right operand, otherwise False. | flag = a < b |

>= | returns True if left operand is greater than or equal to the right operand, otherwise False. | flag = a > b |

<= | returns True if left operand is smaller than or equal to the right operand, otherwise False. | flag = a < b |

```
# create two variables
a=100
b=200
# (==) operator, checks if two operands are equal or not
print(a==b)
# (!=) operator, checks if two operands are not equal
print(a!=b)
# (>) operator, checks left operand is greater than right operand or not
print(a>b)
# (<) operator, checks left operand is less than right operand or not
print(a<b)
#(>=) operator, checks left operand is greater than or equal to right operand or not
print(a>=b)
# (<=) operator, checks left operand is less than or equal to right operand or not
print(a<=b)
```

## Python Bitwise Operators

Operator | Description | Example |
---|---|---|

& | Binary AND Operator | x = 10 & 7 = 2 |

| | Binary OR Operator | x = 10 | 7 = 15 |

^ | Binary XOR Operator | x = 10 ^ 7 = 13 |

~ | Binary ONEs Compliment Operator | x = ~10 = -11 |

<< | Binary Left Shift operator | x = 10<<1 = 20 |

>> | Binary Right Shift Operator | x = 10>>1 = 5 |

```
#create two variables
a=10 # binary 1010
b=7 # binary 0111
# Binary AND (&) operator, done binary AND operation
print(a&b)
# Binary OR (|) operator, done binary OR operation
print(a|b)
# Binary XOR (^) operator, done binary XOR operation
print(a^b)
# Binary ONEs Compliment (~) operator, done binary One's Compliment operation
print(~a)
# Binary Left Shift (<<) operator, done binary Left Shift operation
print(a<<1)
# Binary Right Shift (>>) operator, done binary Right Shift operation
print(a>>1)
```

## Python Logical Operators

Operator | Description | Example |
---|---|---|

and | Logical AND Operator | flag = exp1 and exp2 |

or | Logical OR Operator | flag = exp1 or exp2 |

not | Logical NOT Operator | flag = not(True) = False |

```
#take user input as int
a=int(input())
# logical AND operation
if a%4==0 and a%3==0:
print("divided by both 4 and 3")
# logical OR operation
if a%4==0 or a%3==0:
print("either divided by 4 or 3")
# logical NOT operation
if not(a%4==0 or a%3==0):
print("neither divided by 4 nor 3")
```

## Python Assignment Operators

Operator | Description |
---|---|

+= | a+=b is equivalent to a=a+b |

*= | a*=b is equivalent to a=a*b |

/= | a/=b is equivalent to a=a/b |

%= | a%=b is equivalent to a=a%b |

**= | a**=b is equivalent to a=a**b (exponent operator) |

//= | a//=b is equivalent to a=a//b (floor division) |

```
# take two variable, assign values with assignment operators
a=3
b=4
print("a: "+str(a))
print("b: "+str(b))
# it is equivalent to a=a+b
a+=b
print("a: "+str(a))
print("b: "+str(b))
# it is equivalent to a=a*b
a*=b
print("a: "+str(a))
print("b: "+str(b))
# it is equivalent to a=a/b
a/=b
print("a: "+str(a))
print("b: "+str(b))
# it is equivalent to a=a%b
a%=b
print("a: "+str(a))
print("b: "+str(b))
# it is equivalent to a=a**b ( exponent operator)
a**=b
print("a: "+str(a))
print("b: "+str(b))
# it is equivalent to a=a//b ( floor division)
a//=b
print("a: "+str(a))
print("b: "+str(b))
```

## Python Operator Precedence

Precedence of python operators means the priority level of operators. This becomes vital when an expression has multiple operators in it. For example consider the following expression:

```
>>> 2+3*4
```

Now, what do you think the series of operation would be? We can add 2 and 3, then multiply the result by 4. Also, we can multiply 3 and 4 first, then add 2 with it. Here we can see that the operators’ precedence is important.

Below is a list of operators indicating the precedence level. It’s in descending order. That means the upper group has more precedence than that of the lower group.

- Parenthesis –
`()`

- Exponentiation –
`**`

- Compliment, unary plus and minus –
`~`

,`+`

,`-`

- Multiply, Divide, modulo –
`*`

,`/`

,`%`

- Addition and Subtraction –
`+`

,`-`

- Right and Left Shift –
`>>`

,`<<`

- Bitwise AND –
`&`

- Bitwise OR and XOR –
`|`

,`^`

- Comparison Operators –
`==`

,`!=`

,`>`

,`<`

,`>=`

,`<=`

- Assignment Operator-
`=`

Reference: Official Python Documentation