Operators and Expressions in Python

# Pattern 1: Even or odd check
print(7 % 2)    # 1 → odd
print(8 % 2)    # 0 → even

# Pattern 2: Wrapping numbers (e.g. clock arithmetic)
hour = 14
print(hour % 12)    # 2 → "2 o'clock" in 12-hour format

# Pattern 3: Every Nth item (e.g. every 5th row gets highlighted)
for i in range(1, 11):
    if i % 5 == 0:
        print(f"Row {i} gets highlighted!")

Modulo is used constantly: pagination, cyclical patterns, divisibility checks, time conversion. Once you recognise it, you'll see it everywhere.

# Convert seconds to minutes and seconds
total_seconds = 275
minutes = total_seconds // 60    # 4
seconds = total_seconds % 60     # 35
print(f"{minutes}m {seconds}s")  # "4m 35s"

# Pagination: which page is item 47 on? (10 items per page)
item_index = 47
items_per_page = 10
page_number = (item_index // items_per_page) + 1
print(f"Item 47 is on page {page_number}")  # Page 5

// and % are a natural pair — they give you the quotient and the remainder from the same division.

# Area of a square
side = 7
area = side ** 2
print(f"Area: {area} sq units")  # 49

# Compound interest: A = P * (1 + r) ** n
principal  = 1000
rate       = 0.05    # 5%
years      = 10
amount     = principal * (1 + rate) ** years
print(f"After {years} years: £{amount:.2f}")  # £1628.89

# Kilobytes to bytes
kb = 64
bytes_ = kb * 2 ** 10
print(f"{kb}KB = {bytes_} bytes")  # 65536 bytes

print("apple" < "banana")   # True  — 'a' comes before 'b'
print("zebra" > "ant")      # True  — 'z' comes after 'a'
print("Apple" < "apple")    # True  — uppercase letters come first in Python!

# Equality check is case-sensitive
name = "Alice"
print(name == "alice")   # False — different case
print(name == "Alice")   # True

Python compares strings character by character using their Unicode value. Capital letters (A–Z) have lower values than lowercase (a–z), so "Apple" < "apple" is True. This matters for sorting names or usernames.

Most languages require you to write two separate conditions. Python lets you chain them like a maths expression:

age >= 13 and age <= 17

13 <= age <= 17

score = 75

# Check if score is in a grade band
print(90 <= score <= 100)  # False — not an A
print(70 <= score <= 89)   # True  — it's a B
print(0  <= score <= 100)  # True  — valid score range

# Very readable real-world use
temperature = 22
is_comfortable = 18 <= temperature <= 26
print(f"Comfortable temperature? {is_comfortable}")  # True

Python is lazy in a clever way: it stops evaluating as soon as the result is certain.

# With 'and': if the first part is False, Python skips the second
# (False and ANYTHING is always False)
x = 0
result = x != 0 and (10 / x) > 1   # Safe! Division never runs
print(result)  # False

# With 'or': if the first part is True, Python skips the second
# (True or ANYTHING is always True)
name = "Alice"
result = name != "" or some_expensive_function()  # Second part skipped
print(result)  # True

This isn't just trivia — it's a common technique to prevent crashes. Check that a value is safe before using it, using and.

When mixing logical operators, priority order is: not → and → or. Use parentheses to be explicit:

age = 20
has_ticket = True
is_vip = False

# Without parentheses — can be confusing:
result = age >= 18 and has_ticket or is_vip

# With parentheses — crystal clear intent:
result = (age >= 18 and has_ticket) or is_vip
print(result)  # True

# 'not' flips an entire condition:
is_banned = False
can_enter = has_ticket and not is_banned
print(can_enter)  # True

Incrementing a number by 1 each time something happens is called a counter. It's one of the most common patterns in programming:

login_attempts = 0
errors = 0
words_typed = 0

# Each time something happens:
login_attempts += 1   # user tried to log in
errors += 1           # an error occurred
words_typed += 1      # user typed a word

print(f"Login attempts: {login_attempts}")
print(f"Errors: {errors}")

# Decrement works too:
lives = 3
lives -= 1   # player lost a life
print(f"Lives remaining: {lives}")

Adding values to a running total is called an accumulator. This is how shopping carts, bank balances, and totals work:

# Shopping cart total
cart_total = 0.0

cart_total += 29.99   # Added Python Book
cart_total += 9.99    # Added USB Cable
cart_total += 14.50   # Added Notebook

print(f"Cart total: £{cart_total:.2f}")  # £54.48

# Apply discount
discount_percent = 10
cart_total *= (1 - discount_percent / 100)
print(f"After {discount_percent}% off: £{cart_total:.2f}")  # £49.03

+= works on strings too — it appends text to an existing string:

# Building a message piece by piece
message = "Hello"
message += ", "
message += "welcome to "
message += "Python!"
print(message)   # "Hello, welcome to Python!"

# Practical: building a CSV row
row = ""
row += "Alice"
row += ","
row += "25"
row += ","
row += "London"
print(row)   # "Alice,25,London"

In large programs, f-strings are usually better for complex string construction — but += is handy when you're building a string incrementally over time.

When you see a long expression, break it down by precedence:

# What does this evaluate to?
result = 2 + 3 ** 2 * 4 - 1

# Step 1: Exponents first   → 3 ** 2 = 9
# Step 2: Multiplication    → 9 * 4  = 36
# Step 3: Left to right add/sub → 2 + 36 - 1 = 37
print(result)  # 37

# With parentheses to match intent:
discount = 100
tax_rate = 0.20
base_price = 50
final = (base_price - discount * 0.1) * (1 + tax_rate)
# Step 1: discount * 0.1 = 10
# Step 2: base_price - 10 = 40
# Step 3: 1 + tax_rate = 1.20
# Step 4: 40 * 1.20 = 48.0
print(f"Final price: £{final:.2f}")

email = "user@example.com"

# Check it has an @ sign and a dot
has_at   = "@" in email
has_dot  = "." in email
looks_valid = has_at and has_dot
print(f"Looks like a valid email: {looks_valid}")  # True

# Check for forbidden words
comment = "This is a great tutorial!"
banned_words = ["spam", "scam", "hack"]
is_clean = not any(word in comment for word in banned_words)
print(f"Comment is clean: {is_clean}")  # True

# Input validation — only allow specific options
valid_sizes   = ["small", "medium", "large"]
valid_colours = ["red", "green", "blue", "black", "white"]

chosen_size   = "medium"
chosen_colour = "purple"

if chosen_size not in valid_sizes:
    print(f"Invalid size: {chosen_size}")

if chosen_colour not in valid_colours:
    print(f"Sorry, we don't stock {chosen_colour}")
# Output: "Sorry, we don't stock purple"

# Days of the week check
weekdays = ["Monday","Tuesday","Wednesday","Thursday","Friday"]
weekend  = ["Saturday","Sunday"]
today    = "Saturday"

is_workday = today in weekdays
print(f"Is {today} a work day? {is_workday}")  # False

This pattern is everywhere: checking file extensions, validating user choices, filtering allowed commands, verifying roles and permissions.