Python Operators: The `is` vs `==` Gotcha That Costs $5000

# ─── 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)

# ─── Operator Precedence and Associativity ────────────────────────────────

# Example 1: Arithmetic precedence
result_1 = 2 + 3 * 4
print("2 + 3 * 4 =", result_1)  # 14 (NOT 20)

result_2 = (2 + 3) * 4
print("(2 + 3) * 4 =", result_2)  # 20

# Example 2: Comparison vs arithmetic
result_3 = 3 + 4 > 2 * 3
print("3 + 4 > 2 * 3 =", result_3)  # True (7 > 6)

# Example 3: Logical precedence
result_4 = not True or True and False
print("not True or True and False =", result_4)  # False
# Equivalent to: (not True) or (True and False) = False or False = False

result_5 = (not True) or (True and False)
print("Same with parentheses:", result_5)  # False

# Without parentheses, it's easy to misread:
# Suppose you wanted: not (True or True) and False
result_6 = not (True or True) and False
print("not (True or True) and False =", result_6)  # False (and False anyway)

# Example 4: Right-associative exponentiation
result_7 = 2 ** 3 ** 2
print("2 ** 3 ** 2 =", result_7)  # 512  (2**(3**2) = 2**9)

result_8 = (2 ** 3) ** 2
print("(2 ** 3) ** 2 =", result_8)  # 64  (8**2)

# Example 5: Assignment is right-associative
a = b = c = 5
print("a =", a, "b =", b, "c =", c)  # All 5: a = (b = (c = 5))

# Example 6: Common real-world mistake
hours = 8
rate = 15
# You want: (hours * rate) * 1.1 with 10% bonus
# But what if you forget parentheses?
total = hours * rate + 0.1
print("Wrong total:", total)  # 120.1 (because + has lower precedence)
total_correct = hours * rate + (hours * rate * 0.1)
print("Correct total:", total_correct)  # 132.0