# 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:

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

+ -

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

is is not

Identity operators

12

in not in

Membership operators

13

not or and

Logical operators