An operator is a symbol that performs an operation. An operator acts on some variables, called operands to get the desired result.
If an operator acts on a single variable, it is called unary operator; if it acts on two variables, it is called binary operator; and if it acts on three variables, then it is called ternary operator.
These operators are used to perform basic arithmetic operations like addition, subtraction, division, etc. There are seven arithmetic operators available in Python. Since these operators act on two operands, they are called 'binary operators' also. Let's assume a = 7 and b = 3 and see the effect of various arithmetic operators in the Table
Arithmetic
Operators
These
operators are used to perform basic arithmetic operations like
addition, subtraction, division, etc. There are seven
arithmetic operators available in Python. Since these operators
act on two operands, they are called 'binary operators' also.
Let's assume a = 7 and b = 3 and see the effect of
various arithmetic operators in the Table
Meaning 
Example 
Result 

+ 
Addition
operator. Adds two values. 
a+b 
10 
 
Subtraction
operator. Subtracts one value from another. 
a
b 
4 
* 
Multiplication
Operator. Multiplies values on either side of the operator. 
a*b 
21 
/ 
Division
Operator. Divides left operand by the right operand. 
a
/b 
2.3333333333333335 
% 
Modulus
Operator. Gives remainder of division. 
a%b 
1 
** 
Exponent
Operator. Calculates exponential power value. a**b gives
the value of a to the power of b. 
a**b 
343 
// 
Integer
Division. This is also called as Floor Division and gives
only integer quotient. 
a
//b 
2 
When
there is an expression that contains several arithmetic
operators, we should know which operation is done first and
which operation is done next. In such cases, the following
order of evaluation is used:
Let's
take a sample expression: d = (x+y)*z**a//b+c.
Assume
the values of variables as: x=1; y=2; z=3; a=2; b=2; c=3.
Then,
the given expression d = (1+2)*3**2//2+3 will evaluate
as:
For
order of precedence, just remember this PEMDAS (similar to BODMAS)
Problem
Statement
Given
an amount, find the minimum number of notes of different
denominations that sum upto the given
amount. Starting from the highest denomination note, try to
accommodate as many notes possible for given amount.
Input 
Output 
Hints
 Calculation 
9800 
9 
4x2000
+ 3x500 + 1x200 + 1x100, 4+3+1+1 
4500 
3 
2x2000
+ 1x500, 2+1 
5500 
5 
2x2000
+ 3x500, 2+3 
2000 
1 
1x2000 
a=int(input())
t=a//2000
r=a%2000
f=r//500
r=r%500
th=r//200
r=r%200
h=r//100
print
("2000's = ",t)
print
("500's = ",f)
print
("200's = ",th)
print
("100's = ",h)
print
("Total no of notes = ",t+f+th+h)
Assignment
Operators
These
operators are useful to store the right side value into a left
side variable. These operators are shown in Table. In Table,
let's assume the values x = 20, y = 10 and z = 5:
Example

Meaning 
Result 

= 
z
= x + y 
Assignment
operator. Stores right side value into left side variable,
i.e. x+y is stored into z.

z
= 30 
+= 
z
+= x 
Addition
assignment operator. Adds right operand to the left operand
and stores the result into left operand, i.e. z = z+x.

z
= 25 
= 
z
= x 
Subtraction
assignment operator. Subtracts right operand from left
operand and stores the result into left operand, i.e. z =
zx. 
z
= 15 
*= 
z
*= x 
Multiplication
assignment operator. Multiplies right operand with left
operand and stores the result into left operand, i.e. z = z
*x. 
z
= 100 
/= 
z
/= x 
Division
assignment operator. Divides left operand with right
operand and stores the result into left operand, i.e. z =
z/x.

z
= 0.25 
%= 
z
%= x 
Modulus
assignment operator. Divides left operand with right
operand and stores the remainder into left operand, i.e. z
= z%x. 
z
= 5 
**= 
z
**= y 
Exponentiation
assignment operator. Performs power value and then stores
the result into left operand, i.e. z = z**y. 
z=
9765625 
//= 
z
//= y 
Floor
division assignment operator. Performs floor division and
then stores the result into left operand, i.e. z = z// y. 
z
= 0 
It
is possible to assign the same value to two variables in the
same statement as:
a=b=1
print(a,
b) #will display 1 1
Another
example is where we can assign different values to two
variables as:
a=1;
b=2
print(a,
b) #will display 1 2
The
same can be done using the following statement:
a,
b = 1, 2
print(a,
b) #will display 1 2
A
word of caution: Python does not have increment operator (++)
and decrement operator () that are available in C and Java.
Unary
Minus Operator
The
unary minus operator is denoted by the symbol minus ().
When this operator is used before a variable, its value is
negated. That means if the variable value is positive, it will
be converted into negative and vice versa.
For
example, consider the following statements:
n
= 10
print(n)
#displays 10
num
= 10
num
=  num
print(num)
#displays 10
Relational
Operators
Relational
operators are used to compare two quantities. We can understand
whether two values are same or which one is bigger or which one
is lesser, etc. using these operators. These operators will
result in True or False depending on the values compared, as
shown in Table. In this table, we are assuming a =1 and
b = 2.
Example

