Python Operators Explained in Detail with Examples

When diving into the world of Python programming, understanding Python operators is akin to learning the alphabets of a new language. These operators act as the building blocks for any Python script, playing a critical role in carrying out operations like arithmetic calculations, comparisons, and logical decisions. Not only do they facilitate code execution, but they also make your code more efficient and readable. In this comprehensive guide, we will explore various types of Python operators, how they function, and why they are essential for anyone aspiring to master Python programming.

 

Different Python Operators

Here are the list of Python Operators:

• Arithmetic Operators
• Comparison Operators
• Logical Operators
• Assignment Operators
• Augmented Operators
• Bitwise Operators
• Identity Operators
• Membership Operators

We will cover these in detail in next chapters.

 

1. Arithmetic operators in Python

As the name suggests, these operators perform various arithmetic operations and calculations like addition, multiplications, division, etc. They can be used with numerical data types like integers and floats, and some can even be used with strings and lists for operations like concatenation and repetition.

Below is a table that provides a detailed explanation of arithmetic operators in Python.

In each example, the variable a is used to store the result of the operation, and then print(a) is used to display the output.

 

2. Comparison operators in Python

Comparison operators are also known as rational operators as well. They are used to compare different values.  They evaluate different types of expressions and manipulate the values of variables by performing different operations on them.

In each code example, the variable a is used to store the result of the comparison operation, and then print(a) is used to display the Boolean output (True or False).

 

3. Logical operators in Python

Python logical operators are used to evaluate the one or more than one condition between variables or operands by providing specific results. i.e True and False. Useful for making decisions in code (conditionals) and testing multiple conditions. It can be used with any data types that can be converted to Boolean values.

In each example, the variable a is used to store the result of the logical operation, and print(a) is used to display the resulting Boolean value (True or False).

 

4. Assignment Operators

Assignment operators are primarily used to assign values to variables. They perform a single function of assigning a value from the right-hand side to the variable on the left-hand side. It is useful for initializing variables and updating their values.

Below is a table that explains the assignment operators in Python, along with code examples using a small variable name (a) and the print() statement to display the result.

In each example, the variable a is initially assigned a value. Then, an assignment operator modifies this value, and print(a) displays the updated value.

 

5. Augmented Operators (Compound Assignment Operators)

Python has a set of operators known as "augmented assignment operators," also sometimes called "compound assignment operators." These operators provide a shorthand way to apply an operation and an assignment in a single step. They are similar to assignment operators but perform an additional operation before the assignment.

Unlike normal assignment operators, Augmented Assignment Operators are used to replace those statements where a binary operator takes two operands, variable1 and variable1 and then assigns a final result back to one of the operands.

Below is a table that outlines the augmented assignment operators in Python, complete with code examples using a small variable name (a) and the print() function to display the result.

In each example, the variable a is initially assigned a value. Then, an augmented assignment operator modifies this value, and print(a) displays the updated value.

 

6. Bitwise Operators

Bitwise operators in Python are used to operate at a binary level. This means they look directly at the binary digits or binary bits of an integer. Below is a table that explains each bitwise operator in Python, along with a code example that uses a small variable name (a) and the print() statement to display the result.

 

Below are some examples to help you understand how these operators work in Python:

Bitwise AND (&):This operator compares each binary digit of the first operand to the corresponding binary digit of the second operand. If both digits are 1, the digit in the resulting binary representation is 1, otherwise 0.

a = 5  # binary: 0101
b = 3  # binary: 0011

result = a & b  # binary: 0001 -> decimal: 1

print("Bitwise AND:", result)

Bitwise OR (|): This operator also compares each binary digit of the first operand to the corresponding binary digit of the second operand. If either of the digits is 1, the resulting binary digit is 1.

a = 5  # binary: 0101
b = 3  # binary: 0011

result = a | b  # binary: 0111 -> decimal: 7

print("Bitwise OR:", result)

Bitwise XOR (^): The XOR operator compares each bit of its first operand to the corresponding bit of its second operand. If one bit is 0 and the other bit is 1, the corresponding result bit is set to 1.

a = 5  # binary: 0101
b = 3  # binary: 0011

result = a ^ b  # binary: 0110 -> decimal: 6

print("Bitwise XOR:", result)

Bitwise NOT (~): This operator is a unary operator, meaning it works with a single operand. Bitwise NOT will invert the number's bit-wise representation. Note that because Python uses signed integers, the result will be the two's complement of the inverted bits.

a = 5   # binary: 0101

result = ~a  # binary: -0110 -> decimal: -6

print("Bitwise NOT:", result)

Left Shift (<<): The left shift operator shifts the bits of a number to the left by a specified number of positions. Each left shift doubles the number, as it is equivalent to multiplication by 2 to the power of the number of shifted positions.

a = 5  # binary: 0101

result = a << 1  # binary: 1010 -> decimal: 10

print("Left Shift:", result)

Right Shift (>>): The right shift operator shifts the bits of a number to the right by a specified number of positions. Each right shift halves the number, rounding down.

a = 5  # binary: 0101

result = a >> 1  # binary: 0010 -> decimal: 2

