Learning a new syntax or other complex stuff in any programming language is great!
But,
It would become useless if you are not able to solve real world problems.
Because,
The Ultimate goal of any programmer is to solve real world problems.
So,
In this article, You are going to learn about one of the fundamental tool through which you can solve any complicated problem within a second.
And,
The tool which I am talking about are Python Operators.
Along with that, You’ll learn about their types, their syntax and you’ll also learn how to use them with examples.
So, Let’s dive right in!
What are Operators in Python?
Python Operators are special symbols (characters) used to perform arithmetic or logical manipulations (calculations) on Operands.
Or,
In other words: Python Operators are special symbols which tells the python interpreter to carry out some mathematical or logical operations (calculations) on Operands.
Now, you might be wondering that,
What is an Operand?
An operand is a value or a variable on which the operator performs the operations.
It means:
- Operands may be constants
- Operands may be variables
But,
What are Arithmetic and Logical calculations?
Don’t Worry!
You will learn about Arithmetic and Logical calculations later on this article.
But, Before going into that,
Let’s Understand what actually Operators and Operands are with the help of an example.
Example:
# addition of two numbers (this complete line is a comment in Python, which will not be executed by the Python interpreter)
3 + 5
Or,
x = 3
y = 5
x + y
Output:
8
“ In the above example, The symbol (+) is the operator that performs addition, Values 3 and 5 and variables x and y are the operands and 8 is the output ( i.e., result) of the operation “.
Types of Operators in Python
Python language has 7 different types of operators:
- Arithmetic Operators
- Assignment Operators
- Comparison (Relational) Operators
- Logical (Boolean) Operators
- Bitwise (Binary) Operators
- Identity Operators
- Membership Operators
Arithmetic Operators:
Arithmetic Operators are used to perform mathematical operations on numeric values, such as:- Addition, Subtraction, Multiplication, Division and many more…
Operator | Description | Example |
---|---|---|
+ | Addition: Add two operands or a unary plus | 2+7 = 9 Unary Plus means: either- +(any variable) or +(any value) |
– | Subtraction: Subtract right hand operand from the left hand operand or a unary minus | 6-8 = -2 Unary Minus means: either- –(any variable) or –(any value) |
* | Multiplication: Multiply two operands | 3*2 = 6 |
/ | Float Division: Gives quotient when left hand operand is divided by the right one. The result always has type float . | 5/2 = 2.5 |
// | Floor (integer) Division: Gives quotient (but digits after the decimal points are removed) when left hand operand is divided by the right one. | 7//2 =3 |
% | Modulus: Gives the remainder of the division of left hand operand by the right one | 7%3 =1 |
** | Exponent: Left hand operand raised to power of right hand operand | 4**3 =64 |
Assignment Operators:
Assignment Operators are used to assign values to variables.
Then,
What does assigning a value to a variable mean?
It simply means that giving or storing a value to a variable.
Example:
x = 2
Here we are assigning 2 to the variable x with the help of an assignment operator (=).
So,
Assigning a value to a variable in Python is so simple, You just have to write the variable name on the left hand side of equal to operator (=) and the value on the right hand side, as shown above.
Operator | Description | Example |
---|---|---|
= | Assigns value to right hand side to an operand (i.e., variable) on left side | n = 8 m = 2 |
+= | Add right side operand with left side operand and assign the result to left operand | n+= m it is same as: n = n+m |
-= | Subtract right side operand with left side operand and assign the result to left operand | n-= m it is same as: n = n-m |
*= | Multiply right side operand with left side operand and assign the result to left operand | n*= m it is same as: n = n*m |
/= | Divide left side operand with right side operand and assign the result to left operand | n/= m it is same as: n = n/m |
//= | Performs Floor division on Operands and assign the result to left operand | n//= m it is same as: n = n//m |
%= | Takes modulus using left and right side operands and assign result to left operand | n%= m it is same as: n = n%m |
**= | Calculate exponent (i.e., Left hand operand raised to power of right hand operand) and assign result to left operand | n**= m it is same as: n = n**m |
&= | Performs Bitwise AND (we will learn about Bitwise Operators later on this article) on both side of operands and assign result to left operand | n&= m it is same as: n = n&m |
|= | Performs Bitwise OR on operands and assign result to left operand | n|= m it is same as: n = n|m |
^= | Performs Bitwise XOR on operands and assign result to left operand | n^= m it is same as: n = n^m |
>>= | Performs Bitwise Right Shift on operands and assign result to left operand | n>>= m it is same as: n = n>>m |
<<= | Performs Bitwise Left Shift on operands and assign result to left operand | n<<= m it is same as: n = n<<m |
Comparison (Relational) Operators:
Comparison Operators are used to compare values on either side of the operator and find out the relationship between them.
These are also called as relational operators.
These operators basically return True or False according to the condition.
Which means:- It return True if the condition is satisfied otherwise it return False.
Operator | Description | Example |
---|---|---|
== | Equal to: Returns True , If the values or variables on either side of the operator are equal | x = 5 y = 8 x == y False |
!= | Not Equal to: Returns True , If the values or variables on either side of the operator are not equal | x = 5 y = 8 x != y True |
> | Greater than: Returns True , If left hand side operand (value or variable) is greater than the right one | x =10 y = 8 x > y True |
< | Less than: Returns True , If left hand side operand is less than the right one | x = 3 y = 8 x < y True |
>= | Greater than or equal to: Returns True , If left hand side operand is greater than or equal to the right one | x =10 y = 8 x >= y True |
<= | Less than or equal to: Returns True , If left hand side operand is less than or equal to the right one | x =10 y = 8 x <= y False |
Logical (Boolean) Operators:
Logical Operators are used to combine True
or False
values of variables, statements or any other expressions to carry out their resultant truth value.
Operator | Description | Example |
---|---|---|
or | Logical OR: Returns True , if either of the operands is true | a = 2 b = 5 a > 1 or b < 6 True |
and | Logical AND: Returns True , if both the operands are true | a = 28 b = 10 a < 30 and b >5 True |
not | Logical NOT: Returns False , if the operand is True (i.e., complements of the operand).This operator simply reverse the result. | a = True not a False |
Bitwise (Binary) Operators:
Bitwise Operators are used to perform bitwise calculations on integers.
Yes, Only integers – Python Bitwise Operators work only on integers.
These are also called as Binary Operators.
Now,
You might be wondering that what does bitwise calculation means?
It simply means that operations (calculations) that involves working with individual bits,
Bits are the smallest units of data in a computer. Each bit has a single binary value: 0
or 1
.
Bitwise operators consider operands (integers) as sequences of binary digits (i.e., 0
and 1
),
The integers are first converted into binary
format and then operations are performed bit by bit, Then, the result is returned back in decimal
(integers) format.
Example:
Let’s consider two Variable named X and Y which consists of two integer values as: X = 12
and Y = 13
.
And,
we know that, binary of 12 = 0b1100
and binary of 13 = 0b1101
,
And, If you don’t know – How to convert a decimal number into binary then, You can visit this video.
Operator | Description | Example |
---|---|---|
& | Bitwise AND: Returns 1, if both the bits are 1 otherwise returns 0 | X & Y Output: 12 (0b1100) |
| | Bitwise OR: Returns 1, if either of the bits are 1 otherwise returns 0 | X | Y Output: 13 (0b1101) |
~ | Bitwise NOT: Reverse the bit, It means if one of the bit is 0 it will return 1 and if one of the bit is 1 it will return 0. | ~X Output: -13 ~Y Output: -14 |
^ | Bitwise XOR: Returns 1, if one of the bit is 1 and other is 0 otherwise returns 0 | X ^ Y Output: 1 |
>> | Bitwise Right Shift: Returns a with the bits shifted to the right by b places. This is the same as //’ing a by 2**b . | a = 9 b = 2 a >> b Output: 2 (0b10) |
<< | Bitwise Left Shift: Returns a with the bits shifted to the left by b places (and new bits on the right-hand-side are zeros). This is the same as multiplying a by 2**b . | a = 9 b = 2 a << b Output: 36 (0b100100) |
Let’s Understand all the above Operators one by one with examples:
Bitwise AND:
X | Y | X & Y |
---|---|---|
1 | 0 | 0 |
0 | 0 | 0 |
0 | 1 | 0 |
1 | 1 | 1 |
Bitwise OR:
X | Y | X | Y |
---|---|---|
1 | 0 | 1 |
0 | 0 | 0 |
0 | 1 | 1 |
1 | 1 | 1 |
Bitwise NOT:
X | ~X |
---|---|
1 | 0 |
0 | 1 |
Bitwise XOR:
X | Y | X ^ Y |
---|---|---|
1 | 0 | 1 |
0 | 1 | 1 |
0 | 0 | 0 |
1 | 1 | 0 |
Bitwise Right Shift:

