Python Operators and Operands with examples

Python Operators and Operands.  Learn the types of  operators in python like arithmetic, assignment operators, etc. Type casting, operators precedence, expressions and statements in python are some topics covered in this post.

Operators and Operands

The symbols that trigger the operation/action on data, are called operators, and the data on which operation is being carried out are referred to as operands.

Types of operators in Python:

• Arithmetic Operators
• Comparison (Relational) Operators
• Assignment Operators
• Bitwise Operators
• Logical Operators
• Membership Operators
• Identity Operators

Let’s have a look and discuss these operators in detail.

  Arithmetic Operators

Operator	Description	Example 1	Example 2
+ Addition	Adds values on either side of the operator.	a + b = 30	>>> ‘Good’ + ‘Morning’ GoodMorning
- Subtraction	Subtracts right hand operand from left hand operand.	a – b = -10	>>>55-45 10
* Multiplication	Multiplies values on either side of the operator	a * b = 200	>>> ‘Good’ * 3 GoodGoodGood
/ Division	Divides left hand operand by right hand operand	b / a = 2	>>>28/3 9
% Modulus	Divides left hand operand by right hand operand and returns remainder	b % a = 0	>>>17%5 2
** Exponent	Performs exponential (power) calculation on operators	a**b =10 to the power 20	>>>2**8 256
// Floor Division	Floor Division - The division of operands where the result is the quotient in which the digits after the decimal point are removed.	9//2 = 4 and 9.0//2.0 = 4.0	>>>3//2 1

Example: Print the area of circle of radius 14 metres.

radius = 14 area = (22/7)*radius**2 print(area,’sq. metre’)

Relational Operators

Operator	Description	Example
==	If the values of two operands are equal, then the condition becomes true.	(a == b) is not true.
!=	If values of two operands are not equal, then condition becomes true.	(a != b) is true.
<>	If values of two operands are not equal, then condition becomes true.	(a <> b) is true. This is similar to != operator.
>	If the value of left operand is greater than the value of right operand, then condition becomes true.	(a > b) is not true.
<	If the value of left operand is less than the value of right operand, then condition becomes true.	(a < b) is true.
>=	If the value of left operand is greater than or equal to the value of right operand, then condition becomes true.	(a >= b) is not true.
<=	If the value of left operand is less than or equal to the value of right operand, then condition becomes true.	(a <= b) is true.

For example:

a = 3; b=13

a < b       # will return True

“God” < “Godhouse”      # will return True

“god” < “Godhouse”      # will return False

      It returns false because the length of the string does not matter here. Lower case g is greater than upper case G.

Assignment Operators

Assigned values from right side operands to left variable

Operator	Description	Example
=	Assigns values from right side operands to left side operand	c = a + b assigns value of a + b into c
+= Add AND	It adds right operand to the left operand and assign the result to left operand	c += a is equivalent to c = c + a
-= Subtract AND	It subtracts right operand from the left operand and assign the result to left operand	c -= a is equivalent to c = c - a
*= Multiply AND	It multiplies right operand with the left operand and assign the result to left operand	c *= a is equivalent to c = c * a
/= Divide AND	It divides left operand with the right operand and assign the result to left operand	c /= a is equivalent to c = c / a
%= Modulus AND	It takes modulus using two operands and assign 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 assign value to the left operand	c //= a is equivalent to c = c // a

Bitwise Operators

Bitwise operator works on bits and performs bit by bit operation. Assume if a = 60; and b = 13; Now in binary format they will be as follows:

a = 0011 1100

b = 0000 1101

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