Meaning 
Result 

> 
a
> b 
Greater
than operator. If the value of left operand is greater than
the value of right operand, it gives True else it gives
False. 
False 
>= 
a
>= b 
Greater
than or equal operator. If the value of left operand is
greater or equal than that of right operand, it gives True
else False. 
False 
< 
a
< b 
Less
than operator. If the value of left operand is less than
the value of right operand, it gives True else it gives
False. 
True 
<= 
a
<= b 
Less
than or equal operator. If the value of left operand is
lesser or equal than that of right operand, it gives True
else False. 
True 
== 
a
== b 
Equals
operator. If the value of left operand is equal to the
value of right operand, it gives True else False. 
False 
!= 
a
!= b 
Not
equals operator. If the value of the left operand is not
equal to the value of right operand, it returns True else
it returns False. 
True 
Relational
operators are generally used to construct conditions in if
statements. For example,
a=1;
b=2
if (a>b):
print("Yes")
else:
print("No")
will
display 'No'. Observe the expression (a>b) written
after if. This is called a
'condition'. When this condition becomes True, if statement
will display 'Yes' and if it becomes False, then it will
display 'No'. In this case, (1>2) is False and hence
'No' will be displayed.
Relational
operators can be chained. It means, a single expression can
hold more than one relational operator. For example,
x=15
10<x<20 #displays True
Here,
10 is less than 15 is True, and then 15 is less than 20 is
True. Since both the conditions are evaluated to True, the
result will be True.
x=15
10>=x<20 #displays False
Here,
10 is greater than or equal to15 is False, and then 15 is less
than 20 is True.
10<x>20
#displays False
Solve
the following
1<2<3<4 #displays True
1<2>3<4 #displays False
4>2>=2>1 #displays True
Logical
Operators
Logical
operators are useful to construct compound conditions. A
compound condition is a combination of more than one simple
condition. Each of the simple condition is evaluated to True or
False and then the decision is taken to know whether the total
condition is True or False. We should keep in mind that in case
of logical operators, False indicates 0 and True indicates any
other number. There are 3 logical operators as shown in Table.
Let's
take x = 1 and y=2 in this table.
Operator 
Example

Meaning 
Result 
and 
x
and y 
and
operator. If x is False, it returns x, otherwise it returns
y. 
2 
or 
x
or y 
or
operator. If x is False, it returns y, otherwise it returns
x. 
1 
not 
not
x 
not
operator. If x is False, it returns True, otherwise False. 
False 
x
= 100 y = 200
print(x
and y) #will display 200
print(x
or y) #will display 100
print
(not x) #will display False
Boolean
Operators
We
know that there are two 'bool' type literals. They are True
and False. Boolean operators act upon 'bool' type
literals and they provide 'bool' type output. There are three
Boolean operators as mentioned in Table.
Let's
take x = True and y = False in Table
Operator 
Example

Meaning 
Result 
and 
x
and y 
Boolean
and operator. If both x and y are True, then it
returns True, otherwise False.

False 
or 
x
or y 
Boolean
or operator. If either x or y is True, then it
returns True, else False. 
True 
not 
not
x 
Boolean
not operator. If x is True, it returns False, else
True.