Bitwise Left Shift:

Identity Operators:
As the name indicates, Identity is related to the term identicalness, sameness which simply means that the quality or fact of [several specified things (here it is Operands )] being the same,
As well as, Identity is also related to id ( i.e., address) of the memory locations where the data (values) are stored in the memory.
So,
Basically,
Identity Operators are used to check whether two Operands (i.e., values or variables) are equal and also if they stored at the same memory location ( i.e., both have same memory address) or not.
Operator | Description | Example |
---|---|---|
is | Returns True, if both the Operands are equal (identical) and both have the same memory location | a = 2 b = 2 a is b Output: True |
is not | Returns True, if either the Operands or the memory location is not same | x = (5,6,7) y = (5,6,7) x is not y Output: True |
In the above example, We can see that the 1st (i.e., is operator) example gives the output as: True,
Because, the value of a and b are equal as well as they both have the same memory location (i.e., both the values are stored at the same memory address).
Let’s Check, It is true or not:
a = 2
b = 2
a is b
True
id(a) # id is used for printing the memory address of the variable (here it is a)
1443428288
id(b)
1443428288
And,
In the 2nd (i.e., is not) example, The Output is again: True,
Because,
However, both the variables have the same values but they do not have stored at the same memory locations, which means they both have the different id (i.e., address) in the memory location.
Let’s Check:
x = (5,6,7)
y = (5,6,7)
x is not y
True
id(x)
62687368
id(y)
62686504 # id is not same as that of the id of x
Membership Operators:
Membership Operators are used to check whether a value or a variable is a member of a particular sequence or not.
The sequence might be a string
(i.e., sequence of characters), a list
, a tuple
, a set
or a dictionary
that you will learn about in later tutorials.
There are two membership Operators in Python:
in
not in
Let’s understand the above concept with the help of a real world example:
Suppose, a person named “John” belongs to a family named X and another person named “Harry” does not belongs to the family X.
You can think of families as a list of family members.
Here, We can write the list of John’s family members as: [ John, John’s Father, John’s Mother, John’s Brother, John’s Sister, … ]
And,
If we want to check who is not belonging to the family X then we can use either in
or not in
Operator.
I know you are thinking that we already know about who belongs to the family X and who’s not.
Then, What is the need for checking?
It’s just for the sake of better understanding about the membership operators that it is working or not.
So,
If the in
Operator returns True
then we will conclude that the person belongs to the family X otherwise not belonging to the family X.
Example:
"Harry" in X
False # it means Harry is not belonging to the family X.
Or,
If the not
in
Operator returns True
then we will conclude that the person does not belongs to the family X otherwise belonging to the family X.
Example:
"Harry not in X
True # it means Harry is not belonging to the family X.
Operator | Description | Example |
---|---|---|
in | Returns True if a value or a variable is found in the sequence | name = “JavaScript“ “Java“ in nameTrue |
not in | Returns True if a value or a variable is not found in the sequence | lst = [ 2, 3.14, 9 ] 3.1479 not in lst True |
So, That’s it from my side
Now, I’d like to hear from you:
Did I Miss Anything?
Or,
Is this post helpful for you?
Let me know by leaving a quick comment below.