Operators in Python

What Is It?

What Are Operators in Python?

An operator is a special symbol that tells Python to perform a specific operation on one or more values. Think of operators as verbs in a sentence. Just as the verb "add" tells you to combine two numbers, the + operator tells Python to add two values together.

You have already used operators without realizing it. When you wrote print(2 + 3) in earlier chapters, the + symbol was an arithmetic operator. When you stored a value with age = 14, the = symbol was an assignment operator.

What Are Operands?

The values that operators work on are called operands. In the expression 5 + 3, the numbers 5 and 3 are operands, and + is the operator. Some operators need two operands (called binary operators, like +), while others need only one (called unary operators, like not or - when used to negate a number).

Python provides seven categories of operators, and this chapter covers each one in detail: Arithmetic, Comparison, Logical, Assignment, Membership, Identity, and Bitwise operators.

Why Does It Matter?

Why Are Operators Important?

Operators are the building blocks of every computation your program performs. Without operators, your code could store values but never do anything meaningful with them. Here is why understanding operators thoroughly matters:

1. Every Calculation Uses Operators

Whether you are building a calculator, computing a student's grade percentage, or calculating the area of a rectangle, you need arithmetic operators. Even simple tasks like counting how many items are in a shopping cart or splitting a bill among friends require operators.

2. Decision-Making Depends on Comparison and Logical Operators

When your program needs to make decisions ("Is the user old enough to sign up?", "Did the student pass the exam?"), it uses comparison operators (>=, ==, !=) and logical operators (and, or, not). You will use these constantly when you learn conditional statements in the next chapters.

3. Operator Precedence Prevents Bugs

If you do not understand the order in which Python evaluates operators, your calculations will give wrong results. The expression 2 + 3 * 4 gives 14 (not 20), because multiplication happens before addition. Knowing operator precedence is the difference between writing correct programs and spending hours debugging wrong answers.

4. Writing Shorter, Cleaner Code

Assignment operators like += and *= let you update variables in a compact way. Membership operators like in let you check if something exists in a collection with a single readable expression. These make your code shorter and easier to understand.

Detailed Explanation

Detailed Explanation

1. Arithmetic Operators

Arithmetic operators perform mathematical calculations on numbers (integers and floats). Python provides seven arithmetic operators:

Division vs Floor Division

This is one of the most commonly confused concepts. The / operator always returns a float, even if the result is a whole number. So 10 / 2 gives 5.0, not 5. The // operator performs floor division, which means it divides and then rounds DOWN to the nearest integer. For positive numbers, this is the same as removing the decimal part: 10 // 3 gives 3 (not 3.33).

For negative numbers, floor division rounds towards negative infinity: -10 // 3 gives -4 (not -3), because -4 is the nearest integer less than -3.33. This catches many students off guard.

The Modulus Operator (%)

The modulus operator returns the remainder after division. For example, 10 % 3 gives 1 because 10 divided by 3 is 3 with a remainder of 1. This operator is extremely useful for: checking if a number is even or odd (n % 2 == 0 means even), checking divisibility (n % 5 == 0 means divisible by 5), and wrapping values around a range.

2. Comparison Operators

Comparison operators compare two values and return a Boolean result (True or False). They are essential for making decisions in your programs.

Important: == vs =

A very common mistake is confusing = (assignment) with == (comparison). The single equals sign = assigns a value to a variable: x = 5 stores 5 in x. The double equals sign == compares two values: x == 5 checks whether x is equal to 5 and returns True or False.

Chaining Comparisons

Python allows you to chain comparison operators in a way that matches mathematical notation. Instead of writing x > 1 and x < 10, you can write 1 < x < 10. This reads naturally as "x is between 1 and 10" and is one of Python's elegant features.

3. Logical Operators

Logical operators combine multiple Boolean expressions. Python has three logical operators:

Truth Tables

A truth table shows every possible combination of inputs and the resulting output:

AND truth table: True and True = True, True and False = False, False and True = False, False and False = False. The and operator returns True only when BOTH sides are True.

OR truth table: True or True = True, True or False = True, False or True = True, False or False = False. The or operator returns False only when BOTH sides are False.

Short-Circuit Evaluation

