Python Operators

Python operators are symbols that are used to perform operations on variables and values. They are used to manipulate data and perform calculations.

Categories of Python operators, based on the types of operations they perform, are as follows:

• 1. Arithmetic Operators
• 2. Comparison Operators
• 3. Assignment Operators
• 4. Logical Operators
• 5. Bitwise Operators
• 6. Membership Operators
• 7. Identity Operators
• 8. Ternary Operator (Conditional Expression)
• 9. Unary Operators

In Python, arithmetic operators are used to perform mathematical operations on numerical values.

Arithmetic operators are:

• Addition (+): Adds two operands.
• Subtraction (-): Subtracts the second operand from the first.
• Multiplication (*): Multiplies two operands.
• Division (/): Divides the first operand by the second (result is always a float).
• Floor Division (//): Divides the first operand by the second and returns the integer part of the result (rounded down).
• Modulus (%): Returns the remainder of the division of the first operand by the second.
• Exponentiation (**): Raises the first operand to the power of the second operand.

Output of the above example

Addition: 13
Subtraction: 3
Product of multiplication: 40
Quotient of division: 8.0
Result of floor division: 3
result of modulus (remainder): 1
Result of exponentiation 25
                                

In Python, comparison operators are used to compare values. They return boolean values 'True' or 'False' based on if the comparison is true or not.

Comparison operators are:

• Equal to (==): Checks if the values of two operands are equal.
• Not equal to (!=): Checks if the values of two operands are not equal.
• Greater than (>): Checks if the value of the left operand is greater than the value of the right operand.
• Less than (<): Checks if the value of the left operand is less than the value of the right operand.
• Greater than or equal to (>=): Checks if the value of the left operand is greater than or equal to the value of the right operand.
• Less than or equal to (<=): Checks if the value of the left operand is less than or equal to the value of the right operand.

Output of the above example

Equal: False
Not equal to: True
Greater than: True
Less than: False
Greater than or equal to: True
Less than or equal to: True
                                

In Python, assignment operators are used to assign values to variables.

Assignment operators are:

• Simple Assignment (=): Assigns the value on the right to the variable on the left.
• Addition Assignment (+=): Adds the value on the right to the variable on the left and assigns the result to the variable.
• Subtract Assignment (-=): Subtracts the value on the right from the variable on the left and assigns the result to the variable.
• Multiplication Assignment (*=): Multiplies the variable on the left by the value on the right and assigns the result to the variable.
• Division Assignment (/=): Divides the variable on the left by the value on the right and assigns the result to the variable.
• Floor Division Assignment (//=): Performs floor division on the variable on the left by the value on the right and assigns the result to the variable.
• Modulus Assignment (%=): Computes the modulus of the variable on the left with the value on the right and assigns the result to the variable.
• Exponentiation Assignment (**=): Raises the variable on the left to the power of the value on the right and assigns the result to the variable.
• Bitwise AND Assignment (&=): Performs a bitwise AND operation between the variable on the left and the value on the right, and assigns the result to the variable.
• Bitwise OR Assignment (|=): Performs a bitwise OR operation between the variable on the left and the value on the right, and assigns the result to the variable.
• Bitwise XOR Assignment (^=): Performs a bitwise XOR operation between the variable on the left and the value on the right, and assigns the result to the variable.
• Bitwise Left Shift Assignment (<<=): Performs a bitwise left shift operation on the variable on the left by the number of bits specified by the value on the right, and assigns the result to the variable.
• Bitwise Right Shift Assignment (>>=): Performs a bitwise right shift operation on the variable on the left by the number of bits specified by the value on the right, and assigns the result to the variable.

Please have a closer look at the following examples:

Output of the above example

Simple assignment: 5
Addition Assignment: 8
Subtract Assignment: 3
Multiplication Assignment: 9
Division Assignment: 1.0
Floor Division Assignment: 2
Modulus Assignment: 1
Exponentiation Assignment: 25
Bitwise AND Assignment: 0
Bitwise OR Assignment: 5
Bitwise XOR Assignment: 4
Bitwise Left Shift Assignment: 20
Bitwise Right Shift Assignment: 2
                                

In Python, logical operators are used to perform logical operations on True and False of boolean values. The logical operators in Python are:

• Logical and (and): returns True if both operands are True, otherwise returns False.
• Logical or (or): Returns True if at least one operand is True, otherwise returns False.
• Logical not (not): Returns True if the operand is False, and False if the operand is True.

Please have a closer look at the following examples:

Output of the above example

True
False
True
True
False
                                

In Python, bitwise operators are used to perform operations on individual bits of integers.

Bitwise operators work at the binary level. The bitwise operators are:

• Bitwise AND (&): Performs a bitwise AND operation between the corresponding bits of two operands where the result is 1 if both bits are 1; otherwise, it's 0.
• Bitwise OR (|): Performs a bitwise OR operation between the corresponding bits of two operands where the result is 1 if at least one of the bits is 1; otherwise, it's 0.
• Bitwise XOR (^): Performs a bitwise XOR (exclusive OR) operation between the corresponding bits of two operands where the result is 1 if the bits are different; otherwise, it's 0.
• Bitwise NOT (~): Pperforms a bitwise NOT operation on its single operand, which inverts (flips) all the bits (1 to 0 and 0 to 1).
• Left Shift (<<): Shifts the bits of the left operand to the left by a number of positions specified by the right operand.
• Right Shift (>>): This operator shifts the bits of the left operand to the right by a number of positions specified by the right operand.

Please have a closer look at the following examples:

Output of the above example

1
7
6
-6
10
2
                                

In Python, membership operators ('in' and 'not in') are used to test whether a value exists within a sequence (such as strings, lists, or tuples). The membership operators in Python are:

• 'in' operator : Checks if a value exists in a sequence. If the value is present in the sequence, the 'in' operator returns True; otherwise, it returns False.
• 'not in' operator: Checks if a value does not exist in a sequence. If the value is not present in the sequence, the 'not in' operator returns True; otherwise, it returns False.

Please have a closer look at the following examples:

Output of the above example

True
True
                                

In Python, identity operators are used to check if two variables refer to the exact same object in memory. The identity operators in Python are:

• 'is' operator : Returns True if two variables point to the same object; otherwise, it returns False.
• 'is not' operator: Returns True if two variables do not point to the same object; otherwise, it returns False.

Please have a closer look at the following examples:

Output of the above example

False
True
True
False
                                

In Python, ternary operator is used to provide a concise way to write conditional statements in a single line. Here is the syntext of ternary operator:

<expression_if_condition_is_true> if <condition> else <expression_if_condition_is_false>

In the following example, if the condition (if num % 2 == 0) is true, it will return "even number"; otherwise, it will return "odd number". As the num is 17, the condition will be false and it will return "odd number".

Please have a closer look at the following example:

Output of the above example

17 is an odd number
                                

In Python, Unary Operators act on a single operand.

They perform various operations such as negation, logical negation, bitwise negation, etc.

• Positive (+): Indicates a positive value.
• Negative (-): Negates the value of its operand.
• Logical NOT: Negates the boolean truth value of its operand (though not is a logical operator in Python).
• Bitwise NOT (~): Inverts the bits of its operand.

Please have a closer look at the following examples:

Output of the above example

-7
-6
False
                                

Practice the above Python code in the following Python Editor. Create more code using Python operators and perform different operations in the following Python code editor and click Execute button. Output will be displayed in Python Code Output section.

Python Editor Execute

# Addition result_addition = 5 + 8 # Result: 13 print("Addition:", result_addition) # Subtraction result_subtraction = 8 - 5 # Result: 3 print("Subtraction:", result_subtraction) # Multiplication result_multiplication = 8 * 5 # Result: 40 print("Product of multiplication:", result_multiplication) # Division result_division = 40 / 5 # Result: 2.0 (always a float) print("Quotient of division:", result_division) # Floor Division result_floor_division = 16 // 5 # Result: 2 print("Result of floor division:", result_floor_division) # Modulus result_modulus = 11 % 5 # Result: 1 (remainder of division) print("result of modulus (remainder):", result_modulus) # Exponentiation result_exponentiation = 5 ** 2 # Result: 25 (5 raised to the power of 2) print("Result of exponentiation", result_exponentiation) # Equal to result_equat = 5 == 8 # Result: False print("Equal:", result_equat) # Not equal to result_not_equal = 8 != 5 # Result: True print("Not equal to:", result_not_equal) # greater than greater_than = 8 > 5 # Result: True print("Greater than:", greater_than) # Less than less_than = 8 < 5 # Result: False print("Less than:", less_than) # Greater than or equal to greater_than_or_equal_to = 8 >= 5 # Result: True print("Greater than or equal to:", greater_than_or_equal_to) # Greater than or equal to less_than_or_equal_to = 5 <= 8 # Result: True print("Less than or equal to:", less_than_or_equal_to) #Simple assignment x = 5 print("Simple assignment:", x) #Addition Assignment x = 5 x += 3 # equivalent to x = x + 3 print("Addition Assignment:", x) #Subtract Assignment x = 5 x -= 2 # equivalent to x = x - 2 print("Subtract Assignment:", x) #Multiplication Assignment x = 5 x *= 3 # equivalent to x = x * 3 print("Multiplication Assignment:", x) #Division Assignment x = 5 x /= 5 # equivalent to x = x / 5 print("Division Assignment:", x) #Floor Division Assignment x = 5 x //= 2 # equivalent to x = x // 2 print("Floor Division Assignment:", x) #Modulus Assignment x = 5 x %= 2 # equivalent to x = x % 2 print("Modulus Assignment:", x) #Exponentiation Assignment x = 5 x **= 2 # equivalent to x = x ** 2 print("Exponentiation Assignment:", x) #Bitwise AND Assignment x = 5 x &= 2 # equivalent to x = x & 2 print("Bitwise AND Assignment:", x) #Bitwise OR Assignment x = 5 x |= 4 # equivalent to x = x | 4 print("Bitwise OR Assignment:", x) #Bitwise XOR Assignment x = 5 x ^= 1 # equivalent tox = x ^ 1 print("Bitwise XOR Assignment:", x) #Bitwise Left Shift Assignment x = 5 x <<= 2 # equivalent to x = x << 2 print("Bitwise Left Shift Assignment:", x) #Bitwise Right Shift Assignment x = 5 x >>= 1 # equivalent to x = x >> 1 print("Bitwise Right Shift Assignment:", x)

Python Code Output