# Python Basic Operators

Operators are the constructs which help to manipulate the value of operands.

Lets consider the expression 2 + 5 = 7. Here, 2 and 5 are called operands and + is called operator.

## Various types of Operator

Python language supports the seven types of operators which are as follows:

- Arithmetic Operators
- Comparison (Relational) Operators
- Assignment Operators
- Logical Operators
- Bitwise Operators
- Membership Operators
- Identity Operators

Let discuss all the operator categories one by one:

## Python Arithmetic Operators

Let's consider that variable a holds 10 and variable b holds 20, then −

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

+ Addition | Adds values on either side of the operator. | a + b = 30 |

- Subtraction | Subtracts right-hand operand from the left-hand operand. | a – b = -10 |

* Multiplication | Multiplies values on either side of the operator | a * b = 200 |

/ Division | Divides left-hand operand by right-hand operand | b / a = 2 |

% Modulus | Divides left-hand operand by right-hand operand and returns the remainder | b % a = 0 |

** Exponent | Performs exponential (power) calculation on operators | a**b =10 to the power 20 |

// | 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, that is rounded away from zero (towards negative infinity) − | 9//2 = 4 and 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0 |

## Python Comparison Operators

These type of operators compare the values on either side of them and select the relation among them. These are also known as Relational operators.

Here is the classification of various operators and their condition to become true. Let's consider variable a holds 10 and variable b holds 20, then

Operator | Explanation: | Illustrations |
---|---|---|

== | Values of two operands should be equal. | (a == b) is not true. |

!= | Values of two operands should be unequal. | (a != b) is true. |

<> | Values of two operands should be unequal. | (a <> b) is true. This operator is the same as != operator. |

> | Value of left operand should be greater than the value of the right operand. | (a > b) is not true. |

< | Value of left operand should be less than the value of the right operand. | (a < b) is true. |

>= | Value of left operand either greater than or equal to the value of the right operand. | (a >= b) is not true. |

<= | Value of left operand either less than or equal to the value of the right operand. | (a <= b) is true. |

## Python Assignment Operators

Lets study the various assignment operators. Consider variable a holds 10 and variable b holds 20, then -

Operator | Explanation | Illustrations |
---|---|---|

= | Assigns values to left side operands from right side operands | c = a + b assigns value of a + b into c |

+= Add AND | It adds right operand to the left operand and assigns the result to left operand | c += a is equivalent to c = c + a |

-= Subtract AND | It subtracts right operand from the left operand and assigns the result to left operand | c -= a is equivalent to c = c - a |

*= Multiply AND | It multiplies right operand with the left operand and assigns the result to left operand | c *= a is equivalent to c = c * a |

/= Divide AND | It divides left operand with the right operand and assigns the result to left operand | c /= a is equivalent to c = c / ac /= a is equivalent to c = c / a |

%= Modulus AND | It takes modulus using two operands and assigns the result to left operand | c %= a is equivalent to c = c % a |

**= Exponent AND | Performs exponential (power) calculation on operators and assign value to the left operand | c **= a is equivalent to c = c ** a |

//= Floor Division | It performs floor division on operators and assigns value to the left operand | c //= a is equivalent to c = c // a |

## Python Bitwise Operators

Bitwise operator works on bits and performs bit by bit operation. Consider if a = 60; and b = 13; Now in the binary format they will be written as follows −

```
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
```

Let's discuss some Bitwise operators supported by Python language which are as follows:

Operator | Explanation | Illustrations |
---|---|---|

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

| Binary OR | It copies a bit if it exists in either operand. | (a | b) = 61 (implies 0011 1101) |

^ Binary XOR | It copies the bit if it is set in one operand rather than both | (a ^ b) = 49 (implies 0011 0001) |

~ Binary One's Complement | It is unary and has the effect of 'flipping' bits. | (~a ) = -61 (means 1100 0011 in 2's complement form because of a signed binary number. |

<< Binary Left Shift | The left operands value is moved left by the number of bits stated by the right operand. | a << 2 = 240 (implies 1111 0000) |

>> Binary Right Shift | The left operands value is moved right by the number of bits specified by the right operand. | a >> 2 = 15 (implies 0000 1111) |

## Python Logical Operators

Various logical operators supported by Python language are as follows. Consider variable a holds 10 and variable b holds 20 then -

Operator | Explanation | Illustrations |
---|---|---|

and Logical AND | If both the operands are true then condition becomes true. | (a and b) is true. |

or Logical OR | If one of the two operands are non-zero then condition becomes true. | (a or b) is true. |

not Logical NOT | Helps to reverse the logical state of its operand. | Not(a and b) is false. |

## Python Membership Operators

Python’s membership operators test for membership in a series such as strings, lists, or tuples. There are two membership operators described as follows −

Operator | Explanation | Illustrations |
---|---|---|

in | It becomes true if it finds a variable in the specified sequence and otherwise false. | x in y, herein results in a 1 if x is a member of sequence y. |

not in | It becomes true if it does not find a variable in the specified sequence and otherwise false. | x not in y, here not in results in a 1 if x is not a member of sequence y. |

## Python Identity Operators

Identity operators correlate the memory locations of two objects. There are two Identity operators described as follows −

Operator | Explanation | Illustrations |
---|---|---|

is | It becomes true if the variables on either side of the operator point to the single object and otherwise false. | x is y, here is results in 1 if id(x) equals id(y). |

is not | It becomes false if the variables on either side of the operator point to the single object and otherwise true. | x is not y, here is not results in 1 if id(x) is not equal to id(y) |

## Python Operators Precedence

The table lists of all operators from highest precedence to lowest are as follows:

Sr.No. | Operator & Explanation |
---|---|

1 |
Exponentiation (raise to the power) |

2 |
Complement, unary plus and minus (concept names for the last two are [email protected] and [email protected]) |

3 |
Multiply, divide, modulo and floor division |

4 |
Addition and subtraction |

5 |
Right and left bitwise shift |

6 |
Bitwise 'AND' |

7 |
Bitwise exclusive `OR' and regular `OR' |

8 |
Comparison operators |

9 |
Equality operators |

10 |
Assignment operators |

11 |
Identity operators |

12 |
Membership operators |

13 |
Logical operators |