Python uses short-circuit evaluation with logical operators. With and, if the left side is False, Python does not even check the right side (because the result will be False regardless). With or, if the left side is True, Python skips the right side (because the result will be True regardless). This is not just an optimization; it can affect your program if the right side has side effects like function calls.

4. Assignment Operators

Assignment operators store values in variables. The basic assignment operator is =, but Python also provides compound assignment operators that combine an arithmetic operation with assignment:

Compound assignment operators are just a shorthand. Writing score += 10 is identical to writing score = score + 10. They make code shorter and more readable, especially when updating variables in loops.

5. Membership Operators

Membership operators check whether a value exists inside a sequence (like a string, list, or tuple). Python has two membership operators:

Membership operators are extremely readable. The expression "Python" in languages reads almost like plain English: "Is Python in the languages list?" You will use these frequently when working with strings and lists.

6. Identity Operators

Identity operators check whether two variables refer to the exact same object in memory, not just whether they have the same value. Python has two identity operators:

== vs is

This is a subtle but important distinction. The == operator checks if two values are equal. The is operator checks if two variables refer to the same object in memory. Two variables can have equal values but be different objects. For example, two different lists [1, 2, 3] and [1, 2, 3] are equal (== returns True) but they are separate objects in memory (is returns False).

The most common use of is is checking for None: you should always write if x is None rather than if x == None. This is a Python best practice.

7. Bitwise Operators

Bitwise operators work on the binary (base-2) representation of numbers, manipulating individual bits. While you may not use these daily as a beginner, understanding them gives you deeper knowledge of how computers work.

Let us trace through 5 & 3: In binary, 5 is 101 and 3 is 011. The AND operation compares each bit position: 1 AND 0 = 0, 0 AND 1 = 0, 1 AND 1 = 1. The result is 001, which is 1 in decimal.

Left shift (<<) moves all bits to the left by the specified number of positions, which is equivalent to multiplying by 2 for each shift. So 5 << 1 is 5 * 2 = 10. Right shift (>>) moves bits to the right, equivalent to integer division by 2.

8. Operator Precedence (PEMDAS)

When an expression contains multiple operators, Python follows a strict order of priority called operator precedence. This is similar to the PEMDAS rule you learn in mathematics (Parentheses, Exponents, Multiplication/Division, Addition/Subtraction), but Python extends it to include all its operators.

Here is the precedence from highest (evaluated first) to lowest (evaluated last):

1. Parentheses () — always evaluated first
2. Exponentiation **
3. Unary operators +x, -x, ~x
4. Multiplication, Division, Floor Division, Modulus *, /, //, %
5. Addition, Subtraction +, -
6. Bitwise Shifts <<, >>
7. Bitwise AND &
8. Bitwise XOR ^
9. Bitwise OR |
10. Comparison operators ==, !=, >, <, >=, <=, is, is not, in, not in
11. Logical NOT not
12. Logical AND and
13. Logical OR or

Key Rules to Remember

Rule 1: Parentheses override everything. When in doubt, use parentheses to make your intent clear.

Rule 2: Exponentiation (**) is right-associative. This means 2 ** 3 ** 2 is evaluated as 2 ** (3 ** 2) = 2 ** 9 = 512, NOT as (2 ** 3) ** 2 = 8 ** 2 = 64.

Rule 3: Among operators at the same precedence level, evaluation happens left to right (left-associative), except for exponentiation which is right-associative.

Rule 4: not has higher precedence than and, which has higher precedence than or. So True or False and not False evaluates as True or (False and (not False)) = True or (False and True) = True or False = True.

Code Examples

a = 15
b = 4

