Common Python Mistakes Every Beginner Makes (And How to Fix Them)

# ============================================================
# WRONG VERSION — using a mutable list as a default argument
# ============================================================
def add_to_cart_broken(item, cart=[]):
    # Python creates this [] ONCE when the function is defined
    # Every call that omits 'cart' shares the SAME list object
    cart.append(item)     # We're modifying the one shared list
    return cart

print("--- Broken version ---")
first_order = add_to_cart_broken("apple")
print(f"First order: {first_order}")   # Looks fine so far

second_order = add_to_cart_broken("banana")
print(f"Second order: {second_order}")  # Wait — why is apple here?!

print(f"First order now: {first_order}")  # Even first_order changed!


# ============================================================
# CORRECT VERSION — use None as the sentinel, build inside
# ============================================================
def add_to_cart(item, cart=None):
    # None signals "no cart was provided" — a safe, immutable default
    if cart is None:
        cart = []         # Create a BRAND NEW list for this call only
    cart.append(item)
    return cart

print("\n--- Fixed version ---")
first_order = add_to_cart("apple")
print(f"First order: {first_order}")    # ['apple']

second_order = add_to_cart("banana")
print(f"Second order: {second_order}")  # ['banana'] — clean!

print(f"First order still: {first_order}")  # ['apple'] — untouched

# ============================================================
# Demonstrating == (equality) vs is (identity)
# ============================================================

# --- Lists: same contents, different objects ---
shopping_list_a = ["milk", "eggs", "bread"]
shopping_list_b = ["milk", "eggs", "bread"]

print("--- List comparison ---")
print(shopping_list_a == shopping_list_b)  # True  — same CONTENTS
print(shopping_list_a is shopping_list_b)  # False — different OBJECTS in memory

# --- Integers: Python's small integer cache can mislead you ---
small_number_a = 42
small_number_b = 42
print("\n--- Small integer (cached by Python) ---")
print(small_number_a == small_number_b)  # True
print(small_number_a is small_number_b)  # True — only because Python CACHES -5 to 256

big_number_a = 10000
big_number_b = 10000
print("\n--- Large integer (NOT cached) ---")
print(big_number_a == big_number_b)  # True
print(big_number_a is big_number_b)  # False — now they ARE different objects!

# --- The correct pattern: use 'is' ONLY for None checks ---
user_input = None

if user_input is None:          # CORRECT — this is the right use of 'is'
    print("\nNo input received — please enter a value")

if user_input == None:          # WORKS but considered bad style in Python
    print("This also works, but PEP8 prefers 'is None'")

# --- String comparison: never use 'is' for strings you build ---
first_name = "Alice"
search_term = "".join(["Al", "ice"])  # Built at runtime

print("\n--- Runtime string comparison ---")
print(first_name == search_term)  # True  — values match
print(first_name is search_term)  # False — different objects (usually)

# ============================================================
# WRONG — removing items from a list while looping over it
# ============================================================
temperature_readings = [22, -5, 30, -1, 18, -8, 25]
print(f"Original readings: {temperature_readings}")

for reading in temperature_readings:
    if reading < 0:  # Try to remove all negative (faulty) readings
        temperature_readings.remove(reading)  # This shifts the list!

# Notice -1 survived! It slid into the slot where -5 was removed,
# and Python's iterator had already moved past that index.
print(f"After (broken) cleanup: {temperature_readings}")
print("Notice -1 was NOT removed — it slipped through!")


# ============================================================
# CORRECT approach 1 — iterate over a COPY of the list
# ============================================================
temperature_readings = [22, -5, 30, -1, 18, -8, 25]  # Reset

for reading in temperature_readings[:]:   # [:] creates a shallow copy
    if reading < 0:
        temperature_readings.remove(reading)  # Safe — we're iterating the copy

print(f"\nAfter (copy) cleanup: {temperature_readings}")


# ============================================================
# CORRECT approach 2 — list comprehension (cleanest, most Pythonic)
# ============================================================
temperature_readings = [22, -5, 30, -1, 18, -8, 25]  # Reset

# Build a NEW list containing only valid readings
valid_readings = [r for r in temperature_readings if r >= 0]

print(f"Valid readings (list comprehension): {valid_readings}")
# This is the preferred approach — readable, safe, and efficient

import copy  # Python's built-in module for copying objects

# ============================================================
# MISTAKE 1 — assignment is NOT a copy
# ============================================================
original_scores = [95, 87, 76, 88]
aliased_scores = original_scores  # This is NOT a copy — same object!

aliased_scores.append(100)  # Modifying through the alias...
print(f"Original (should be unchanged): {original_scores}")
# Surprise — original changed too!


# ============================================================
# SHALLOW COPY — fine for flat structures
# ============================================================
original_scores = [95, 87, 76, 88]  # Reset
shallow_copy = original_scores[:]   # Creates a new list...

shallow_copy.append(100)             # This only affects shallow_copy
print(f"\nOriginal after shallow copy append: {original_scores}")
print(f"Shallow copy: {shallow_copy}")


# ============================================================
# WHERE SHALLOW COPY FAILS — nested lists
# ============================================================
classroom_grades = [[90, 85, 88], [72, 78, 80], [95, 91, 93]]
shallow_classroom = classroom_grades[:]  # Shallow copy of outer list

# Modifying a nested list through the copy...
shallow_classroom[0].append(99)  # This changes the SHARED inner list!

print(f"\nOriginal classroom (should be unchanged):")
print(classroom_grades)  # The inner list changed — shallow copy problem!


# ============================================================
# DEEP COPY — full independence at every level
# ============================================================
classroom_grades = [[90, 85, 88], [72, 78, 80], [95, 91, 93]]  # Reset
deep_classroom = copy.deepcopy(classroom_grades)  # Copies everything recursively

deep_classroom[0].append(99)  # Modifying the deep copy's inner list

print(f"\nOriginal after deep copy modification:")
print(classroom_grades)   # Unchanged!
print(f"Deep copy:")
print(deep_classroom)     # Only the copy changed