print("Right Shift:", result)

 

7. Identity Operators

Identity operators in Python are used to compare the memory locations of two objects. They help to check if two variables refer to the same object in memory. Below is a table that describes the identity operators, accompanied by Python code examples using small variable names (a and b) and the print() function to display the result.

 

Description and Use-cases

is Operator: The is operator checks whether both the operands refer to the same object (i.e., point to the same memory location). It's often used to test if a variable is None, although it can also be used for other objects like lists or dictionaries to ensure that two variables point to the same data structure.

a = None
print(a is None)  # Output will be True

is not Operator: The is not operator is essentially the opposite of the is operator. It checks whether two variables refer to different objects in memory. This is useful for ensuring that two variables don't share the same underlying data.

a = [1, 2, 3]
b = [1, 2, 3]
print(a is not b)  # Output will be True

Remember, is and is not operators should not be confused with == and != operators. The former compare the memory locations, whereas the latter compare the values.

 

8. Membership Operators

Membership operators are used to test whether a value is a member of a sequence such as a list, tuple, or string, or a collection like a dictionary. Below is a table explaining the membership operators in Python, with code examples using small variable names (a and b) and the print() statement to display the result.

 

Description and Use-cases

in Operator: The in operator is used to check if a value exists in a sequence or a collection. It's a quick way to check for the presence of a specific item.

# Using 'in' with a list
a = [1, 2, 3, 4, 5]
print(3 in a)  # Output will be True

# Using 'in' with a string
b = "Hello World"
print("World" in b)  # Output will be True

not in Operator: The not in operator is essentially the opposite of the in operator. It checks if a specified element is not present in a given sequence or collection.

# Using 'not in' with a list
a = [1, 2, 3, 4, 5]
print(6 not in a)  # Output will be True

# Using 'not in' with a string
b = "Hello World"
print("Python" not in b)  # Output will be True

 

Assignment Vs Augmented Assignment Operators

The fundamental difference between assignment operators and augmented assignment operators lies in their functionality and readability.

 

Assignment Operators:

Basic Function: Assignment operators are mainly used to assign values to variables.

a = 5
b = 10

Single Operation: Assignment operators perform just one function: they assign the value on the right-hand side to the variable on the left-hand side.

a = b  # 'a' now holds the value that 'b' holds, which is 10.

Multiple Steps for Operations: If you need to perform an operation (like addition, subtraction, etc.) and then assign the result to the variable, you have to do it in multiple steps or lines.

a = a + 2  # Increment 'a' by 2.

 

Augmented Assignment Operators:

Enhanced Function: Augmented assignment operators perform an operation in addition to assignment, effectively combining the two into a single action.

a += 2  # This is equivalent to a = a + 2

Conciseness: They allow for more concise code. Instead of writing a = a + 2, you can simply write a += 2.

Efficiency: Augmented assignment operators may be more efficient in some cases, as they can reduce the amount of typing and potentially perform the operation faster, although the speed difference is generally negligible for basic types.

Multiple Operations: They make it easier to perform complex calculations and reassignments in a single step.

a *= 3  # This is equivalent to a = a * 3

 

Operators precedence order in Python

Operator precedence in Python determines the order in which operators are evaluated when multiple operators are present in an expression. Operators with higher precedence are evaluated before operators with lower precedence.

Here is a list of operators in Python, sorted from highest precedence to lowest:

1. Parentheses (): Expressions inside parentheses are evaluated first.
2. Exponentiation **: Right-to-left associativity.
3. Complement, Unary Plus and Minus ~ + -: Unary operators.
4. Multiply, Divide, Floor Divide, and Modulus * / // %: Left-to-right associativity.
5. Addition and Subtraction + -: Left-to-right associativity.
6. Bitwise Right Shift and Left Shift >> <<: Left-to-right associativity.
7. Bitwise AND &: Left-to-right associativity.
8. Bitwise XOR ^: Left-to-right associativity.
9. Bitwise OR |: Left-to-right associativity.
10. Comparison Operators == != < <= > >=: Left-to-right associativity.
11. Identity Operators is is not: Left-to-right associativity.
12. Membership Operators in not in: Left-to-right associativity.
13. Logical NOT not: Right-to-left associativity.
14. Logical AND and: Left-to-right associativity.
15. Logical OR or: Left-to-right associativity.
16. Conditional Expression if else: Right-to-left associativity.
17. Assignment =: Right-to-left associativity.
18. Augmented Assignment += -= *= /= //= %= **= &= ^= |= <<= >>=: Right-to-left associativity.

 

When multiple operators have the same precedence, Python usually evaluates them from left to right (left-to-right associativity). The exception to this rule is the exponentiation operator (**), which has right-to-left associativity, meaning that operations are evaluated from right to left.

For example:

• With the expression 3 + 4 * 2, the multiplication (*) operator has higher precedence than addition (+), so 4 * 2 is evaluated first, resulting in 3 + 8 which is 11.
• In the expression 2 ** 3 ** 2, the ** operator is right associative, so 3 ** 2 is evaluated first, resulting in 2 ** 9 which is 512

 

