Python Operators Explained — Types, Examples and Common Mistakes

# ─── Arithmetic Operators in Python ───────────────────────────────────────
# Let's use a real-world scenario: calculating an order total at a bakery.

items_ordered = 7       # Number of croissants ordered
price_per_item = 3.50   # Price in dollars

# Addition: total cost before any extras
subtotal = items_ordered + 2.00  # Adding a $2 bag fee
print("Subtotal with bag fee:", subtotal)  # 9.5

# Subtraction: applying a discount
discount = 1.50
price_after_discount = subtotal - discount
print("After discount:", price_after_discount)  # 8.0

# Multiplication: total cost for the original order
total_cost = items_ordered * price_per_item
print("Total cost:", total_cost)  # 24.5

# Division: splitting the bill evenly among friends
num_friends = 2
cost_per_person = total_cost / num_friends
print("Cost per person:", cost_per_person)  # 12.25

# Floor Division: how many whole boxes of 3 can we fill?
boxes_of_three = items_ordered // 3
print("Full boxes of 3:", boxes_of_three)  # 2  (7 // 3 = 2, ignores remainder)

# Modulus: how many croissants are left over after boxing?
leftover_croissants = items_ordered % 3
print("Leftover croissants:", leftover_croissants)  # 1  (7 % 3 = 1)

# Exponentiation: calculate 2 to the power of 8 (useful in computing)
byte_combinations = 2 ** 8
print("Possible values in one byte:", byte_combinations)  # 256

# ─── Comparison and Logical Operators ─────────────────────────────────────
# Scenario: A simple age-gate for a website with a premium tier.

user_age = 22
user_is_subscriber = True
minimum_age = 18
subscription_price = 9.99
account_balance = 15.00

# ── Comparison Operators ──────────────────────────────────────────────────

# == checks equality (note: NOT a single = which would assign a value)
print(user_age == 22)        # True  — age IS 22
print(user_age == 30)        # False — age is NOT 30

# != checks inequality
print(user_age != 30)        # True  — 22 is not 30

# > and < check magnitude
print(user_age > minimum_age)   # True  — 22 is greater than 18
print(user_age < minimum_age)   # False — 22 is not less than 18

# >= and <= include the boundary value
print(user_age >= 22)        # True  — 22 is equal to 22, so >= is satisfied
print(user_age <= 21)        # False — 22 is not less than or equal to 21

# ── Logical Operators ─────────────────────────────────────────────────────

# AND: BOTH conditions must be True
can_access_premium = user_age >= minimum_age and user_is_subscriber
print("Can access premium:", can_access_premium)  # True (22>=18 AND subscriber)

# OR: AT LEAST ONE condition must be True
can_afford_subscription = account_balance >= subscription_price or user_is_subscriber
print("Can afford subscription:", can_afford_subscription)  # True

# NOT: flips the boolean — True becomes False, False becomes True
print("Is a guest user:", not user_is_subscriber)  # False (they ARE a subscriber)

# Combining all three for a real access check
user_is_banned = False
full_access = (user_age >= minimum_age) and user_is_subscriber and (not user_is_banned)
print("Full access granted:", full_access)  # True

# ─── Assignment Operators ─────────────────────────────────────────────────
# Scenario: Tracking a player's score in a simple game loop.

player_score = 0         # Basic assignment: store 0 in player_score
player_lives = 3
boss_health = 100

# += adds the right value to the variable and saves the result
player_score += 50       # Player collected a coin: score is now 50
player_score += 100      # Player defeated an enemy: score is now 150
print("Score after two events:", player_score)  # 150

# -= subtracts from the variable
player_lives -= 1        # Player hit a spike: lives drop from 3 to 2
print("Lives remaining:", player_lives)  # 2

# *= multiplies the variable by a value
player_score *= 2        # Double score power-up activated!
print("Score after double power-up:", player_score)  # 300

# /= divides the variable (result is always a float)
boss_health /= 2         # Boss hit by a special attack — half health
print("Boss health:", boss_health)  # 50.0  ← notice the .0, it becomes a float

# //= floor-divides the variable (result stays a whole number)
boss_health = 100        # Reset boss health for demo
boss_health //= 3        # Each hit removes a third (rounded down)
print("Boss health after floor division:", boss_health)  # 33

# %= stores the remainder
ammo_count = 17
shots_per_clip = 5
remainder_in_clip = ammo_count % 5  # How many bullets are in the partial clip?
ammo_count %= 5          # ammo_count now holds only the leftover
print("Bullets in partial clip:", ammo_count)  # 2

# **= raises the variable to a power
base_damage = 2
base_damage **= 4        # Damage scales exponentially: 2^4
print("Scaled damage:", base_damage)  # 16

# ─── Identity, Membership, and Bitwise Operators ──────────────────────────

# ── IDENTITY OPERATORS: is, is not ───────────────────────────────────────
# 'is' checks if two names point to the SAME object in memory
# '==' checks if two objects have the SAME VALUE

response_data = None

# The correct way to check for None is always 'is', not '=='
if response_data is None:
    print("No data received from the server.")  # This prints

# Demonstrating the difference between 'is' and '=='
list_a = [1, 2, 3]
list_b = [1, 2, 3]   # Same values, but a brand-new list object in memory
list_c = list_a      # list_c points to the SAME object as list_a

print(list_a == list_b)   # True  — values are identical
print(list_a is list_b)   # False — they are different objects in memory
print(list_a is list_c)   # True  — both names point to the same object

# ── MEMBERSHIP OPERATORS: in, not in ─────────────────────────────────────
# Check if a value exists inside a collection

allowed_file_types = ['jpg', 'png', 'gif', 'webp']
uploaded_extension = 'pdf'

if uploaded_extension not in allowed_file_types:
    print(f".{uploaded_extension} files are not allowed.")  # This prints

welcome_message = "Welcome to TheCodeForge!"
if "CodeForge" in welcome_message:
    print("Brand name found in message.")  # This prints

# ── BITWISE OPERATORS ─────────────────────────────────────────────────────
# These operate on binary representations of integers.
# Practical use: combining permission flags (like Linux file permissions)

READ_PERMISSION    = 0b100   # Binary 4:  the 'read' bit is ON
WRITE_PERMISSION   = 0b010   # Binary 2:  the 'write' bit is ON
EXECUTE_PERMISSION = 0b001   # Binary 1:  the 'execute' bit is ON

# & (AND): both bits must be 1 — used to CHECK if a permission is set
# | (OR):  at least one bit is 1 — used to COMBINE permissions
# ~ (NOT): flips all bits
# ^ (XOR): bits differ — used to TOGGLE a permission
# << (left shift): multiply by powers of 2
# >> (right shift): divide by powers of 2

# Grant read and write permissions using OR
user_permissions = READ_PERMISSION | WRITE_PERMISSION
print("User permissions (binary):", bin(user_permissions))  # 0b110  (decimal 6)

# Check if user has WRITE permission using AND
has_write = user_permissions & WRITE_PERMISSION
print("Has write access:", bool(has_write))  # True

# Check if user has EXECUTE permission
has_execute = user_permissions & EXECUTE_PERMISSION
print("Has execute access:", bool(has_execute))  # False

# Left shift: quick multiply by 2
base_value = 3
print("3 left-shifted by 2:", base_value << 2)   # 12  (3 * 4)

# Right shift: quick divide by 2
print("12 right-shifted by 2:", 12 >> 2)          # 3   (12 / 4)