In every programming language, operators are used for performing various types of operations on any given operand(s). They are used to evaluate different types of expressions and to manipulate the values of operands or variables by performing different operations on them.

In python, we have 7 different types of operators, they are:

- Arithmetic Operators
- Comparison Operators
- Assignment Operators
- Logical Operators
- Bitwise Operators
- Membership Operators
- Identity Operators

While the first five are commonly used operators the last two i.e **Membership** and **Identity** operators are exclusive to python.

Arithmetic operators are the operators used for performing arithmetic operations on **numeric** operands like division, subtraction, addition etc.

Following are different arithmetic operators:

To multiply values on either side of the operator.Operator | Usage | Description |
---|---|---|

`+` | `a + b` | Adds values on either side of the operator. |

`-` | `a - b` | Subtracts the right hand operand from the left hand operand. |

`*` | `a*b` | |

`/` | `a/b` | Divides left hand operand by right hand operand(returns float value). |

`%` | `a % b` | Returns the remainder from dividing left hand operand by right hand operand. |

`**` | `a**b` | Returns Exponent – left operand raised to the power of right |

`//` | `a//b` | Floor Division – The division of operands where the result is the quotient in which the digits after the decimal point are removed. But if one of the operands is negative, the result is floored, i.e., rounded away from zero(towards negative infinity). |

Let's have a few code examples:

```
>>>3+2
5
>>>4-3
1
>>>3/2
1.5
```

These operators are used to compare the values of operands on either side of this type of operators. These operators return `true`

or `false`

Boolean values. They return **true** if the condition is satisfied otherwise the return **false**.

Following are different comparison operators:

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

`==` | `a == b` | Returns True if the values on the either side of the operator is equal otherwise False. |

`!=` | `a != b` | Returns True if the values on either sides of the operator is not equal to each other otherwise False. |

`>` | `a > b` | Returns True if the value of the operand on the left of the operator is greater than the value on the right side of the operator. |

`<` | `a < b` | Returns True if the value of the operand on the left of the operator is less than the value on the right side of the operator. |

`>=` | `a >= b` | Returns True if the value of the operand on the left of the operator is greater than or equal to the value on the right side of the operator. |

`<=` | `a <= b` | Returns True if the value of the operand on the left of the operator is less than or equal to the value on the right side of the operator. |

Let's have a few code examples:

```
>>> 3 == 2
False
>>> 3 != 2
True
>>> 2<=4
True
```

The assignment operator is used to assign a specific value to a variable or an operand.

The equal to (`=`

) operator is used to assign a value to an operand directly, if we use any arithmetic operator (`+`

, `-`

, `/`

, etc.) along with the equal to operator then it will perform the arithmetic operation on the given variable and then assign the resulting value to that variable itself.

Let's have a few code examples:

```
>>> x=2
>>> x
2
>>> x+=1
>>> x
3
>>> x-=1
>>> x
2
```

The logical operators are used to perform logical operations (like **and**, **or**, **not**) and to combine two or more conditions to provide a specific result i.e. true or false.

Following are different logical operators:

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

`and` | `x and y` | True if both sides of the operator is True |

`or` | `x or y` | True if either of the operand is True |

`not` | `not x` | Complements the operand |

Bitwise operator acts on the operands bit by bit. These operators take one or two operands. Some of the the bitwise operators appear to be similar to logical operators but they aren't.

Following are different bitwise operators:

It copies a bit if it exists in either operand.Operator | Usage | Description |
---|---|---|

`&` Binary AND | `(a & b)` | Operator copies a bit to the result if it exists in both operands. |

`|` Binary OR | `(a | b)` | |

`^` Binary XOR | `(a ^ b)` | It copies the bit if it is set in one operand but not both. |

`~` 1's complement | `(~a)` | It is unary and has the effect of 'flipping' bits. |

`<<` Binary Left Shift | `a << 2` | The left operands value is moved left by the number of bits specified by the right operand. |

`>>` Binary Right Shift | `a >> 2` | The left operands value is moved right by the number of bits specified by the right operand. |

Let's have a few code examples:

```
>>> a = 3
>>> b = 4
>>> a = 3 # equivalent binary is 0011
>>> b = 4 # equivalent binary is 0100
>>> a & b
0
>>> a | b
7
>>> # 7 is equivalent to 0111 in binary
```

The membership operators are used to test whether a value is in a specific sequence or not like in lists, tuples, string, etc. It returns True or False as output.

Following are different membership operators:

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

`in` | `x in y` | True if the value/operand in the left of the operator is present in the sequence in the right of the operator. |

`not in` | `x not in y` | True if the value/operand in the left of the operator is not present in the sequence in the right of the operator. |

Let's have a few code examples:

```
>>> lst=[2,3,6,7,9,1]
>>> x=2
>>> y=5
>>> x in lst
True
>>> y in lst
False
```

The identity operators are used to test whether a variable refers to same value/object or not. It returns True or False as output.

Following are different identity operators:

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

`is` | `x is True` | True if both the operands refer to the same object. |

`is not` | `x is not True` | Evaluates to false if the variables on either side of the operator point to the same object and true otherwise. |

Let's have a few code examples:

```
>>> x=4
>>> y=4
>>> z=2
>>> x is y
True
>>> z is x
False
```