Special Cases and Syntax

Python allows some operators to be used in unconventional ways. For example, you can use the * operator to repeat strings and lists.

print("A" * 5)  # Output: AAAAA
print([1, 2] * 2)  # Output: [1, 2, 1, 2]

While using operators, you should follow certain syntax rules, like putting them between operands (in infix notation), or ensuring that they are applied to compatible data types.

 

Chaining: Python allows you to chain multiple comparisons to perform a more complex test.

a = 5
print(2 < a < 10)  # Output: True

Chained comparisons also benefit from short-circuit behavior. This means that if one comparison fails, the remaining ones are not executed, which can improve performance.

 

Mixing Operators in Expressions: Python allows for mixing certain types of operators, but it's important to use parentheses to make the expression clear.

print(3 + 4 * 2 / (1 - 5))  # Output: 1.0

When mixing operators with different data types, Python will usually automatically convert the types to make them compatible, if possible.

print(3 + 4.0)  # Output: 7.0

 

Common Mistakes and Best Practices

Importance of Parentheses

Clarifying Ambiguity: Parentheses help in making the expression unambiguous. This is especially crucial when dealing with operators of different precedences.

# Avoid
print(3 + 4 * 2 - 1)  # Output: 10

# Best Practice
print((3 + 4) * (2 - 1))  # Output: 7

Parentheses can also make complex expressions more readable, even if they're not strictly necessary.

 

Floating-Point Arithmetic Caveats

Precision: Floating-point numbers do not always represent decimal numbers precisely, which can lead to errors in calculations.

# Avoid
print(0.1 + 0.2 == 0.3)  # Output: False

# Best Practice
print(abs(0.1 + 0.2 - 0.3) < 1e-9)  # Output: True

Integer Division: When dividing integers, use // for integer division and / for floating-point division to avoid unexpected results.

# Avoid
print(5 / 2)  # Output: 2.5

# Best Practice
print(5 // 2)  # Output: 2

 

Common Pitfalls with Assignment Operators

Immutable Reassignment: Be cautious when you are working with immutable types like tuples or strings. Reassignment will produce a new object instead of modifying the original one.

# Ineffective
a = "Hello"
a[0] = "h"  # Raises TypeError

# Effective
a = "hello"

Augmented Assignment: Remember that augmented assignment (+=, *= etc.) can behave differently for mutable and immutable objects.

# Mutable
a = [1, 2, 3]
b = a
a += [4, 5]
print(b)  # Output: [1, 2, 3, 4, 5]

# Immutable
a = 5
b = a
a += 2
print(b)  # Output: 5

Chaining Assignments: While Python allows for chained assignments like a = b = 1, be cautious when using this feature with mutable objects as it can lead to unexpected behavior.

# Risky
a = b = []
a.append(5)
print(b)  # Output: [5]

 

Practical Examples

How to use Arithmetic Operators in Math Calculations

Arithmetic operators come in handy for a wide range of math calculations. Here we are calculating Area and Perimeter:

# Calculate the area of a circle
radius = 5
area = 3.14159 * radius ** 2
print("Area:", area)

# Calculate the perimeter of a rectangle
length, width = 10, 5
perimeter = 2 * (length + width)
print("Perimeter:", perimeter)

 

Using Comparison Operators in Conditional Statements

Comparison operators are frequently used in conditional statements like if, elif, and else. Here we are determining the Largest Number:

a, b, c = 5, 15, 10

if a > b and a > c:
    print("a is the largest.")
elif b > a and b > c:
    print("b is the largest.")
else:
    print("c is the largest.")

 

Using Logical Operators in Decision Making

Logical operators can be used for making complex decisions. Here we are checking the eligibility for a Loan:

income = 50000
credit_score = 700
if income > 40000 and credit_score > 600:
    print("Loan approved.")
else:
    print("Loan denied.")

 

Real-world Scenarios where Bitwise Operators are Useful

Bitwise operators are particularly useful in low-level programming and bit manipulation:

Setting Flags

# Suppose 0b0100 represents a read flag and 0b0010 represents a write flag.
flags = 0b0100 | 0b0010  # Setting both read and write flags

Checking Flags

# Check if the write flag is set
if flags & 0b0010:
    print("Write flag is set.")

 

How Membership and Identity Operators Work in Data Structures like Lists, Sets, and Dictionaries

Membership and identity operators are quite useful when working with data structures:

Lists

items = [1, 2, 3, 4]
if 2 in items:
    print("Found in list.")

Sets

unique_items = {1, 2, 3, 4}
if 3 in unique_items:
    print("Found in set.")

Dictionaries

student_data = {'name': 'Alice', 'grade': 'A'}
if 'name' in student_data:
    print("Name is present.")

 

Summary

Python has seven different types of operators. Arithmetic operators, logic operators, assignment operators, augmented operators, bitwise operators, and two special kinds of operators; membership operator and identity operator. In this tutorial, we learned about each type of these operators by taking different examples.  Moreover, we also covered the precedence of these operators over each other.

 

Further Reading

Python operators
Augmented operators
More about python operators