Why Python Eliminates More Candidates Than They Expect

grid = [[0] * 3] * 3
grid[0][0] = 9
print(grid)
# [[9, 0, 0], [9, 0, 0], [9, 0, 0]]  - all rows changed!

print(grid[0] is grid[1])  # True - same object

# Correct: build a new inner list each time
grid = [[0] * 3 for _ in range(3)]
grid[0][0] = 9
print(grid)
# [[9, 0, 0], [0, 0, 0], [0, 0, 0]]

# Why [0] * 3 is fine but [[0]] * 3 is not:
# integers are immutable, so sharing them is harmless.
# Lists are mutable, so sharing them shares changes.

import copy

teams = [["Asha", "Ravi"], ["Meena"]]

shallow = copy.copy(teams)
deep = copy.deepcopy(teams)

teams[0].append("Karan")

print(shallow[0])  # ['Asha', 'Ravi', 'Karan'] - inner list shared
print(deep[0])     # ['Asha', 'Ravi']          - fully independent

# Spoken: "A shallow copy makes a new outer list but
# keeps references to the same inner lists. A deep copy
# copies every level."

nums = [2, 4, 5, 6, 8]
for n in nums:
    if n % 2 == 0:
        nums.remove(n)
print(nums)
# [4, 5, 8]  - expected [5]

# What happened:
# index 0: 2 removed -> list is [4, 5, 6, 8], loop moves to index 1 (5)
# index 1: 5 kept
# index 2: 6 removed -> list is [4, 5, 8], loop moves to index 3
# index 3: does not exist -> loop ends
# 4 and 8 were never checked.

nums = [2, 4, 5, 6, 8]

# 1. Comprehension (most Pythonic)
odds = [n for n in nums if n % 2 != 0]
print(odds)  # [5]

# 2. In place, if other code holds a reference to nums
nums[:] = [n for n in nums if n % 2 != 0]

# 3. Dicts: iterate over a snapshot of the keys
stock = {"pen": 0, "book": 3, "bag": 0}
for item in list(stock):
    if stock[item] == 0:
        del stock[item]
print(stock)  # {'book': 3}

import time

n = 20_000
seen_list = list(range(n))
seen_set = set(seen_list)
queries = range(n)

start = time.perf_counter()
hits = sum(1 for q in queries if q in seen_list)   # list scan each time
print("list:", round(time.perf_counter() - start, 3), "s")

start = time.perf_counter()
hits = sum(1 for q in queries if q in seen_set)    # hash lookup
print("set: ", round(time.perf_counter() - start, 3), "s")

# Run it yourself: the set version is dramatically faster,
# and the gap grows as n grows.

Q: Find all numbers that appear in both lists.

First version (say it, then improve it):
  common = [x for x in a if x in b]
  "This is O(len(a) * len(b)) because 'in b' scans b."

Improved:
  b_set = set(b)
  common = [x for x in a if x in b_set]
  "Building the set is O(len(b)), each lookup is O(1)
  on average, so total is O(len(a) + len(b)).
  This keeps a's order and duplicates. If I only need
  unique values, set(a) & set(b) is simpler."

PREDICT, THEN RUN

1.  a = [1, 2]; b = a; b.append(3); print(a)
2.  grid = [[""] * 2] * 2; grid[1][0] = "x"; print(grid)
3.  d = dict.fromkeys(["a", "b"], []); d["a"].append(1); print(d)
4.  nums = [1, 1, 2, 3]
    for n in nums:
        if n == 1: nums.remove(n)
    print(nums)
5.  t = (1, [2, 3]); t[1].append(4); print(t)

Answers:
1. [1, 2, 3]
2. [['x', ''], ['x', '']]
3. {'a': [1], 'b': [1]}
4. [1, 2, 3]
5. (1, [2, 3, 4])  - tuple cannot change, its list can

COST CHECK (say the Big-O aloud)

[ ] x in a list           -> ____
[ ] x in a set            -> ____
[ ] list.append(x)        -> ____
[ ] list.insert(0, x)     -> ____
[ ] deque.appendleft(x)   -> ____
[ ] dict[key]             -> ____
[ ] sorted(list)          -> ____
[ ] ''.join(list_of_str)  -> ____

Then review one of your old solutions and mark
every line that runs inside a loop.

EDGE-CASE SWEEP (for every solution)

Test with:
[ ] empty input  ([], "", {})
[ ] a single item
[ ] all items the same
[ ] negative numbers or zero
[ ] very large input (mentally: what is the cost?)
[ ] None where a value is expected

Say aloud: "For an empty list my function returns ___
because ___." If you cannot finish the sentence,
the edge case is not handled yet.