print("Addition:", a + b)
print("Subtraction:", a - b)
print("Multiplication:", a * b)
print("Division:", a / b)
print("Floor Division:", a // b)
print("Modulus:", a % b)
print("Exponentiation:", a ** b)

print("10 / 3 =", 10 / 3)
print("10 // 3 =", 10 // 3)
print()
print("-10 / 3 =", -10 / 3)
print("-10 // 3 =", -10 // 3)
print()
print("10 / -3 =", 10 / -3)
print("10 // -3 =", 10 // -3)

marks = 78

print("Is marks equal to 78?", marks == 78)
print("Is marks not equal to 100?", marks != 100)
print("Is marks greater than 50?", marks > 50)
print("Is marks less than 40?", marks < 40)
print("Is marks >= 75?", marks >= 75)
print("Is marks <= 80?", marks <= 80)

# Chaining comparisons
print("Is marks between 60 and 90?", 60 <= marks <= 90)

age = 15
has_id = True

# AND - both must be True
can_enter = age >= 13 and has_id
print("Can enter (age >= 13 AND has ID)?", can_enter)

# OR - at least one must be True
is_weekend = False
is_holiday = True
no_school = is_weekend or is_holiday
print("No school (weekend OR holiday)?", no_school)

# NOT - reverses the value
is_raining = False
can_play_outside = not is_raining
print("Can play outside (NOT raining)?", can_play_outside)

# Combining all three
can_go_trip = (age >= 12 and has_id) or not is_raining
print("Can go on trip?", can_go_trip)

score = 100
print("Starting score:", score)

score += 25       # score = score + 25
print("After +25:", score)

score -= 10       # score = score - 10
print("After -10:", score)

score *= 2        # score = score * 2
print("After *2:", score)

score //= 3       # score = score // 3
print("After //3:", score)

score %= 10       # score = score % 10
print("After %10:", score)

score **= 3       # score = score ** 3
print("After **3:", score)

# Membership operators
name = "Ananya"
print("Is 'A' in name?", "A" in name)
print("Is 'z' in name?", "z" in name)
print("Is 'z' NOT in name?", "z" not in name)

fruits = ["apple", "mango", "banana"]
print("Is 'mango' in fruits?", "mango" in fruits)
print("Is 'grape' in fruits?", "grape" in fruits)

# Identity operators
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print("\na == b?", a == b)     # Same value?
print("a is b?", a is b)     # Same object?
print("a is c?", a is c)     # Same object?

print("\nChecking None:")
x = None
print("x is None?", x is None)

# Example 1: Multiplication before addition
result1 = 2 + 3 * 4
print("2 + 3 * 4 =", result1)  # 14, not 20

# Example 2: Parentheses override precedence
result2 = (2 + 3) * 4
print("(2 + 3) * 4 =", result2)  # 20

# Example 3: Exponentiation is right-associative
result3 = 2 ** 3 ** 2
print("2 ** 3 ** 2 =", result3)  # 512, not 64

# Example 4: Mixed operators
result4 = 10 + 2 * 3 ** 2 - 4 // 2
print("10 + 2 * 3 ** 2 - 4 // 2 =", result4)
# Step by step: 3**2=9, 2*9=18, 4//2=2, 10+18-2=26

# Example 5: Logical operator precedence
result5 = True or False and False
print("True or False and False =", result5)
# and is evaluated before or: True or (False and False) = True or False = True

a = 5   # binary: 101
b = 3   # binary: 011

print("a & b =", a & b)     # AND:  101 & 011 = 001 = 1
print("a | b =", a | b)     # OR:   101 | 011 = 111 = 7
print("a ^ b =", a ^ b)     # XOR:  101 ^ 011 = 110 = 6
print("~a =", ~a)           # NOT:  ~5 = -6
print("a << 1 =", a << 1)   # Left shift: 101 -> 1010 = 10
print("a >> 1 =", a >> 1)   # Right shift: 101 -> 10 = 2

# Practical: Check if a number is even using bitwise AND
num = 14
if num & 1 == 0:
    print(num, "is even")
else:
    print(num, "is odd")

Common Mistakes

age = 18
if age = 18:
    print("You are 18")

age = 18
if age == 18:
    print("You are 18")

total = 10
students = 4
each_gets = total / students
print("Each student gets", each_gets, "chocolates")

total = 10
students = 4
each_gets = total // students
print("Each student gets", each_gets, "chocolates")

result = -7 // 2
print(result)  # Expecting -3

# Floor division rounds TOWARD negative infinity
result = -7 // 2   # -3.5 rounded down = -4
print(result)       # Output: -4

# If you want to truncate toward zero, use int()
result = int(-7 / 2)  # int(-3.5) = -3
print(result)          # Output: -3

# Rohan wants to calculate average of 3 numbers
average = 80 + 75 + 90 / 3
print("Average:", average)  # Expecting 81.67

average = (80 + 75 + 90) / 3
print("Average:", average)  # Correct: 81.666...

a = 1000
b = 1000
print(a is b)  # Might print False!

a = 1000
b = 1000
print(a == b)  # Always True for equal values

Summary