An expression may have multiple operators to be evaluated. The operator precedence defines the order in which operators are evaluated. In other words, the order of operator evaluation is determined by the operator precedence.
If a certain expression contains multiple operators, their order of evaluation is determined by the order of precedence. For example, consider the following expression
>>> a =2+3*5
Here, what will be the value of a? – yes it will be 17 (multiply 3 by 5 first and then add 2) or 25 (adding 2 and 3 and then multiply with 5)? Pythons operator precedence rule comes into picture here.
If we consider only the arithmetic operators in Python, the traditional BODMAS rule is also employed by Python interpreter, where the brackets are evaluated first, the division and multiplication operators next, followed by addition and subtraction operators. Hence, a will become 17 in the above expression.
In addition to the operator precedence, the associativity of operators is also important. If an expression consists of operators with same level of precedence, the associativity determines the order. Most of the operators have left to right associativity. It means, the operator on the left is evaluated before the one on the right.
Let us consider another expression:
>>> b =10/5*4
In this case, both * (multiplication) and / (division) operators have same level of precedence. However, the left to right associativity rule performs the division first (10/5 = 2) and then the multiplication (2*4 = 8).
Python Operator Precedence Table
The following table lists all the operators in Python in their decreasing order of precedence. Operators in the same cell under the Operators column have the same precedence.
in, not in, is, is not, <, <=, >, >=, !=, ==Comparisons, including membership tests and identity tests
13
not xBoolean NOT
14
andBoolean AND
15
orBoolean OR
16
if elseConditional expression
17
lambdaLambda expression
18
:=Walrus operator
Python Operator Precedence Example
a =20
b =10
c =15
d =5
e =0
e =(a + b)* c / d #( 30 * 15 ) / 5print("Value of (a + b) * c / d is ", e)
e =((a + b)* c)/ d # (30 * 15 ) / 5print("Value of ((a + b) * c) / d is ", e)
e =(a + b)*(c / d);# (30) * (15/5)print("Value of (a + b) * (c / d) is ", e)
e = a +(b * c)/ d;# 20 + (150/5)print("Value of a + (b * c) / d is ", e)
When you execute the above program, it produces the following result −
Value of (a + b) * c / d is 90.0
Value of ((a + b) * c) / d is 90.0
Value of (a + b) * (c / d) is 90.0
Value of a + (b * c) / d is 50.0
The walrus operator (:=) is a new type of assignment operator that was introduced in Python 3.8. This chapter will give a clear understanding of the walrus operator and how to use it to reduce number of lines in your Python code.
What is Walrus Operator?
The walrus operator (:=) is used to assign a value to a variable from an expression inside loop conditions. This is useful when you need to use a value multiple times in a loop, but don’t want to repeat the calculation. Hence it is also known as the assignment expression operator. The name “walrus operator” comes because the operator (:=) looks likes the eyes and tusks of a walrus.
The syntax of the walrus operator is as follows −
variable := expression
# Example
n :=len(arr)+10
variable − This is the name of the variable to which the value will be assigned.
expression − The mathematical expression, function call, or any valid Python expression that returns a value.
Example of Walrus Operator
Now, let’s look at an example to understand how the walrus operator can be used to simplify code. Consider the following code that uses a while loop to pop elements from a stack until it is empty. At each iteration of the loop, we calculate the length of the stack using len(stack) and assign it to the variable n.
The walrus operator allows us to combine these two operations into a single line, see the code below −
# Traditional wayprint("Using traditional way:")
stack =[1,2,3,4,5]
n =len(stack)whilelen(stack)>0:print(stack.pop(), end=" ")print("\n\n")# Simplify using walrus operatorprint("Using walrus operator:")
stack =[1,2,3,4,5]while(n :=len(stack))>0:print(stack.pop(), end=" ")
The output of both the above code will be −
Using traditional way:
5 4 3 2 1
Using walrus operator:
5 4 3 2 1
Walrus Operator for List Comprehensions
The list comprehensions is a simple way to create lists in Python using a single line of code. The walrus operator can be used in list comprehensions to assign a value to a variable as part of the expression.
In the example below, we show how list comprehensions and the walrus operator simplify the code that generates a list of squares of numbers greater than 20 from a range of 10 numbers.
# Traditional wayprint("Using traditional way:")
results =[]for x inrange(10):
y = x * x
if y >20:
results.append(y)print(results,"\n")# Simplify using walrus operatorprint("Using walrus operator:")
results =[y for x inrange(10)if(y := x * x)>20]print(results)
The output of both the above code will be −
Using traditional way:
[25, 36, 49, 64, 81]
Using walrus operator:
[25, 36, 49, 64, 81]
When to Avoid Using Walrus Operator?
We already saw that the walrus operator can be used to reduce the number of lines in your code and make it more readable. However, there are some scenarios where using the walrus operator may not be appropriate.
Avoid using the walrus operator in following scenarios −
The assignment expression is too complex and makes the code harder to read.
Direct assignment to a variable is restricted. For example, x := 10 will result in a syntax error.
The walrus operator is not allowed in lambda functions. For example, lambda x := 5: x * 2 will result in a syntax error.
Conclusion
If you are using Python 3.8 or later, you can use the walrus operator to reduce the number of lines in your code and make it more readable. However, it is important to use the walrus operator carefully, because it can make code harder to read if overused or used inappropriately. It is recommended to use the walrus operator only when it improves the clarity of the code.
The identity operators compare the objects to determine whether they share the same memory and refer to the same object type (data type).
Python provided two identity operators; we have listed them as follows:
‘is‘ Operator
‘is not‘ Operator
Python ‘is’ Operator
The ‘is‘ operator evaluates to True if both the operand objects share the same memory location. The memory location of the object can be obtained by the “id()” function. If the “id()” of both variables is same, the “is” operator returns True.
Example of Python Identity ‘is’ Operator
a =[1,2,3,4,5]
b =[1,2,3,4,5]
c = a
# Comparing and printing return valuesprint(a is c)print(a is b)# Printing IDs of a, b, and cprint("id(a) : ",id(a))print("id(b) : ",id(b))print("id(c) : ",id(c))
The ‘is not‘ operator evaluates to True if both the operand objects do not share the same memory location or both operands are not the same objects.
Example of Python Identity ‘is not’ Operator
a =[1,2,3,4,5]
b =[1,2,3,4,5]
c = a
# Comparing and printing return valuesprint(a isnot c)print(a isnot b)# Printing IDs of a, b, and cprint("id(a) : ",id(a))print("id(b) : ",id(b))print("id(c) : ",id(c))
Python Identity Operators Examples with Explanations
Example 1
a="TutorialsPoint"
b=a
print("id(a), id(b):",id(a),id(b))print("a is b:", a is b)print("b is not a:", b isnot a)
It will produce the following output −
id(a), id(b): 2739311598832 2739311598832
a is b: True
b is not a: False
The list and tuple objects behave differently, which might look strange in the first instance. In the following example, two lists “a” and “b” contain same items. But their id() differs.
Example 2
a=[1,2,3]
b=[1,2,3]print("id(a), id(b):",id(a),id(b))print("a is b:", a is b)print("b is not a:", b isnot a)
It will produce the following output −
id(a), id(b): 1552612704640 1552567805568
a is b: False
b is not a: True
The list or tuple contains the memory locations of individual items only and not the items itself. Hence “a” contains the addresses of 10,20 and 30 integer objects in a certain location which may be different from that of “b”.
The membership operators in Python help us determine whether an item is present in a given container type object, or in other words, whether an item is a member of the given container type object.
Types of Python Membership Operators
Python has two membership operators: in and not in. Both return a Boolean result. The result of in operator is opposite to that of not in operator.
The ‘in’ Operator
The “in” operator is used to check whether a substring is present in a bigger string, any item is present in a list or tuple, or a sub-list or sub-tuple is included in a list or tuple.
Example of Python Membership “in” Operator
In the following example, different substrings are checked whether they belong to the string var=”TutorialsPoint”. Python differentiates characters on the basis of their Unicode value. Hence “To” is not the same as “to”. Also note that if the “in” operator returns True, the “not in” operator evaluates to False.
var ="TutorialsPoint"
a ="P"
b ="tor"
c ="in"
d ="To"print(a,"in", var,":", a in var)print(b,"in", var,":", b in var)print(c,"in", var,":", c in var)print(d,"in", var,":", d in var)
It will produce the following output −
P in TutorialsPoint : True
tor in TutorialsPoint : True
in in TutorialsPoint : True
To in TutorialsPoint : False
The ‘not in’ Operator
The “not in” operator is used to check a sequence with the given value is not present in the object like string, list, tuple, etc.
Example of Python Membership “not in” Operator
var ="TutorialsPoint"
a ="P"
b ="tor"
c ="in"
d ="To"print(a,"not in", var,":", a notin var)print(b,"not in", var,":", b notin var)print(c,"not in", var,":", c notin var)print(d,"not in", var,":", d notin var)
It will produce the following output −
P not in TutorialsPoint : False
tor not in TutorialsPoint : False
in not in TutorialsPoint : False
To not in TutorialsPoint : True
Membership Operator with Lists and Tuples
You can use the “in/not in” operator to check the membership of an item in the list or tuple.
var =[10,20,30,40]
a =20
b =10
c = a-b
d = a/2print(a,"in", var,":", a in var)print(b,"not in", var,":", b notin var)print(c,"in", var,":", c in var)print(d,"not in", var,":", d notin var)
It will produce the following output −
20 in [10, 20, 30, 40] : True
10 not in [10, 20, 30, 40] : False
10 in [10, 20, 30, 40] : True
10.0 not in [10, 20, 30, 40] : False
In the last case, “d” is a float but still it compares to True with 10 (an int) in the list. Even if a number expressed in other formats like binary, octal or hexadecimal are given the membership operators tell if it is inside the sequence.
>>>0x14in[10,20,30,40]True
Example
However, if you try to check if two successive numbers are present in a list or tuple, the in operator returns False. If the list/tuple contains the successive numbers as a sequence itself, then it returns True.
var =(10,20,30,40)
a =10
b =20print((a,b),"in", var,":",(a,b)in var)
var =((10,20),30,40)
a =10
b =20print((a,b),"in", var,":",(a,b)in var)
It will produce the following output −
(10, 20) in (10, 20, 30, 40) : False
(10, 20) in ((10, 20), 30, 40) : True
Membership Operator with Sets
Python’s membership operators also work well with the set objects.
var ={10,20,30,40}
a =10
b =20print(b,"in", var,":", b in var)
var ={(10,20),30,40}
a =10
b =20print((a,b),"in", var,":",(a,b)in var)
It will produce the following output −
20 in {40, 10, 20, 30} : True
(10, 20) in {40, 30, (10, 20)} : True
Membership Operator with Dictionaries
Use of in as well as not in operators with dictionary object is allowed. However, Python checks the membership only with the collection of keys and not values.
var ={1:10,2:20,3:30}
a =2
b =20print(a,"in", var,":", a in var)print(b,"in", var,":", b in var)
It will produce the following output −
2 in {1: 10, 2: 20, 3: 30} : True
20 in {1: 10, 2: 20, 3: 30} : False
Python bitwise operators are normally used to perform bitwise operations on integer-type objects. However, instead of treating the object as a whole, it is treated as a string of bits. Different operations are done on each bit in the string.
Python has six bitwise operators – &, |, ^, ~, << and >>. All these operators (except ~) are binary in nature, in the sense they operate on two operands. Each operand is a binary digit (bit) 1 or 0.
The following are the bitwise operators in Python –
Bitwise AND Operator
Bitwise OR Operator
Bitwise XOR Operator
Bitwise NOT Operator
Bitwise Left Shift Operator
Biwtise Right Shift Operator
Python Bitwise AND Operator (&)
Bitwise AND operator is somewhat similar to logical and operator. It returns True only if both the bit operands are 1 (i.e. True). All the combinations are −
0 & 0 is 0
1 & 0 is 0
0 & 1 is 0
1 & 1 is 1
When you use integers as the operands, both are converted in equivalent binary, the & operation is done on corresponding bit from each number, starting from the least significant bit and going towards most significant bit.
Example of Bitwise AND Operator in Python
Let us take two integers 60 and 13, and assign them to variables a and b respectively.
a=60
b=13print("a:",a,"b:",b,"a&b:",a&b)
It will produce the following output −
a: 60 b: 13 a&b: 12
To understand how Python performs the operation, obtain the binary equivalent of each variable.
print("a:",bin(a))print("b:",bin(b))
It will produce the following output −
a: 0b111100
b: 0b1101
For the sake of convenience, use the standard 8-bit format for each number, so that “a” is 00111100 and “b” is 00001101. Let us manually perform and operation on each corresponding bits of these two numbers.
0011 1100
&
0000 1101
-------------
0000 1100
Convert the resultant binary back to integer. You’ll get 12, which was the result obtained earlier.
>>>int('00001100',2)12
Python Bitwise OR Operator (|)
The “|” symbol (called pipe) is the bitwise OR operator. If any bit operand is 1, the result is 1 otherwise it is 0.
0 | 0 is 0
0 | 1 is 1
1 | 0 is 1
1 | 1 is 1
Example of Bitwise OR Operator in Python
Take the same values of a=60, b=13. The “|” operation results in 61. Obtain their binary equivalents.
To perform the “|” operation manually, use the 8-bit format.
0011 1100
|
0000 1101
-------------
0011 1101
Convert the binary number back to integer to tally the result −
>>>int('00111101',2)61
Python Bitwise XOR Operator (^)
The term XOR stands for exclusive OR. It means that the result of OR operation on two bits will be 1 if only one of the bits is 1.
0^0is00^1is11^0is11^1is0
Example of Bitwise XOR Operator in Python
Let us perform XOR operation on a=60 and b=13.
a=60
b=13print("a:",a,"b:",b,"a^b:",a^b)
It will produce the following output −
a: 60 b: 13 a^b: 49
We now perform the bitwise XOR manually.
0011 1100
^
0000 1101
-------------
0011 0001
The int() function shows 00110001 to be 49.
>>>int('00110001',2)49
Python Bitwise NOT Operator (~)
This operator is the binary equivalent of logical NOT operator. It flips each bit so that 1 is replaced by 0, and 0 by 1, and returns the complement of the original number. Python uses 2’s complement method. For positive integers, it is obtained simply by reversing the bits. For negative number, -x, it is written using the bit pattern for (x-1) with all of the bits complemented (switched from 1 to 0 or 0 to 1). Hence: (for 8 bit representation)
Left shift operator shifts most significant bits to right by the number on the right side of the “<<” symbol. Hence, “x << 2” causes two bits of the binary representation of to right.
Example of Bitwise Left Shift Operator in Python
Let us perform left shift on 60.
a=60print("a:",a,"a<<2:", a<<2)
It will produce the following output −
a: 60 a<<2: 240
How does this take place? Let us use the binary equivalent of 60, and perform the left shift by 2.
00111100<<2-------------11110000
Convert the binary to integer. It is 240.
>>>int('11110000',2)240
Python Bitwise Right Shift Operator (>>)
Right shift operator shifts least significant bits to left by the number on the right side of the “>>” symbol. Hence, “x >> 2” causes two bits of the binary representation of to left.
Example of Bitwise Right Shift Operator in Python
Let us perform right shift on 60.
a=60print("a:",a,"a>>2:", a>>2)
It will produce the following output −
a: 60 a>>2: 15
Manual right shift operation on 60 is shown below −
00111100>>2-------------00001111
Use int() function to covert the above binary number to integer. It is 15.
Python logical operators are used to form compound Boolean expressions. Each operand for these logical operators is itself a Boolean expression. For example,
Example
age >16and marks >80
percentage <50or attendance <75
Along with the keyword False, Python interprets None, numeric zero of all types, and empty sequences (strings, tuples, lists), empty dictionaries, and empty sets as False. All other values are treated as True.
There are three logical operators in Python. They are “and“, “or” and “not“. They must be in lowercase.
Logical “and” Operator
For the compound Boolean expression to be True, both the operands must be True. If any or both operands evaluate to False, the expression returns False.
Logical “and” Operator Truth Table
The following table shows the scenarios.
a
b
a and b
F
F
F
F
T
F
T
F
F
T
T
T
Logical “or” Operator
In contrast, the or operator returns True if any of the operands is True. For the compound Boolean expression to be False, both the operands have to be False.
Logical “or” Operator Truth Table
The following tables shows the result of the “or” operator with different conditions:
a
b
a or b
F
F
F
F
T
T
T
F
T
T
T
T
Logical “not” Operator
This is a unary operator. The state of Boolean operand that follows, is reversed. As a result, not True becomes False and not False becomes True.
Logical “not” Operator Truth Table
a
not (a)
F
T
T
F
How the Python interpreter evaluates the logical operators?
The expression “x and y” first evaluates “x”. If “x” is false, its value is returned; otherwise, “y” is evaluated and the resulting value is returned.
The expression “x or y” first evaluates “x”; if “x” is true, its value is returned; otherwise, “y” is evaluated and the resulting value is returned.
Python Logical Operators Examples
Some use cases of logical operators are given below −
Example 1: Logical Operators With Boolean Conditions
x =10
y =20print("x > 0 and x < 10:",x >0and x <10)print("x > 0 and y > 10:",x >0and y >10)print("x > 10 or y > 10:",x >10or y >10)print("x%2 == 0 and y%2 == 0:",x%2==0and y%2==0)print("not (x+y>15):",not(x+y)>15)
It will produce the following output −
x > 0 and x < 10: False
x > 0 and y > 10: True
x > 10 or y > 10: True
x%2 == 0 and y%2 == 0: True
not (x+y>15): False
Example 2: Logical Operators With Non- Boolean Conditions
We can use non-boolean operands with logical operators. Here, we need to not that any non-zero numbers, and non-empty sequences evaluate to True. Hence, the same truth tables of logical operators apply.
In the following example, numeric operands are used for logical operators. The variables “x”, “y” evaluate to True, “z” is False
x =10
y =20
z =0print("x and y:",x and y)print("x or y:",x or y)print("z or x:",z or x)print("y or z:", y or z)
It will produce the following output −
x and y: 20
x or y: 10
z or x: 10
y or z: 20
Example 3: Logical Operators With Strings and Tuples
The string variable is treated as True and an empty tuple as False in the following example −
a="Hello"
b=tuple()print("a and b:",a and b)print("b or a:",b or a)
It will produce the following output −
a and b: ()
b or a: Hello
Example 4: Logical Operators To Compare Sequences (Lists)
Finally, two list objects below are non-empty. Hence x and y returns the latter, and x or y returns the former.
x=[1,2,3]
y=[10,20,30]print("x and y:",x and y)print("x or y:",x or y)
The = (equal to) symbol is defined as assignment operator in Python. The value of Python expression on its right is assigned to a single variable on its left. The = symbol as in programming in general (and Python in particular) should not be confused with its usage in Mathematics, where it states that the expressions on the either side of the symbol are equal.
Example of Assignment Operator in Python
Consider following Python statements −
a =10
b =5
a = a + b
print(a)
At the first instance, at least for somebody new to programming but who knows maths, the statement “a=a+b” looks strange. How could a be equal to “a+b”? However, it needs to be reemphasized that the = symbol is an assignment operator here and not used to show the equality of LHS and RHS.
Because it is an assignment, the expression on right evaluates to 15, the value is assigned to a.
In the statement “a+=b”, the two operators “+” and “=” can be combined in a “+=” operator. It is called as add and assign operator. In a single statement, it performs addition of two operands “a” and “b”, and result is assigned to operand on left, i.e., “a”.
Augmented Assignment Operators in Python
In addition to the simple assignment operator, Python provides few more assignment operators for advanced use. They are called cumulative or augmented assignment operators. In this chapter, we shall learn to use augmented assignment operators defined in Python.
Python has the augmented assignment operators for all arithmetic and comparison operators.
Python augmented assignment operators combines addition and assignment in one statement. Since Python supports mixed arithmetic, the two operands may be of different types. However, the type of left operand changes to the operand of on right, if it is wider.
Example
The += operator is an augmented operator. It is also called cumulative addition operator, as it adds “b” in “a” and assigns the result back to a variable.
The following are the augmented assignment operators in Python:
Augmented Addition Operator
Augmented Subtraction Operator
Augmented Multiplication Operator
Augmented Division Operator
Augmented Modulus Operator
Augmented Exponent Operator
Augmented Floor division Operator
Augmented Addition Operator (+=)
Following examples will help in understanding how the “+=” operator works −
a=10
b=5print("Augmented addition of int and int")
a+=b # equivalent to a=a+bprint("a=",a,"type(a):",type(a))
a=10
b=5.5print("Augmented addition of int and float")
a+=b # equivalent to a=a+bprint("a=",a,"type(a):",type(a))
a=10.50
b=5+6jprint("Augmented addition of float and complex")
a+=b #equivalent to a=a+bprint("a=",a,"type(a):",type(a))
It will produce the following output −
Augmented addition of int and int
a= 15 type(a): <class 'int'>
Augmented addition of int and float
a= 15.5 type(a): <class 'float'>
Augmented addition of float and complex
a= (15.5+6j) type(a): <class 'complex'>
Augmented Subtraction Operator (-=)
Use -= symbol to perform subtract and assign operations in a single statement. The “a-=b” statement performs “a=a-b” assignment. Operands may be of any number type. Python performs implicit type casting on the object which is narrower in size.
a=10
b=5print("Augmented subtraction of int and int")
a-=b #equivalent to a=a-bprint("a=",a,"type(a):",type(a))
a=10
b=5.5print("Augmented subtraction of int and float")
a-=b #equivalent to a=a-bprint("a=",a,"type(a):",type(a))
a=10.50
b=5+6jprint("Augmented subtraction of float and complex")
a-=b #equivalent to a=a-bprint("a=",a,"type(a):",type(a))
It will produce the following output −
Augmented subtraction of int and int
a= 5 type(a): <class 'int'>
Augmented subtraction of int and float
a= 4.5 type(a): <class 'float'>
Augmented subtraction of float and complex
a= (5.5-6j) type(a): <class 'complex'>
Augmented Multiplication Operator (*=)
The “*=” operator works on similar principle. “a*=b” performs multiply and assign operations, and is equivalent to “a=a*b”. In case of augmented multiplication of two complex numbers, the rule of multiplication as discussed in the previous chapter is applicable.
a=10
b=5print("Augmented multiplication of int and int")
a*=b #equivalent to a=a*bprint("a=",a,"type(a):",type(a))
a=10
b=5.5print("Augmented multiplication of int and float")
a*=b #equivalent to a=a*bprint("a=",a,"type(a):",type(a))
a=6+4j
b=3+2jprint("Augmented multiplication of complex and complex")
a*=b #equivalent to a=a*bprint("a=",a,"type(a):",type(a))
It will produce the following output −
Augmented multiplication of int and int
a= 50 type(a): <class 'int'>
Augmented multiplication of int and float
a= 55.0 type(a): <class 'float'>
Augmented multiplication of complex and complex
a= (10+24j) type(a): <class 'complex'>
Augmented Division Operator (/=)
The combination symbol “/=” acts as divide and assignment operator, hence “a/=b” is equivalent to “a=a/b”. The division operation of int or float operands is float. Division of two complex numbers returns a complex number. Given below are examples of augmented division operator.
a=10
b=5print("Augmented division of int and int")
a/=b #equivalent to a=a/bprint("a=",a,"type(a):",type(a))
a=10
b=5.5print("Augmented division of int and float")
a/=b #equivalent to a=a/bprint("a=",a,"type(a):",type(a))
a=6+4j
b=3+2jprint("Augmented division of complex and complex")
a/=b #equivalent to a=a/bprint("a=",a,"type(a):",type(a))
It will produce the following output −
Augmented division of int and int
a= 2.0 type(a): <class 'float'>
Augmented division of int and float
a= 1.8181818181818181 type(a): <class 'float'>
Augmented division of complex and complex
a= (2+0j) type(a): <class 'complex'>
Augmented Modulus Operator (%=)
To perform modulus and assignment operation in a single statement, use the %= operator. Like the mod operator, its augmented version also is not supported for complex number.
a=10
b=5print("Augmented modulus operator with int and int")
a%=b #equivalent to a=a%bprint("a=",a,"type(a):",type(a))
a=10
b=5.5print("Augmented modulus operator with int and float")
a%=b #equivalent to a=a%bprint("a=",a,"type(a):",type(a))
It will produce the following output −
Augmented modulus operator with int and int
a= 0 type(a): <class 'int'>
Augmented modulus operator with int and float
a= 4.5 type(a): <class 'float'>
Augmented Exponent Operator (**=)
The “**=” operator results in computation of “a” raised to “b”, and assigning the value back to “a”. Given below are some examples −
a=10
b=5print("Augmented exponent operator with int and int")
a**=b #equivalent to a=a**bprint("a=",a,"type(a):",type(a))
a=10
b=5.5print("Augmented exponent operator with int and float")
a**=b #equivalent to a=a**bprint("a=",a,"type(a):",type(a))
a=6+4j
b=3+2jprint("Augmented exponent operator with complex and complex")
a**=b #equivalent to a=a**bprint("a=",a,"type(a):",type(a))
It will produce the following output −
Augmented exponent operator with int and int
a= 100000 type(a): <class 'int'>
Augmented exponent operator with int and float
a= 316227.7660168379 type(a): <class 'float'>
Augmented exponent operator with complex and complex
a= (97.52306038414744-62.22529992036203j) type(a): <class 'complex'>
Augmented Floor division Operator (//=)
For performing floor division and assignment in a single statement, use the “//=” operator. “a//=b” is equivalent to “a=a//b”. This operator cannot be used with complex numbers.
a=10
b=5print("Augmented floor division operator with int and int")
a//=b #equivalent to a=a//bprint("a=",a,"type(a):",type(a))
a=10
b=5.5print("Augmented floor division operator with int and float")
a//=b #equivalent to a=a//bprint("a=",a,"type(a):",type(a))
It will produce the following output −
Augmented floor division operator with int and int
a= 2 type(a): <class 'int'>
Augmented floor division operator with int and float
a= 1.0 type(a): <class 'float'>
Python uses two more operators, combining “=” symbol with these two. The “<=” symbol is for less than or equal to operator and the “>=” symbol is for greater than or equal to operator.
Different Comparison Operators in Python
Python has two more comparison operators in the form of “==” and “!=”. They are for is equal to and is not equal to operators. Hence, there are six comparison operators in Python and they are listed below in this table:
<
Less than
a<b
>
Greater than
a>b
<=
Less than or equal to
a<=b
>=
Greater than or equal to
a>=b
==
Is equal to
a==b
!=
Is not equal to
a!=b
Comparison operators are binary in nature, requiring two operands. An expression involving a comparison operator is called a Boolean expression, and always returns either True or False.
Example
a=5
b=7print(a>b)print(a<b)
It will produce the following output −
False
True
Both the operands may be Python literals, variables or expressions. Since Python supports mixed arithmetic, you can have any number type operands.
Example
The following code demonstrates the use of Python’s comparison operators with integer numbers −
Both operands are integer
a= 5 b= 7 a>b is False
a= 5 b= 7 a<b is True
a= 5 b= 7 a==b is False
a= 5 b= 7 a!=b is True
Comparison of Float Number
In the following example, an integer and a float operand are compared.
Example
print("comparison of int and float")
a=10
b=10.0print("a=",a,"b=",b,"a>b is", a>b)print("a=",a,"b=",b,"a<b is",a<b)print("a=",a,"b=",b,"a==b is",a==b)print("a=",a,"b=",b,"a!=b is",a!=b)
It will produce the following output −
comparison of int and float
a= 10 b= 10.0 a>b is False
a= 10 b= 10.0 a<b is False
a= 10 b= 10.0 a==b is True
a= 10 b= 10.0 a!=b is False
Comparison of Complex umbers
Although complex object is a number data type in Python, its behavior is different from others. Python doesn’t support < and > operators, however it does support equality (==) and inequality (!=) operators.
Example
print("comparison of complex numbers")
a=10+1j
b=10.-1jprint("a=",a,"b=",b,"a==b is",a==b)print("a=",a,"b=",b,"a!=b is",a!=b)
It will produce the following output −
comparison of complex numbers
a= (10+1j) b= (10-1j) a==b is False
a= (10+1j) b= (10-1j) a!=b is True
You get a TypeError with less than or greater than operators.
Example
print("comparison of complex numbers")
a=10+1j
b=10.-1jprint("a=",a,"b=",b,"a<b is",a<b)print("a=",a,"b=",b,"a>b is",a>b)
It will produce the following output −
comparison of complex numbers
Traceback (most recent call last):
File "C:\Users\mlath\examples\example.py", line 5, in <module>
print ("a=",a, "b=",b,"a<b is",a<b)
^^^
TypeError: '<' not supported between instances of 'complex' and
'complex
Comparison of Booleans
Boolean objects in Python are really integers: True is 1 and False is 0. In fact, Python treats any non-zero number as True. In Python, comparison of Boolean objects is possible. “False < True” is True!
Example
print("comparison of Booleans")
a=True
b=Falseprint("a=",a,"b=",b,"a<b is",a<b)print("a=",a,"b=",b,"a>b is",a>b)print("a=",a,"b=",b,"a==b is",a==b)print("a=",a,"b=",b,"a!=b is",a!=b)
It will produce the following output −
comparison of Booleans
a= True b= False a<b is False
a= True b= False a>b is True
a= True b= False a==b is False
a= True b= False a!=b is True
Comparison of Sequence Types
In Python, comparison of only similar sequence objects can be performed. A string object is comparable with another string only. A list cannot be compared with a tuple, even if both have same items.
Example
print("comparison of different sequence types")
a=(1,2,3)
b=[1,2,3]print("a=",a,"b=",b,"a<b is",a<b)
It will produce the following output −
comparison of different sequence types
Traceback (most recent call last):
File "C:\Users\mlath\examples\example.py", line 5, in <module>
print ("a=",a, "b=",b,"a<b is",a<b)
^^^
TypeError: '<' not supported between instances of 'tuple' and 'list'
Sequence objects are compared by lexicographical ordering mechanism. The comparison starts from item at 0th index. If they are equal, comparison moves to next index till the items at certain index happen to be not equal, or one of the sequences is exhausted. If one sequence is an initial sub-sequence of the other, the shorter sequence is the smaller (lesser) one.
Which of the operands is greater depends on the difference in values of items at the index where they are unequal. For example, ‘BAT’>’BAR’ is True, as T comes after R in Unicode order.
If all items of two sequences compare equal, the sequences are considered equal.
Example
print("comparison of strings")
a='BAT'
b='BALL'print("a=",a,"b=",b,"a<b is",a<b)print("a=",a,"b=",b,"a>b is",a>b)print("a=",a,"b=",b,"a==b is",a==b)print("a=",a,"b=",b,"a!=b is",a!=b)
It will produce the following output −
comparison of strings
a= BAT b= BALL a<b is False
a= BAT b= BALL a>b is True
a= BAT b= BALL a==b is False
a= BAT b= BALL a!=b is True
In the following example, two tuple objects are compared −
Example
print("comparison of tuples")
a=(1,2,4)
b=(1,2,3)print("a=",a,"b=",b,"a<b is",a<b)print("a=",a,"b=",b,"a>b is",a>b)print("a=",a,"b=",b,"a==b is",a==b)print("a=",a,"b=",b,"a!=b is",a!=b)
The use of “<” and “>” operators for Python’s dictionary is not defined. In case of these operands, TypeError: ‘<‘ not supported between instances of ‘dict’ and ‘dict’ is reported.
Equality comparison checks if the length of both the dict items is same. Length of dictionary is the number of key-value pairs in it.
Python dictionaries are simply compared by length. The dictionary with fewer elements is considered less than a dictionary with more elements.
Example
print("comparison of dictionary objects")
a={1:1,2:2}
b={2:2,1:1,3:3}print("a=",a,"b=",b,"a==b is",a==b)print("a=",a,"b=",b,"a!=b is",a!=b)
Python arithmetic operators are used to perform mathematical operations such as addition, subtraction, multiplication, division, and more on numbers. Arithmetic operators are binary operators in the sense they operate on two operands. Python fully supports mixed arithmetic. That is, the two operands can be of two different number types. In such a situation.
Types of Arithmetic Operators
Following is the table which lists down all the arithmetic operators available in Python:
Operator
Name
Example
+
Addition
a + b = 30
–
Subtraction
a b = -10
*
Multiplication
a * b = 200
/
Division
b / a = 2
%
Modulus
b % a = 0
**
Exponent
a**b =10**20
//
Floor Division
9//2 = 4
Let us study these operators with examples.
Addition Operator
The addition operator represents by + symbol. It is a basic arithmetic operator. It adds the two numeric operands on the either side and returns the addition result.
Example to add two integer numbers
In the following example, the two integer variables are the operands for the “+” operator.
a=10
b=20print("Addition of two integers")print("a =",a,"b =",b,"addition =",a+b)
It will produce the following output −
Addition of two integers
a = 10 b = 20 addition = 30
Example to add integer and float numbers
Addition of integer and float results in a float.
a=10
b=20.5print("Addition of integer and float")print("a =",a,"b =",b,"addition =",a+b)
It will produce the following output −
Addition of integer and float
a = 10 b = 20.5 addition = 30.5
Example to add two complex numbers
The result of adding float to complex is a complex number.
a=10+5j
b=20.5print("Addition of complex and float")print("a=",a,"b=",b,"addition=",a+b)
It will produce the following output −
Addition of complex and float
a= (10+5j) b= 20.5 addition= (30.5+5j)
Subtraction Operator
The subtraction operator represents by – symbol. It subtracts the second operand from the first. The resultant number is negative if the second operand is larger.
Example to subtract two integer numbers
First example shows subtraction of two integers.
a=10
b=20print("Subtraction of two integers:")print("a =",a,"b =",b,"a-b =",a-b)print("a =",a,"b =",b,"b-a =",b-a)
Result −
Subtraction of two integers
a = 10 b = 20 a-b = -10
a = 10 b = 20 b-a = 10
Example to subtract integer and float numbers
Subtraction of an integer and a float follows the same principle.
a=10
b=20.5print("subtraction of integer and float")print("a=",a,"b=",b,"a-b=",a-b)print("a=",a,"b=",b,"b-a=",b-a)
It will produce the following output −
subtraction of integer and float
a= 10 b= 20.5 a-b= -10.5
a= 10 b= 20.5 b-a= 10.5
Example to subtract complex numbers
In the subtraction involving a complex and a float, real component is involved in the operation.
a=10+5j
b=20.5print("subtraction of complex and float")print("a=",a,"b=",b,"a-b=",a-b)print("a=",a,"b=",b,"b-a=",b-a)
It will produce the following output −
subtraction of complex and float
a= (10+5j) b= 20.5 a-b= (-10.5+5j)
a= (10+5j) b= 20.5 b-a= (10.5-5j)
Multiplication Operator
The * (asterisk) symbol is defined as a multiplication operator in Python (as in many languages). It returns the product of the two operands on its either side. If any of the operands negative, the result is also negative. If both are negative, the result is positive. Changing the order of operands doesn’t change the result
Example to multiply two integers
a=10
b=20print("Multiplication of two integers")print("a =",a,"b =",b,"a*b =",a*b)
It will produce the following output −
Multiplication of two integers
a = 10 b = 20 a*b = 200
Example to multiply integer and float numbers
In multiplication, a float operand may have a standard decimal point notation, or a scientific notation.
a=10
b=20.5print("Multiplication of integer and float")print("a=",a,"b=",b,"a*b=",a*b)
a=-5.55
b=6.75E-3print("Multiplication of float and float")print("a =",a,"b =",b,"a*b =",a*b)
It will produce the following output −
Multiplication of integer and float
a = 10 b = 20.5 a-b = -10.5
Multiplication of float and float
a = -5.55 b = 0.00675 a*b = -0.037462499999999996
Example to multiply complex numbers
For the multiplication operation involving one complex operand, the other operand multiplies both the real part and imaginary part.
a=10+5j
b=20.5print("Multiplication of complex and float")print("a =",a,"b =",b,"a*b =",a*b)
It will produce the following output −
Multiplication of complex and float
a = (10+5j) b = 20.5 a*b = (205+102.5j)
Division Operator
The “/” symbol is usually called as forward slash. The result of division operator is numerator (left operand) divided by denominator (right operand). The resultant number is negative if any of the operands is negative. Since infinity cannot be stored in the memory, Python raises ZeroDivisionError if the denominator is 0.
The result of division operator in Python is always a float, even if both operands are integers.
Example to divide two numbers
a=10
b=20print("Division of two integers")print("a=",a,"b=",b,"a/b=",a/b)print("a=",a,"b=",b,"b/a=",b/a)
It will produce the following output −
Division of two integers
a= 10 b= 20 a/b= 0.5
a= 10 b= 20 b/a= 2.0
Example to divide two float numbers
In Division, a float operand may have a standard decimal point notation, or a scientific notation.
a=10
b=-20.5print("Division of integer and float")print("a=",a,"b=",b,"a/b=",a/b)
a=-2.50
b=1.25E2print("Division of float and float")print("a=",a,"b=",b,"a/b=",a/b)
It will produce the following output −
Division of integer and float
a= 10 b= -20.5 a/b= -0.4878048780487805
Division of float and float
a= -2.5 b= 125.0 a/b= -0.02
Example to divide complex numbers
When one of the operands is a complex number, division between the other operand and both parts of complex number (real and imaginary) object takes place.
a=7.5+7.5j
b=2.5print("Division of complex and float")print("a =",a,"b =",b,"a/b =",a/b)print("a =",a,"b =",b,"b/a =",b/a)
It will produce the following output −
Division of complex and float
a = (7.5+7.5j) b = 2.5 a/b = (3+3j)
a = (7.5+7.5j) b = 2.5 b/a = (0.16666666666666666-0.16666666666666666j)
If the numerator is 0, the result of division is always 0 except when denominator is 0, in which case, Python raises ZeroDivisionError wirh Division by Zero error message.
a= 0 b= 2.5 a/b= 0.0
Traceback (most recent call last):
File "C:\Users\mlath\examples\example.py", line 20, in <module>
print ("a=",a,"b=",b,"b/a=",b/a)
~^~
ZeroDivisionError: float division by zero
Modulus Operator
Python defines the “%” symbol, which is known aa Percent symbol, as Modulus (or modulo) operator. It returns the remainder after the denominator divides the numerator. It can also be called Remainder operator. The result of the modulus operator is the number that remains after the integer quotient. To give an example, when 10 is divided by 3, the quotient is 3 and remainder is 1. Hence, 10%3 (normally pronounced as 10 mod 3) results in 1.
Example for modulus operation on integers
If both the operands are integer, the modulus value is an integer. If numerator is completely divisible, remainder is 0. If numerator is smaller than denominator, modulus is equal to the numerator. If denominator is 0, Python raises ZeroDivisionError.
Python doesn’t accept complex numbers to be used as operand in modulus operation. It throws TypeError: unsupported operand type(s) for %.
Exponent Operator
Python uses ** (double asterisk) as the exponent operator (sometimes called raised to operator). So, for a**b, you say a raised to b, or even bth power of a.
If in the exponentiation expression, both operands are integer, result is also an integer. In case either one is a float, the result is float. Similarly, if either one operand is complex number, exponent operator returns a complex number.
If the base is 0, the result is 0, and if the index is 0 then the result is always 1.
Floor division is also called as integer division. Python uses // (double forward slash) symbol for the purpose. Unlike the modulus or modulo which returns the remainder, the floor division gives the quotient of the division of operands involved.
If both operands are positive, floor operator returns a number with fractional part removed from it. For example, the floor division of 9.8 by 2 returns 4 (pure division is 4.9, strip the fractional part, result is 4).
But if one of the operands is negative, the result is rounded away from zero (towards negative infinity). Floor division of -9.8 by 2 returns 5 (pure division is -4.9, rounded away from 0).
Multiplication of complex numbers is similar to multiplication of two binomials in algebra. If “a+bj” and “x+yj” are two complex numbers, then their multiplication is given by this formula −
(a+bj)*(x+yj)= ax+ayj+xbj+byj2 =(ax-by)+(ay+xb)j
For example,
a=6+4j
b=3+2j
c=a*b
c=(18-8)+(12+12)j
c=10+24j
The following program confirms the result −
a=6+4j
b=3+2jprint("Multplication of complex numbers - a=",a,"b=",b,"a*b=", a*b)
To understand the how the division of two complex numbers takes place, we should use the conjugate of a complex number. Python’s complex object has a conjugate() method that returns a complex number with the sign of imaginary part reversed.
>>> a=5+6j>>> a.conjugate()(5-6j)
Division of complex numbers
To divide two complex numbers, divide and multiply the numerator as well as the denominator with the conjugate of denominator.
Python operators are special symbols used to perform specific operations on one or more operands. The variables, values, or expressions can be used as operands. For example, Python’s addition operator (+) is used to perform addition operations on two variables, values, or expressions.
The following are some of the terms related to Python operators:
Unary operators: Python operators that require one operand to perform a specific operation are known as unary operators.
Binary operators: Python operators that require two operands to perform a specific operation are known as binary operators.
Operands: Variables, values, or expressions that are used with the operator to perform a specific operation.
Types of Python Operators
Python operators are categorized in the following categories −
Let us have a look at all the operators one by one.
Python Arithmetic Operators
Python Arithmetic operators are used to perform basic mathematical operations such as addition, subtraction, multiplication, etc.
The following table contains all arithmetic operators with their symbols, names, and examples (assume that the values of a and b are 10 and 20, respectively) −
Operator
Name
Example
+
Addition
a + b = 30
–
Subtraction
a b = -10
*
Multiplication
a * b = 200
/
Division
b / a = 2
%
Modulus
b % a = 0
**
Exponent
a**b =10**20
//
Floor Division
9//2 = 4
Example of Python Arithmetic Operators
a =21
b =10
c =0
c = a + b
print("a: {} b: {} a+b: {}".format(a,b,c))
c = a - b
print("a: {} b: {} a-b: {}".format(a,b,c))
c = a * b
print("a: {} b: {} a*b: {}".format(a,b,c))
c = a / b
print("a: {} b: {} a/b: {}".format(a,b,c))
c = a % b
print("a: {} b: {} a%b: {}".format(a,b,c))
a =2
b =3
c = a**b
print("a: {} b: {} a**b: {}".format(a,b,c))
a =10
b =5
c = a//b
print("a: {} b: {} a//b: {}".format(a,b,c))
Python Comparison operators compare the values on either side of them and decide the relation among them. They are also called Relational operators.
The following table contains all comparison operators with their symbols, names, and examples (assume that the values of a and b are 10 and 20, respectively) −
Operator
Name
Example
==
Equal
(a == b) is not true.
!=
Not equal
(a != b) is true.
>
Greater than
(a > b) is not true.
<
Less than
(a < b) is true.
>=
Greater than or equal to
(a >= b) is not true.
<=
Less than or equal to
(a <= b) is true.
Example of Python Comparison Operators
a =21
b =10if( a == b ):print("Line 1 - a is equal to b")else:print("Line 1 - a is not equal to b")if( a != b ):print("Line 2 - a is not equal to b")else:print("Line 2 - a is equal to b")if( a < b ):print("Line 3 - a is less than b")else:print("Line 3 - a is not less than b")if( a > b ):print("Line 4 - a is greater than b")else:print("Line 4 - a is not greater than b")
a,b=b,a #values of a and b swapped. a becomes 10, b becomes 21if( a <= b ):print("Line 5 - a is either less than or equal to b")else:print("Line 5 - a is neither less than nor equal to b")if( b >= a ):print("Line 6 - b is either greater than or equal to b")else:print("Line 6 - b is neither greater than nor equal to b")
Output
Line 1 - a is not equal to b
Line 2 - a is not equal to b
Line 3 - a is not less than b
Line 4 - a is greater than b
Line 5 - a is either less than or equal to b
Line 6 - b is either greater than or equal to b
Python Assignment Operators
Python Assignment operators are used to assign values to variables. Following is a table which shows all Python assignment operators.
The following table contains all assignment operators with their symbols, names, and examples −
Operator
Example
Same As
=
a = 10
a = 10
+=
a += 30
a = a + 30
-=
a -= 15
a = a – 15
*=
a *= 10
a = a * 10
/=
a /= 5
a = a / 5
%=
a %= 5
a = a % 5
**=
a **= 4
a = a ** 4
//=
a //= 5
a = a // 5
&=
a &= 5
a = a & 5
|=
a |= 5
a = a | 5
^=
a ^= 5
a = a ^ 5
>>=
a >>= 5
a = a >> 5
<<=
a <<= 5
a = a << 5
Example of Python Assignment Operators
a =21
b =10
c =0print("a: {} b: {} c : {}".format(a,b,c))
c = a + b
print("a: {} c = a + b: {}".format(a,c))
c += a
print("a: {} c += a: {}".format(a,c))
c *= a
print("a: {} c *= a: {}".format(a,c))
c /= a
print("a: {} c /= a : {}".format(a,c))
c =2print("a: {} b: {} c : {}".format(a,b,c))
c %= a
print("a: {} c %= a: {}".format(a,c))
c **= a
print("a: {} c **= a: {}".format(a,c))
c //= a
print("a: {} c //= a: {}".format(a,c))
Output
a: 21 b: 10 c : 0
a: 21 c = a + b: 31
a: 21 c += a: 52
a: 21 c *= a: 1092
a: 21 c /= a : 52.0
a: 21 b: 10 c : 2
a: 21 c %= a: 2
a: 21 c **= a: 2097152
a: 21 c //= a: 99864
Python Bitwise Operators
Python Bitwise operator works on bits and performs bit by bit operation. These operators are used to compare binary numbers.
The following table contains all bitwise operators with their symbols, names, and examples −
Operator
Name
Example
&
AND
a & b
|
OR
a | b
^
XOR
a ^ b
~
NOT
~a
<<
Zero fill left shift
a << 3
>>
Signed right shift
a >> 3
Example of Python Bitwise Operators
a =20
b =10print('a=',a,':',bin(a),'b=',b,':',bin(b))
c =0
c = a & b;print("result of AND is ", c,':',bin(c))
c = a | b;print("result of OR is ", c,':',bin(c))
c = a ^ b;print("result of EXOR is ", c,':',bin(c))
c =~a;print("result of COMPLEMENT is ", c,':',bin(c))
c = a <<2;print("result of LEFT SHIFT is ", c,':',bin(c))
c = a >>2;print("result of RIGHT SHIFT is ", c,':',bin(c))
Output
a= 20 : 0b10100 b= 10 : 0b1010
result of AND is 0 : 0b0
result of OR is 30 : 0b11110
result of EXOR is 30 : 0b11110
result of COMPLEMENT is -21 : -0b10101
result of LEFT SHIFT is 80 : 0b1010000
result of RIGHT SHIFT is 5 : 0b101
Python Logical Operators
Python logical operators are used to combile two or more conditions and check the final result. There are following logical operators supported by Python language. Assume variable a holds 10 and variable b holds 20 then
The following table contains all logical operators with their symbols, names, and examples −
Operator
Name
Example
and
AND
a and b
or
OR
a or b
not
NOT
not(a)
Example of Python Logical Operators
var =5print(var >3and var <10)print(var >3or var <4)print(not(var >3and var <10))
Output
True
True
False
Python Membership Operators
Python’s membership operators test for membership in a sequence, such as strings, lists, or tuples.
There are two membership operators as explained below −
Operator
Description
Example
in
Returns True if it finds a variable in the specified sequence, false otherwise.
a in b
not in
returns True if it does not finds a variable in the specified sequence and false otherwise.
a not in b
Example of Python Membership Operators
a =10
b =20list=[1,2,3,4,5]print("a:", a,"b:", b,"list:",list)if( a inlist):print("a is present in the given list")else:print("a is not present in the given list")if( b notinlist):print("b is not present in the given list")else:print("b is present in the given list")
c=b/a
print("c:", c,"list:",list)if( c inlist):print("c is available in the given list")else:print("c is not available in the given list")
Output
a: 10 b: 20 list: [1, 2, 3, 4, 5]
a is not present in the given list
b is not present in the given list
c: 2.0 list: [1, 2, 3, 4, 5]
c is available in the given list
There are two Identity operators explained below −
Operator
Description
Example
is
Returns True if both variables are the same object and false otherwise.
a is b
is not
Returns True if both variables are not the same object and false otherwise.
a is not b
Example of Python Identity Operators
a =[1,2,3,4,5]
b =[1,2,3,4,5]
c = a
print(a is c)print(a is b)print(a isnot c)print(a isnot b)
Output
True
False
False
True
Python Operators Precedence
Operators precedence decides the order of the evaluation in which an operator is evaluated. Python operators have different levels of precedence. The following table contains the list of operators having highest to lowest precedence −
The following table lists all operators from highest precedence to lowest.
Sr.No.
Operator & Description
1
**Exponentiation (raise to the power)
2
~ + –Complement, unary plus and minus (method names for the last two are +@ and -@)
3
* / % //Multiply, divide, modulo and floor division