False 
Solve
the Following
a=
True b= False
a
and a #displays
True
b
and b #displaysFalse
a
and b #displaysFalse
a
or a #displays
True
a
or b #displays
True
b
or b #displays
False
not
a #displays
False
not
b #displays
True
Bitwise
Operators
These
operators act on individual bits (0 and 1) of the
operands. We can use bitwise operators directly on binary
numbers or on integers also. When we use these operators on
integers, these numbers are converted into bits (binary number
system) and then bitwise operators act upon those bits. The
results given by these operators are always in the form of
integers.
There
are 6 types of bitwise operators as shown below:
Bitwise
Complement Operator (~)
This
operator gives the complement form of a given number. This
operator symbol is ~, which is pronounced as tilde.
Complement form of a positive number can be obtained by
changing 0's as 1's and vice versa. The complement operation is
performed by NOT gate circuit in electronics. Truth
table is a table that gives relationship between the inputs and
the output. The truth table is also given for NOT gate, as
shown in Figure
Shortcut
for finding the complement of a given number is ~x = (x+1)
~
25 =  ( 25 + 1) = 26
~
31 =  ( 31 + 1) = 30
Bitwise
AND Operator (&)
This
operator performs AND operation on the individual bits of
numbers. The symbol for this operator is &, which is
called ampersand. To understand the bitwise AND
operation, see the truth table given in Figure
X = 10 =
0000 1010
Y
= 11 = 0000 1011
X
& Y = 0000 1010
(x & y = 10)
If int x=10, y=12. Find the
value of x&y
x
= 10 = 0000 1010
y
= 12 = 0000 1100 (x&y=8)
Bitwise
OR Operator ()
This
operator performs OR operation on the bits of the numbers. The
symbol of bitwise OR operator is , which is called pipe
symbol. To understand this operation, see the truth table
given in Figure. From the table, we can conclude that by adding
the input bits, we can get the output bit. The OR gate circuit,
which is present in the computer chip will perform the OR
operation.
X = 10 =
0000 1010
Y
= 11 = 0000 1011
X
 Y = 0000 1011
(xy=11)
If int x=10, y=12. Find the
value of xy
x
= 10 = 0000 1010
y
= 12 = 0000 1100 (xy=14)
Bitwise
XOR Operator (^)
This
operator performs exclusive or (XOR) operation on the bits of
numbers. The symbol is ^, which is called cap,
carat, or circumflex symbol. To understand the XOR
operation, see the truth table given in Figure.
X
= 10 = 0000 1010
Y
= 11 = 0000 1011
X
^ Y = 00000001 (x ^ y = 1)
If int x=10, y=12. Find the
value of x^y
x
= 10 = 0000 1010
y
= 12 = 0000 1100 (x^y=6)
Bitwise
Left Shift Operator (<<)
This
operator shifts the bits of the number towards left a specified
number of positions. The symbol for this operator is <<,
read as double less than. If we write x<<n,
the meaning is to shift the bits of x towards left n
positions.
If
x = 10, calculate x value if we write x<<2.
Shifting
the value of x towards left 2 positions will make the leftmost
2 bits to be lost.
The
value of x is 10 = 0000 1010. Now, x<<2 will be 0010 1000
= 40 (in decimal). The procedure to do this is explained, as
shown in Figure
Bitwise
Right Shift Operator (>>)
This
operator shifts the bits of the number towards right a
specified number of positions. The symbol for this operator is
>>, read as double greater than. If we
write x>>n, the meaning is to shift the
bits of x towards right n positions.
If
x = 10, then calculate x>>2 value.
Shifting
the value of x towards right 2 positions will make the
rightmost 2 bits to be lost. x value is 10 = 0000 1010. Now
x>>2 will be: 0000 0010 = 2 (in decimal)
Membership
Operators
The
membership operators are useful to test for membership in a
sequence such as strings, lists, tuples or dictionaries. For
example, if an element is found in the sequence or not can be
asserted using these operators. There are two membership
operators as shown here:
The
in Operator
This
operator returns True if an element is found in
the specified sequence. If the element is not found in
the sequence, then it returns False.
The
not in Operator
This
works in reverse manner for 'in' operator. This operator
returns True if an element is not found in the
sequence. If the element is found, then it returns
False.
Identity
Operators
These
operators compare the memory locations of two
objects. Hence, it is possible to know whether the two objects
are same or not. The memory location of an object can be seen
using the id() function.
This
function returns an integer number, called the identity
number that internally represents the memory location of the
object.
For
example, id(a) gives the identity number of the object referred
by the name 'a'.
There
are two identity operators:
The
is Operator
The
'is' operator is useful to compare whether two objects are same
or not. It will internally compare the identity number of the
objects. If the identity numbers of the objects are same, it
will return True; otherwise, it returns False.
The
is not Operator
This
is not operator returns True, if the identity numbers of
two objects being compared are not same. If they are same,
then it will return False.
The
'is' and 'is not' operators do not compare the values of
the objects. They compare the identity numbers or
memory locations of the objects. If we want to compare the value
of the objects, we should use equality operator (==).