In Python, operators are special symbols that perform arithmetic or logical computation. The operand is the value on which the operator operates.

Examples of operators and operands are given below:

>>> 2+3 5

+ is the addition operator in this case. 2 and 3 are the operands, and 5 is the operation’s output.

In this article, we will look at various Python operators.

__Arithmetic Operators__

Arithmetic operators are employed in the execution of mathematical operations such as addition, subtraction, multiplication, and division.

Operator | Description | Syntax | ||

+ | Addition: adds two operands | x + y | ||

– | Subtraction: subtracts two operands | x-y | ||

* |
| X*y | ||

/ |
| x/y | ||

// | Division (floor): divides the first operand by the second | x//y | ||

% | Modulus: returns the remainder when the first operand is divided by the second | x%y | ||

** | Power: Returns first raised to power second | x**y |

__Precedence__

- P â€“ Parentheses
- E â€“ Exponentiation
- M â€“ Multiplication (Multiplication and division have the same precedence)
- D â€“ Division
- A â€“ Addition (Addition and subtraction have the same precedence)
- Â S â€“ Subtraction

The modulus operator assists us in determining the last digit/s of a number. As an example:

- Â x % 10 -> yields the last digit
- Â x % 100 -> yield last two digits

__Example: Arithmetic operators in Python__

# Examples of Arithmetic Operator a = 9 b = 4 # Addition of numbers add = a + b # Subtraction of numbers sub = a - b # Multiplication of number mul = a * b # Division(float) of number div1 = a / b # Division(floor) of number div2 = a // b # Modulo of both number mod = a % b # Power p = a ** b # print results print(add) print(sub) print(mul) print(div1) print(div2) print(mod) print(p)

__Output__

13 5 36 2.25 2 1 6561

__Comparison Operators__

Comparison of Relational operators compares the values. Depending on the condition, it either returns True or False.

Operator | Description | Syntax | ||

> | Greater than: True if the left operand is greater than the right | x>y | ||

< | Less than: True if the left operand is less than the right | x<y | ||

== |
| x==y | ||

!= |
| x!=y | ||

>= | Greater than or equal to True if the left operand is greater than or equal to the right | x>=y | ||

<= | Less than or equal to True if the left operand is less than or equal to the right | x<=y | ||

is | x is the same as y | x is y | ||

Is not | x is not the same as y | x is not y |

= is an assignment operator and == comparison operator.

__Example: Comparison Operators in Python__

# Examples of Relational Operators a = 13 b = 33 # a > b is False print(a > b) # a < b is True print(a < b) # a == b is False print(a == b) # a != b is True print(a != b) # a >= b is False print(a >= b) # a <= b is True print(a <= b)

__Output__

False True False True False True

__Logical Operators__

Logical operators carry out operations such as Logical AND, Logical OR, and Logical NOT. It is used to join conditional statements together.

Operator | Description | Syntax | ||

and |
| x and y | ||

or | Logical OR: True if either of the operands is true | x or y | ||

not | Logical NOT: True if the operand is false | not x |

__Example: Logical Operators in Python__

# Examples of Logical Operator a = True b = False # Print a and b is False print(a and b) # Print a or b is True print(a or b) # Print not a is False print(not a)

__Output__

False True False

__Bitwise Operators__

Bitwise operators operate on bits and perform bit-by-bit operations. These are used to perform binary number operations.

Operator | Description | Syntax | ||

& | Bitwise AND | x&y | ||

| | Bitwise OR | x|y | ||

~ | Bitwise NOT | ~x | ||

^ | Bitwise XOR | x^y | ||

>> | Bitwise right shift | x>> | ||

<< |
| x<< |

__Example: Bitwise Operators in Python__

# Examples of Bitwise operators a = 10 b = 4 # Print bitwise AND operation print(a & b) # Print bitwise OR operation print(a | b) # Print bitwise NOT operation print(~a) # print bitwise XOR operation print(a ^ b) # print bitwise right shift operation print(a >> 2) # print bitwise left shift operation print(a << 2)

__Output__

0 14 -11 14 2 40

__Assignment Operators__

Assignment operators are used to assigning values to variables.

Operator | Description | Syntax | ||

= | Assign value of right side of expression to left side operand |
| ||

+= | Add AND: Add right-side operand with left side operand and then assign to left operand |
| ||

-= | Subtract AND: Subtract right operand from left operand and then assign to left operand | a-=b Â Â a=a-b | ||

