# Operators in Python

Updated on May 20, 2019 I'm a software developer with a great interest in data analysis and statistics.

Python supports the following types of operators:

• Arithmetic operators
• Comparison operators
• Assignment operators
• Logical operators
• Bitwise operators
• Membership operators
• Identity operators

Let us learn about each of these operators in detail.

## Arithmetic Operators in Python

Almost all operators which are supported in languages like C/C++ or Java are supported in Python. The operators +, -, / , * and % represent addition, subtraction, division, multiplication and modulus respectively. In addition to these, ** performs exponential calculation and // performs floor division. For the sake of the article’s brevity, we will focus more on operators unique to Python.

```#!/usr/bin/python3
# following code demonstrates use of exponential operator.
x = 10
y = 3
print(x, " ** ", y, "=", x**y)  # output: 10  **  3 = 1000```

The following code demonstrates the use of floor operation. In floor division, if the numerator is a positive number, the result is rounded towards zero. If the numerator is negative, the result is rounded away from zero.

```#!/usr/bin/python3

# floor division with positive numerator
a = 10
b = 5.2
print(a,"/", b, "=", a/b) # output: 10 / 5.2 = 1.923076923076923
print(a,"//", b, "=", a//b) # output: 10 // 5.2 = 1.0

# floor division with negative numerator
a = -10
b = 5.2
print(a,"/", b, "=", a/b) # output: -10 / 5.2 = -1.923076923076923
print(a,"//", b, "=", a//b) # output: -10 // 5.2 = -2.0```

## Python Comparison Operators

Almost all comparison operators supported by languages like C/C++ or Java are supported by Python. The operators ==, !=. >,<, >= and <= denote equal to, not equal to, greater than, less than, greater than or equal to, and less than or equal to respectively.

## Assignment Operators in Python

Equals symbol (=) is used by Python to assign a value on the right-hand side of expression to the variable on the left-hand side. Like other languages like C++ and Java, Python supports Operator-And operations where the result of the operation is assigned to the left.

```#!/usr/bin/python3
# demonstration of assignment operators
c = 10
d = 20
print("original value of c", c) # output: original value of c 10
print("original value of d", d) # output: original value of d 20
c+= d
print("New value of c after performing c+=d ",c) # output: New value of c after performing c+=d  30
c-=d
print("New value of c after performing c-=d", c) # output: New value of c after performing c-=d 10
```

Like += operation, all other arithmetic operators available in Python can be clubbed with equals symbol to formulate respective Operator-And operators.

## Logical Operators

AND, OR and NOT are the three basic logical operators supported by Python.

```#!/usr/bin/python3
# demonstration of logical operators
exp1 = True
exp2 = False

print("exp1 and exp2 = ", (exp1 and exp2)) # output: exp1 and exp2 =  False
print("exp1 or exp2 = ", (exp1 or exp2)) # output: exp1 or exp2 =  True
print(" Not(exp1) = ", not(exp1)) # output: Not(exp1) =  False```

## Bitwise Operators

Python supports AND(&), OR(|), XOR(^), One’s compliment or flipping of bits(~), left shift (<<) and right shift(>>) operators. There is a built-in function called bin() which gives the given integer in binary representation. To demonstrate the bitwise operations, we use this while printing the output in the sample code:

```#!/usr/bin/python3
a = 54            # 54 = 0011 0110
b = 8            # 8 = 0000 1000
print ('a=',a,':',bin(a),'b=',b,':',bin(b))
c = 0

c = a & b;        # 0011 0110 AND 0000 1000 = 0000 0000 = 0
print ("result of AND is ", c,':',bin(c))

c = a | b;        # 0011 0110 OR 0000 1000 = 0011 1110 = 62
print ("result of OR is ", c,':',bin(c))

c = a ^ b;        # 0011 0110 XOR 0000 1000 = 0011 1110 = 62
print ("result of EXOR is ", c,':',bin(c))

c = ~a;           # -55 = 1100 1001
print ("result of COMPLEMENT is ", c,':',bin(c))

c = a << 2;       # 216 = 1101 1000
print ("result of LEFT SHIFT is ", c,':',bin(c))

c = a >> 2;       # 13 = 0000 1101
print ("result of RIGHT SHIFT is ", c,':',bin(c))```

Output of the above code will be:

```a= 54 : 0b110110 b= 8 : 0b1000
result of AND is 0 : 0b0
result of OR is 62 : 0b111110
result of EXOR is 62 : 0b111110
result of COMPLEMENT is -55 : -0b110111
result of LEFT SHIFT is 216 : 0b11011000
result of RIGHT SHIFT is 13 : 0b1101```

## Membership Operators

In and not in are the two membership operators. These are used to find out if a given value on LHS is present in the construct of RHS.

```#!/usr/bin/python3
firstTuple = ( 'Welcome', "To" , "List", 'Tutorial', 3.0  )
str1 = "Hello"
str2 = "Welcome"
if str1 in firstTuple:
print(str1, " is present in firstTuple")
else:
print(str1, " is NOT present in firstTuple")
if str2 in firstTuple:
print(str2, " is present in firstTuple")
else:
print(str2, " is NOT present in firstTuple")```

Output for the above program will be:

```Hello is NOT present in firstTuple
Welcome is present in firstTuple```

## Identity Operators

Is and is not are the identity operators in Python. These are used to verify if variables on LHS and RHS point to the same object in memory or not.

```#!/usr/bin/python3

var1 = 2
var2 = var1
var3 = 9
print(var1)
print(var2)
print(var3)

if(var1 is var2):
print("var1 and var2 have same location")
else:
print("var1 and var2 have different locations")

if(var3 is not var2):
print("var3 and var2 have different locations")
else:
print("var3 and var2 have same location")```

Output of the above program will be:

```1397774624
1397774624
1397774736
var1 and var2 have same location
var3 and var2 have different locations```