Operator	Description	Example
& Binary AND	Operator copies a bit to the result if it exists in both operands.	(a & b) = 12 (means 0000 1100)
| Binary OR	It copies a bit if it exists in either operand.	(a | b) = 61 (means 0011 1101)
^ Binary XOR	It copies the bit if it is set in one operand but not both.	(a ^ b) = 49 (means 0011 0001)
~ Binary Ones Complement	It is unary and has the effect of 'flipping' bits.	(~a ) = -61 (means 1100 0011 in 2's complement form due to a signed binary number.
<< Binary Left Shift	The left operands value is moved left by the number of bits specified by the right operand.	a << 2 = 240 (means 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 (means 0000 1111)

Logical Operators

Operator	Description	Example
and Logical AND	If both the operands are true then condition becomes true.	(a and b) is true.
or Logical OR	If any of the two operands are non-zero then condition becomes true.	(a or b) is true.
not Logical NOT	Used to reverse the logical state of its operand.	Not (a and b) is false.

Membership Operators

Operator	Description	Example
in	Evaluates to true if it finds a variable in the specified sequence and false otherwise.	x in y, here in results in a 1 if x is a member of sequence y.
not in	Evaluates to true if it does not finds a variable in the specified sequence and false otherwise.	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 compare the memory locations of two objects. There are two Identity operators as explained below:

Operator	Description	Example
is	Evaluates to true if the variables on either side of the operator point to the same object and false otherwise.	x is y, here is results in 1 if id(x) equals id(y).
is not	Evaluates to false if the variables on either side of the operator point to the same object and true otherwise.	x is not y, here is not results in 1 if id(x) is

Operators Precedence

When an expression or statement involves multiple operators, Python resolves the order of execution through Operator Precedence. The chart of operator precedence from highest to lowest for the operators is given below.

Operator	Description
**	Exponentiation (raise to the power)
~ + -	Complement, unary plus and minus (method names for the last two are +@ and -@)
* / % //	Multiply, divide, modulo and floor division
+ -	Addition and subtraction
>> <<	Right and left bitwise shift
&	Bitwise 'AND'
^ |	Bitwise exclusive `OR' and regular `OR'
<= < > >=	Comparison operators
<> == !=	Equality operators
= %= /= //= -= += *= **=	Assignment operators
is is not	Identity operators
in not in	Membership operators
not or and	Logical operators

Operator Associativity

Python allows multiple operators in a single expression e.g., a < b+2 < c or p < q > r

Associativity is the order inn which an expression (having multiple order of same precedence) is evaluated. Almost all the operators have left-to-right associativity except exponentiation (**), which has right-to-left associativity.

For example, multiplication operator (*), division operator(/) and floor division operator (//) have the same precedence. So if we have an expression having these operators simultaneously, then the same-precedence-operators will be evaluated in left-to-right order.

In[1] : 7 * 8 /5 // 2

Out[1] : 5.0

In[2] : 3 ** 3 ** 2

Out[2] : 19683

Expressions

An expression in Python is any valid combination of operators and atoms. An expression is composed of one or more operations. We have seen many such expressions (with list of operators as example). 10+5 and 9+4+2 are two expressions which will result into value 15. Taking another example, 5.0/4+ (6- 3.0) is an expression in which values of different data types are used. These types of expressions are also known as mixed type expressions.

When mixed type expressions are evaluated, Python promotes the result of lower data type to higher data type, i.e. to float in the above example. This is known as implicit type casting. So, the result of above expression will be 4.25. Expression can also contain another expression. As we have already seen in 9+4+2. When we have an expression consisting of sub expression(s), how does Python decide the order of operations?

It is done based on precedence of operator. Higher precedence operator is worked on before lower precedence operator.

Note: In python ‘=’ and ‘**’ are Right Associative.

Type Casting

The explicit conversion of an operand to a specific type is called type casting.

<datatype> (expression)

Any number-convertible type	int()
Any number-convertible type	float()
Numbers	complex()
Number Booleans	str()
Any type	bool()

For example:

int(7.8) # will give 7

int(‘34’) # will give 34

complex(7) # will give 7 + 0j

complex(3,2) # will give 3 + 2j

bool(0.0) # will give false

bool(‘’) # will give false