*= | Multiply AND: Multiply right operand with left operand and then assign to left operand | a*=b Â Â a=a*b | ||

/= | Divide AND: Divide left operand with right operand and then assign to left operand | a/=b Â Â a=a/b | ||

%= |
| a%=b a=a%b | ||

//= | Divide(floor) AND: Divide the left operand with the right operand and then assign the value(floor) to the left operand | Â a//=b a=a//b | ||

**= | Exponent AND: Calculate exponent(raise power) value using operands and assign value to left operand | a**=b a=a**b | ||

&= | Performs Bitwise AND on operands and assigns value to left operand | a&=b a=a&b | ||

|= |
| a|=b Â Â a=a|b | ||

^= | Performs Bitwise xOR on operands and assigns value to left operand | a^=b Â Â a=a^b | ||

>>= | Performs Bitwise right shift on operands and assigns value to left operand | a>>=b a=a>>b | ||

<<= | Performs Bitwise left shift on operands and assigns value to left operand | a <<= b Â Â a= a << b |

__Example: Assignment Operators in Python__

# Examples of Assignment Operators a = 10 # Assign value b = a print(b) # Add and assign value b += a print(b) # Subtract and assign value b -= a print(b) # multiply and assign b *= a print(b) # bitwise lishift operator b <<= a print(b)

__Output__

10 20 10 100 102400

__Identity Operators__

The identity operators is and is not are used to determine whether two values are in the same part of memory. The fact that two variables are equal does not imply that they are identical.

isÂ Â Â Â Â Â Â Â Â True if the operands are identicalis notÂ Â Â Â Â True if the operands are not identical

__Example: Identity Operator__

a = 10 b = 20 c = a print(a is not b) print(a is c)

__Output__

True True

__Membership Operators__

The membership operators in and not in are used to determine whether a value or variable is in a sequence.

inÂ Â Â Â Â Â Â Â Â Â Â True if value is found in the sequencenot inÂ Â Â Â Â Â Â True if value is not found in the sequence

__Example: Membership Operator__

# Python program to illustrate # not 'in' operator x = 24 y = 20 list = [10, 20, 30, 40, 50] if (x not in list): print("x is NOT present in given list") else: print("x is present in given list") if (y in list): print("y is present in given list") else: print("y is NOT present in given list")

__Output__

x is NOT present in given list y is present in given list

__Precedence and Associativity of Operators__

Operator Precedence and Associativity: Operator precedence and associativity determine the operator’s priorities.

__Operator Precedence__

This is used to determine which operation to perform first in an expression with multiple operators with different precedence.

__Example: Operator Precedence__

# Examples of Operator Precedence # Precedence of '+' & '*' expr = 10 + 20 * 30 print(expr) # Precedence of 'or' & 'and' name = "Alex" age = 0 if name == "Alex" or name == "John" and age >= 2: print("Hello! Welcome.") else: print("Good Bye!!")

__Output__

610 Hello! Welcome.

__Operator Associativity__

Operator Associativity is used to determine if an expression contains two or more operators with the same precedence. It can either be Left to Right or from Right to Left.

__Example: Operator Associativity__

# Examples of Operator Associativity # Left-right associativity # 100 / 10 * 10 is calculated as # (100 / 10) * 10 and not # as 100 / (10 * 10) print(100 / 10 * 10) # Left-right associativity # 5 - 2 + 3 is calculated as # (5 - 2) + 3 and not # as 5 - (2 + 3) print(5 - 2 + 3) # left-right associativity print(5 - (2 + 3)) # right-left associativity # 2 ** 3 ** 2 is calculated as # 2 ** (3 ** 2) and not # as (2 ** 3) ** 2 print(2 ** 3 ** 2)

__Output__

100.0 6 0 512

__Division Operators__

Division Operators allow you to divide two numbers and return the quotient; that is, the first number or number on the left is divided by the second number or number on the right, and the quotient is returned.

Division operators are classified into two types:

__Float division:__

The quotient returned by this operator is always a float number, regardless of whether the two numbers are integers or not. As an example:

>>>5/5 1.0 >>>10/2 5.0 >>>-10/2 -5.0 >>>20.0/2 10.0

__Integer division( Floor division):__

The quotient returned by this operator is determined by the argument passed. If any of the numbers is a float, the output is in float. It is also known as floor division because if any number is negative, the output is floored. For instance:

>>>5//5 1 >>>3//2 1 >>>10//3 3

Consider the Python statements below:

# A Python program to demonstrate the use of # "//" for integers print (5//2) print (-5//2)

__Output__

2 -3

The first output is satisfactory, but the second may surprise us if we are in the Java/C++ world. The “//” operator in Python acts as a floor division for integer and float arguments. The division operator ‘/’, on the other hand, always returns a float value.

** Note: **To return the closest integer value that is less than or equal to a specified expression or value, use the “//” operator. As a result of the preceding code, 5/2 returns 2. You already know that 5/2 equals 2.5, and the nearest integer that is less than or equal to 5/2 is 2. (It is the inverse of normal math; the value in normal math is 3).

__Example__

# A Python program to demonstrate use of # "/" for floating point numbers print (5.0/2) print (-5.0/2)

__Output__

2.5 -2.5

“//” is the correct floor division operator. For both integer and floating-point arguments, it returns the floor value.

# A Python program to demonstrate use of # "//" for both integers and floating points print (5//2) print (-5//2) print (5.0//2) print (-5.0//2)

__Output__

2 -3 2.0 -3.0

Take a look at this.

__Ternary Operators__

Ternary operators, also known as conditional expressions, evaluate something based on whether a condition is true or false. Python version 2.5 included it.

It simply allows you to test a condition in a single line instead of a multiline if-else, making the code more compact.

__Syntax__

[on_true] if [expression] else [on_false]

A simple way to use the ternary operator:

# Program to demonstrate conditional operator a, b = 10, 20 # Copy value of a in min if a < b else copy b min = a if a < b else b print(min)

__Output__

10

__Direct Method with Tuples, Dictionary, and Lambda__

# Python program to demonstrate ternary operator a, b = 10, 20 # Use tuple for selecting an item # (if_test_false,if_test_true)[test] # if [a<b] is true it return 1, so element with 1 index will print # else if [a<b] is false it return 0, so element with 0 index will print print( (b, a) [a < b] ) # Use Dictionary for selecting an item # if [a < b] is true then value of True key will print # else if [a<b] is false then value of False key will print print({True: a, False: b} [a < b]) # lambda is more efficient than above two methods # because in lambda we are assure that # only one expression will be evaluated unlike in # tuple and Dictionary print((lambda: b, lambda: a)[a < b]())

__Output__

10 10 10

Ternary operators can be expressed as nested if-else statements:

# Python program to demonstrate nested ternary operator a, b = 10, 20 print ("Both a and b are equal" if a == b else "a is greater than b" if a > b else "b is greater than a")

The preceding strategy can be written as follows:

# Python program to demonstrate nested ternary operator a, b = 10, 20 if a != b: if a > b: print("a is greater than b") else: print("b is greater than a") else: print("Both a and b are equal")

__Output__

b is greater than a

To use the print function in the ternary operator, do the following:

Example: In Python3, find the greater of two numbers using the ternary operator.

a=5 b=7 # [statement_on_True] if [condition] else [statement_on_false] print(a,"is greater") if (a>b) else print(b,"is Greater")

__Output__

7 is Greater

__Important Notes:__

- The given condition is first evaluated (a<b), and then either an or b is returned based on the condition’s Boolean value.
- The order of the arguments in the operator differs from that of other languages such as C/C++.
- Conditional expressions are the least important Python operation.

Prior to 2.5, this method was used when the ternary operator was not present.

In an expression like the one below, the interpreter looks for the expression and evaluates on_true if it is true, otherwise, on_false is evaluated.

__Syntax__

'''When condition becomes true, expression [on_false] is not executed and value of "True and [on_true]"Â Â is returned.Â Else value of "False or [on_false]"Â Â is returned.Â Â Note that "True and x" is equal to x. Â Â Â And "False or x" is equal to x. ''' [expression] and [on_true] or [on_false]

__Example__

# Program to demonstrate conditional operator a, b = 10, 20 # If a is less than b, then a is assigned # else b is assigned (Note : it doesn't # work if a is 0. min = a < b and a or b print(min)

__Output__

10

** Note: **The only disadvantage of this method is that on_true cannot be 0 or False. If this occurs, on_false will always be evaluated. The reason for this is that if the expression is true, the interpreter will check for on_true; if it is zero or_false, the interpreter will check for on false to give the final result of the entire expression.