← Data Structures (list, tuple, set, dict)

Select a question from the sidebar

20 questions in this topic

Question 1 / 20

What are lists in Python and what are the most common list operations?

A list is a mutable, ordered sequence that can hold items of any type. Lists are the most versatile data structure in Python.

Creation: [], list(), list comprehension

Key operations:

Add: append(x), extend(iterable), insert(i, x), + (concatenation)
Remove: remove(x), pop(i), del lst[i], clear()
Search: index(x), count(x), x in lst
Sort: sort(), sorted(), reverse()
Other: copy(), len(), slicing

Internals: CPython lists are dynamic arrays (not linked lists). This means:

Index access: O(1)
Append: O(1) amortized
Insert/delete at beginning: O(n)
Search: O(n)

Pseudo Code

Create: [], list(), [x for x in iterable]
Add: append(x), extend(iter), insert(i, x)
Remove: remove(x), pop(i), del lst[i]
Search: index(x), count(x), x in lst
Sort: sort() in-place, sorted() new list

Performance:
  Index: O(1), Append: O(1), Insert/Delete at 0: O(n), Search: O(n)

Code

# Creation
lst = [1, 2, 3]
lst2 = list(range(5))      # [0, 1, 2, 3, 4]
lst3 = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

# Adding elements
lst = [1, 2, 3]
lst.append(4)          # [1, 2, 3, 4]
lst.extend([5, 6])     # [1, 2, 3, 4, 5, 6]
lst.insert(0, 0)       # [0, 1, 2, 3, 4, 5, 6]
lst += [7, 8]          # [0, 1, 2, 3, 4, 5, 6, 7, 8]

# Removing elements
lst = [1, 2, 3, 2, 4]
lst.remove(2)          # [1, 3, 2, 4] (removes first occurrence)
last = lst.pop()       # last=4, lst=[1, 3, 2]
first = lst.pop(0)     # first=1, lst=[3, 2]

lst = [1, 2, 3, 4, 5]
del lst[1]             # [1, 3, 4, 5]
del lst[1:3]           # [1, 5]

# Searching
lst = [10, 20, 30, 20, 40]
print(lst.index(20))    # 1 (first occurrence)
print(lst.count(20))    # 2
print(20 in lst)        # True
print(50 in lst)        # False

# Sorting
lst = [3, 1, 4, 1, 5, 9]
lst.sort()              # [1, 1, 3, 4, 5, 9] in-place
lst.sort(reverse=True)  # [9, 5, 4, 3, 1, 1]

lst = [3, 1, 4]
new = sorted(lst)       # new=[1, 3, 4], lst unchanged

# Reversing
lst = [1, 2, 3]
lst.reverse()           # [3, 2, 1] in-place
new = list(reversed(lst))  # creates new list

# Slicing (creates new list)
lst = [0, 1, 2, 3, 4]
print(lst[1:3])    # [1, 2]
print(lst[::-1])   # [4, 3, 2, 1, 0]

# Copying
import copy
lst = [[1, 2], [3, 4]]
shallow = lst.copy()        # or lst[:] or list(lst)
deep = copy.deepcopy(lst)   # for nested structures

# Nested lists
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix[1][2])  # 6

1
2
True
False
[1, 2]
[4, 3, 2, 1, 0]
6

Key Points

•Lists are mutable, ordered, and can hold mixed types
•append() adds one item, extend() adds from iterable
•sort() modifies in-place (returns None), sorted() returns new list
•Lists are dynamic arrays: O(1) index, O(1) append, O(n) insert at 0
•Slicing always creates a new list

Gotchas

•append([4,5]) adds a single list element, extend([4,5]) adds two elements
•sort() returns None -- do not assign: sorted_lst = lst.sort() is a bug
•remove() raises ValueError if element not found
•[[]] * 3 creates three references to the SAME inner list

Lists are mutable ordered sequences. Key methods: append(), extend(), pop(), remove(), sort(), index(). Dynamic arrays internally: O(1) index/append, O(n) insert at beginning.

•Mutable, ordered, dynamic array
•O(1) index and append, O(n) insert at 0

lst = [3, 1, 4]
lst.append(5)       # [3, 1, 4, 5]
lst.sort()          # [1, 3, 4, 5]
lst.pop()           # 5, lst=[1, 3, 4]
print(3 in lst)     # True

True

sort() returns None, sorted() returns a new list

Question 2 / 20

What are tuples and how do they differ from lists?

A tuple is an immutable, ordered sequence. Once created, elements cannot be added, removed, or modified.

Key differences from lists:

Feature	List	Tuple
Mutable	Yes	No
Syntax	`[1, 2, 3]`	`(1, 2, 3)`
Hashable	No	Yes (if all elements are hashable)
As dict key	No	Yes
Performance	Slightly slower	Slightly faster
Memory	More	Less

When to use tuples:

Fixed collections that should not change (coordinates, RGB values)
Dictionary keys (must be hashable)
Return multiple values from functions
Unpacking: a, b = func()
Data integrity: signal that the data is constant

Pseudo Code

Create: (), (1,), (1, 2, 3), tuple(iterable)
Single element: (1,) NOT (1) -- comma is required
Access: t[0], t[1:3], t[-1]
Operations: +, *, in, len(), count(), index()
Immutable: t[0] = 99 -> TypeError

Code

# Creation
t = (1, 2, 3)
t2 = 1, 2, 3          # parentheses optional
t3 = tuple([1, 2, 3])  # from iterable
t4 = tuple("hello")    # ('h', 'e', 'l', 'l', 'o')

# Single element tuple -- comma is required!
t_single = (42,)      # tuple with one element
not_tuple = (42)      # just an int!
print(type(t_single))  # <class 'tuple'>
print(type(not_tuple)) # <class 'int'>

# Empty tuple
t_empty = ()
t_empty2 = tuple()

# Access (same as lists)
t = (10, 20, 30, 40, 50)
print(t[0])       # 10
print(t[-1])      # 50
print(t[1:3])     # (20, 30)

# Immutability
try:
    t[0] = 99
except TypeError as e:
    print(f"Error: {e}")  # 'tuple' object does not support item assignment

# Operations
print((1, 2) + (3, 4))   # (1, 2, 3, 4)
print((1, 2) * 3)         # (1, 2, 1, 2, 1, 2)
print(2 in (1, 2, 3))     # True
print(len((1, 2, 3)))     # 3
print((1, 2, 2, 3).count(2))  # 2
print((1, 2, 3).index(2))     # 1

# Tuple as dict key (hashable)
coordinates = {(0, 0): "origin", (1, 0): "right"}
print(coordinates[(0, 0)])  # 'origin'

# Return multiple values
def min_max(lst):
    return min(lst), max(lst)  # returns a tuple

lo, hi = min_max([3, 1, 4, 1, 5])
print(f"min={lo}, max={hi}")  # min=1, max=5

# Named tuples
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(3, 4)
print(p.x, p.y)   # 3 4
print(p[0], p[1])  # 3 4 (indexable too)

# Tuple with mutable element (tricky!)
t = ([1, 2], [3, 4])
t[0].append(99)    # modifying the list inside the tuple
print(t)            # ([1, 2, 99], [3, 4]) -- allowed!
# The tuple itself is unchanged (still points to the same lists)

<class 'tuple'>
<class 'int'>
10
50
(20, 30)
Error: 'tuple' object does not support item assignment
(1, 2, 3, 4)
(1, 2, 1, 2, 1, 2)
True
3
2
1
origin
min=1, max=5
3 4
3 4
([1, 2, 99], [3, 4])

Key Points

•Tuples are immutable ordered sequences
•Single element tuple needs a trailing comma: (42,)
•Tuples are hashable and can be dict keys (if all elements are hashable)
•Tuples use less memory and are slightly faster than lists
•Named tuples provide named access to fields

Gotchas

•(42) is an int, not a tuple -- use (42,) with trailing comma
•A tuple containing mutable objects (lists) can have its contents changed
•Tuple with mutable element is not hashable: hash(([1,2],)) raises TypeError
•Tuples support + and * but create new tuples (immutable)

Tuples are immutable ordered sequences. Created with () or just commas. Single element needs trailing comma: (42,). Hashable (usable as dict keys). Use for fixed collections and multiple return values.

•Immutable, ordered, hashable (if elements are)
•Single element needs trailing comma

t = (1, 2, 3)
print(t[0])         # 1
# t[0] = 99         # TypeError!

single = (42,)      # tuple, not int
coords = {(0,0): "origin"}  # tuple as dict key

(42) is an int, (42,) is a tuple

Question 3 / 20

What are sets in Python and what operations do they support?

A set is an unordered collection of unique elements. Sets are mutable but can only contain hashable (immutable) elements.

Creation: {1, 2, 3}, set(iterable)

Mathematical set operations:

Union: a | b or a.union(b)
Intersection: a & b or a.intersection(b)
Difference: a - b or a.difference(b)
Symmetric difference: a ^ b or a.symmetric_difference(b)
Subset: a <= b or a.issubset(b)
Superset: a >= b or a.issuperset(b)

Performance: Sets use hash tables internally, so membership testing (in), add, and remove are all O(1) average.

frozenset: An immutable version of set -- can be used as dict key or set element.

Pseudo Code

Create: {1, 2, 3}, set(iterable)
Empty set: set() NOT {} (that's a dict)

Add: add(x), update(iterable)
Remove: remove(x) raises, discard(x) silent, pop()

Set ops: | union, & intersection, - difference, ^ symmetric diff
Tests: <= subset, >= superset, in membership

All O(1) for membership, add, remove

Code

# Creation
s = {1, 2, 3}
s2 = set([1, 2, 2, 3, 3])  # {1, 2, 3} (duplicates removed)
s3 = set("hello")           # {'h', 'e', 'l', 'o'}
empty = set()                # NOT {} (that's an empty dict!)

# Adding and removing
s = {1, 2, 3}
s.add(4)          # {1, 2, 3, 4}
s.update([5, 6])  # {1, 2, 3, 4, 5, 6}
s.remove(6)       # {1, 2, 3, 4, 5} -- raises KeyError if not found
s.discard(99)     # no error if not found
item = s.pop()    # removes and returns arbitrary element

# Set operations
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a | b)   # {1, 2, 3, 4, 5, 6} union
print(a & b)   # {3, 4} intersection
print(a - b)   # {1, 2} difference (in a but not b)
print(b - a)   # {5, 6} difference (in b but not a)
print(a ^ b)   # {1, 2, 5, 6} symmetric difference

# Subset and superset
print({1, 2} <= {1, 2, 3})   # True (subset)
print({1, 2} < {1, 2, 3})    # True (proper subset)
print({1, 2, 3} >= {1, 2})   # True (superset)
print({1, 2} <= {1, 2})      # True (subset or equal)
print({1, 2} < {1, 2})       # False (not proper subset)

# Membership test -- O(1)
big_set = set(range(1000000))
print(999999 in big_set)  # True (instant)

# Remove duplicates from list (preserving order with dict)
lst = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
unique = list(dict.fromkeys(lst))  # [3, 1, 4, 5, 9, 2, 6]
print(unique)

# Set comprehension
squares = {x**2 for x in range(-5, 6)}
print(squares)  # {0, 1, 4, 9, 16, 25}

# frozenset -- immutable set
fs = frozenset([1, 2, 3])
# fs.add(4)  # AttributeError
print({fs: "value"})  # frozenset as dict key

# Sets can only contain hashable elements
try:
    bad_set = {[1, 2], [3, 4]}  # lists are unhashable
except TypeError as e:
    print(f"Error: {e}")  # unhashable type: 'list'

# Use frozenset for sets of sets
set_of_sets = {frozenset([1, 2]), frozenset([3, 4])}
print(set_of_sets)

{1, 2, 3, 4, 5, 6}
{3, 4}
{1, 2}
{5, 6}
{1, 2, 5, 6}
True
True
True
True
False
True
[3, 1, 4, 5, 9, 2, 6]
{0, 1, 4, 9, 16, 25}
{frozenset({1, 2, 3}): 'value'}
Error: unhashable type: 'list'
{frozenset({3, 4}), frozenset({1, 2})}

Key Points

•Sets hold unique elements only, unordered
•O(1) membership testing, add, and remove
•Support mathematical set operations: |, &, -, ^
•Empty set is set(), NOT {} (which is an empty dict)
•frozenset is an immutable set (usable as dict key)

Gotchas

•{} creates an empty dict, not a set -- use set()
•Sets are unordered -- iteration order is not guaranteed
•remove() raises KeyError if not found, discard() does not
•Sets can only contain hashable elements (no lists or dicts)

Sets hold unique elements, unordered. O(1) lookup. Operations: | (union), & (intersection), - (difference), ^ (symmetric diff). Empty set is set() not {}.

•Unique, unordered, O(1) lookup
•set() for empty set, NOT {}

s = {1, 2, 3}
s.add(4)
print(3 in s)    # True (O(1))
print({1,2} | {2,3})  # {1, 2, 3}
print({1,2} & {2,3})  # {2}

True
{1, 2, 3}
{2}

{} is an empty dict, not a set

Question 4 / 20

What are dictionaries and what are the most common dict operations?

A dict is a mutable mapping of unique keys to values. Since Python 3.7, dicts maintain insertion order.

Creation: {}, dict(), dict comprehension, dict(zip(keys, values))

Key operations:

Access: d[key], d.get(key, default)
Set: d[key] = value, d.setdefault(key, default)
Remove: del d[key], d.pop(key, default), d.popitem()
Merge: d.update(other), d | other (Python 3.9+), {**d1, **d2}
Views: d.keys(), d.values(), d.items()

Performance: Hash table internally. O(1) average for get, set, delete, membership.

Keys must be hashable (immutable): str, int, float, tuple, frozenset.

Pseudo Code

Create: {}, dict(), {k: v for ...}, dict(zip(keys, values))
Access: d[key] (KeyError if missing), d.get(key, default)
Set: d[key] = value, d.setdefault(key, default)
Remove: del d[key], d.pop(key), d.popitem()
Merge: d.update(other), d | other (3.9+)
Views: d.keys(), d.values(), d.items()

Code

# Creation
d = {"name": "Alice", "age": 30}
d2 = dict(name="Alice", age=30)  # same
d3 = dict([("name", "Alice"), ("age", 30)])
d4 = dict(zip(["name", "age"], ["Alice", 30]))

# Access
print(d["name"])           # 'Alice'
print(d.get("name"))       # 'Alice'
print(d.get("email", "N/A"))  # 'N/A' (default for missing key)
# d["email"]  # raises KeyError

# Set
d["email"] = "alice@example.com"
d.setdefault("city", "NYC")  # sets only if key missing
print(d)  # {'name': 'Alice', 'age': 30, 'email': 'alice@example.com', 'city': 'NYC'}

# Remove
del d["email"]              # removes key
age = d.pop("age")          # removes and returns value
print(age)                  # 30
item = d.popitem()          # removes last inserted pair
print(item)                 # ('city', 'NYC')

# Merge
d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}

d1.update(d2)        # d1 = {'a': 1, 'b': 3, 'c': 4} (d2 overwrites)
merged = {**d1, **d2}  # unpacking merge
# Python 3.9+
# merged = d1 | d2

# Views
d = {"a": 1, "b": 2, "c": 3}
print(list(d.keys()))    # ['a', 'b', 'c']
print(list(d.values()))  # [1, 2, 3]
print(list(d.items()))   # [('a', 1), ('b', 2), ('c', 3)]

# Iteration
for key, value in d.items():
    print(f"{key}: {value}")

# Membership (checks keys)
print("a" in d)       # True
print(1 in d)          # False (1 is a value, not a key)
print(1 in d.values()) # True

# Dict comprehension
squares = {x: x**2 for x in range(6)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Filter dict
original = {"a": 1, "b": 2, "c": 3, "d": 4}
filtered = {k: v for k, v in original.items() if v > 2}
print(filtered)  # {'c': 3, 'd': 4}

# Invert dict
original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print(inverted)  # {1: 'a', 2: 'b', 3: 'c'}

Alice
Alice
N/A
{'name': 'Alice', 'age': 30, 'email': 'alice@example.com', 'city': 'NYC'}
30
('city', 'NYC')
['a', 'b', 'c']
[1, 2, 3]
[('a', 1), ('b', 2), ('c', 3)]
a: 1
b: 2
c: 3
True
False
True
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{'c': 3, 'd': 4}
{1: 'a', 2: 'b', 3: 'c'}

Key Points

•O(1) average for get, set, delete, membership
•Maintains insertion order (Python 3.7+)
•get() with default avoids KeyError
•Keys must be hashable (immutable types)
•Dict comprehensions for transforming dicts

Gotchas

•d[key] raises KeyError for missing keys -- use d.get(key, default)
•'in' checks keys, not values -- use 'in d.values()' for values
•Cannot modify dict size during iteration -- iterate over list(d.items())
•setdefault() returns the existing value if key already exists

Dicts map unique keys to values. O(1) access. Use get(key, default) to avoid KeyError. Maintains insertion order (3.7+). Keys must be hashable.

•O(1) access, insertion-ordered
•Use get() for safe access

d = {"name": "Alice", "age": 30}
print(d.get("email", "N/A"))  # 'N/A'
d["city"] = "NYC"
for k, v in d.items():
    print(k, v)

N/A
name Alice
age 30
city NYC

'in' checks keys only, not values

Question 5 / 20

What is the difference between list append() and extend()?

append(x) adds x as a single element to the end of the list. extend(iterable) adds each element from the iterable to the list.

This is one of the most common points of confusion for Python beginners.

append(x):

Adds exactly one element
If x is a list, it adds the entire list as a single nested element
O(1) amortized

extend(iterable):

Adds each element from the iterable
Equivalent to for item in iterable: lst.append(item) but faster
O(k) where k is the length of the iterable

Alternative: lst += iterable behaves like extend() for lists (calls __iadd__ which calls extend).

Pseudo Code

lst.append(x):  adds x as ONE element
  [1, 2].append([3, 4]) -> [1, 2, [3, 4]]

lst.extend(iterable):  adds EACH element
  [1, 2].extend([3, 4]) -> [1, 2, 3, 4]

lst += iterable:  same as extend() for lists

Code

# append -- adds one element
lst = [1, 2]
lst.append(3)
print(lst)  # [1, 2, 3]

lst.append([4, 5])  # adds the LIST as a single element
print(lst)  # [1, 2, 3, [4, 5]]

# extend -- adds each element from iterable
lst = [1, 2]
lst.extend([3, 4, 5])
print(lst)  # [1, 2, 3, 4, 5]

lst.extend("abc")  # strings are iterable
print(lst)  # [1, 2, 3, 4, 5, 'a', 'b', 'c']

# += is like extend for lists
lst = [1, 2]
lst += [3, 4]
print(lst)  # [1, 2, 3, 4]

# Comparison
a = [1, 2]
b = [1, 2]

a.append([3, 4])
b.extend([3, 4])

print(a)  # [1, 2, [3, 4]] -- list as element
print(b)  # [1, 2, 3, 4]   -- elements unpacked

# extend works with any iterable
lst = []
lst.extend(range(5))      # [0, 1, 2, 3, 4]
lst.extend({"a": 1})      # adds keys: [0, 1, 2, 3, 4, 'a']
lst.extend((10, 20))      # [0, 1, 2, 3, 4, 'a', 10, 20]

# append with non-iterable
lst = [1, 2]
lst.append(3)    # OK -- 3 is a single element
# lst.extend(3)  # TypeError -- 3 is not iterable

[1, 2, 3]
[1, 2, 3, [4, 5]]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 'a', 'b', 'c']
[1, 2, 3, 4]
[1, 2, [3, 4]]
[1, 2, 3, 4]

Key Points

•append(x) adds x as one element, extend(iterable) adds each element
•append([1,2]) nests the list, extend([1,2]) unpacks it
•+= works like extend() for lists
•extend() accepts any iterable (list, tuple, set, string, range)
•extend() is faster than repeated append() calls

Gotchas

•append('abc') adds one string; extend('abc') adds 'a', 'b', 'c' separately
•extend(3) raises TypeError -- 3 is not iterable; use append(3) for single values
•extend(dict) adds only the keys, not key-value pairs
•+= with a non-list on the right: lst += 'abc' extends with characters

append(x) adds x as one element. extend(iterable) adds each element from the iterable. append([1,2]) nests; extend([1,2]) unpacks.

•append = one element, extend = each element
•+= works like extend

a = [1, 2]
a.append([3, 4])   # [1, 2, [3, 4]]

b = [1, 2]
b.extend([3, 4])   # [1, 2, 3, 4]

extend('abc') adds 'a', 'b', 'c' separately

Question 6 / 20

What are named tuples and when should you use them?

Named tuples are tuples with named fields, created using collections.namedtuple() or typing.NamedTuple. They provide named access while remaining immutable and tuple-compatible.

Benefits over plain tuples:

Self-documenting: point.x vs point[0]
Still supports indexing, unpacking, iteration
Immutable (safer than dicts for fixed structures)
Memory efficient (no per-instance __dict__)

Benefits over dicts:

Immutable
Less memory
Dot access syntax
Can be used as dict keys

When to use:

Simple data containers with named fields
Return values from functions
Records from database queries or CSV files
Any time you would use a tuple but want named access

Pseudo Code

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(3, 4)
p.x, p.y  # named access
p[0], p[1]  # index access

from typing import NamedTuple
class Point(NamedTuple):
    x: float
    y: float

Code

# collections.namedtuple
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(3, 4)
print(p.x, p.y)     # 3 4 (named access)
print(p[0], p[1])    # 3 4 (index access)
print(*p)            # 3 4 (unpacking)

# Still a tuple
print(isinstance(p, tuple))  # True
print(len(p))                # 2
x, y = p                     # unpacking works

# typing.NamedTuple (modern, with type hints)
from typing import NamedTuple

class Employee(NamedTuple):
    name: str
    department: str
    salary: float = 50000.0  # default value

emp = Employee("Alice", "Engineering")
print(emp)              # Employee(name='Alice', department='Engineering', salary=50000.0)
print(emp.name)         # Alice
print(emp.salary)       # 50000.0

# Immutable -- cannot modify
try:
    emp.salary = 60000
except AttributeError as e:
    print(f"Error: {e}")  # can't set attribute

# _replace creates a new instance with changed fields
updated = emp._replace(salary=75000)
print(updated)  # Employee(name='Alice', department='Engineering', salary=75000.0)
print(emp)      # original unchanged

# Convert to dict
print(emp._asdict())  # {'name': 'Alice', 'department': 'Engineering', 'salary': 50000.0}

# Create from dict
data = {"name": "Bob", "department": "Sales", "salary": 60000}
bob = Employee(**data)
print(bob)

# Practical: function returning named tuple
from collections import namedtuple

Result = namedtuple('Result', ['mean', 'median', 'mode'])

def analyze(data):
    from statistics import mean, median, mode
    return Result(mean=mean(data), median=median(data), mode=mode(data))

result = analyze([1, 2, 2, 3, 4])
print(f"Mean: {result.mean}, Median: {result.median}, Mode: {result.mode}")

# Named tuples as dict keys
Color = namedtuple('Color', ['r', 'g', 'b'])
red = Color(255, 0, 0)
color_names = {red: "red", Color(0, 255, 0): "green"}
print(color_names[red])  # 'red'

3 4
3 4
3 4
True
2
Employee(name='Alice', department='Engineering', salary=50000.0)
Alice
50000.0
Error: can't set attribute
Employee(name='Alice', department='Engineering', salary=75000)
Employee(name='Alice', department='Engineering', salary=50000.0)
{'name': 'Alice', 'department': 'Engineering', 'salary': 50000.0}
Employee(name='Bob', department='Sales', salary=60000)
Mean: 2.4, Median: 2, Mode: 2
red

Key Points

•Named tuples provide named field access while remaining immutable
•Two ways: collections.namedtuple and typing.NamedTuple
•typing.NamedTuple supports type hints and default values
•_replace() creates a new instance with changed fields
•_asdict() converts to an OrderedDict/dict

Gotchas

•Named tuples are immutable -- use _replace() to create modified copies
•_replace, _asdict, _fields start with _ but are NOT private -- they avoid name conflicts
•For mutable named containers, consider dataclasses instead
•namedtuple field names must be valid identifiers and not start with _

Named tuples are tuples with named fields. Use collections.namedtuple or typing.NamedTuple. Immutable, memory-efficient, support both p.x and p[0] access.

•Named access + tuple compatibility
•Immutable and memory efficient

from typing import NamedTuple

class Point(NamedTuple):
    x: float
    y: float

p = Point(3, 4)
print(p.x, p.y)  # 3 4
print(p[0])       # 3

3 4
3

Use dataclasses for mutable named containers

Question 7 / 20

What is the difference between dict.get() and dict.setdefault()?

dict.get(key, default) returns the value for key if it exists, otherwise returns default (or None). It does NOT modify the dict.

dict.setdefault(key, default) returns the value for key if it exists. If the key does NOT exist, it inserts key with default as the value and returns default.

Key difference: get() is read-only, setdefault() may insert.

Use cases:

get(): Safe access without KeyError
setdefault(): Building dicts with default values (e.g., grouping)
collections.defaultdict: Automatic defaults (more Pythonic for grouping)

Pseudo Code

d.get(key, default):
  if key in d: return d[key]
  else: return default  # dict NOT modified

d.setdefault(key, default):
  if key in d: return d[key]
  else: d[key] = default; return default  # dict IS modified

Code

# get() -- read only
d = {"a": 1, "b": 2}
print(d.get("a"))        # 1
print(d.get("c"))        # None (key missing)
print(d.get("c", 0))     # 0 (custom default)
print(d)                  # {'a': 1, 'b': 2} -- unchanged

# setdefault() -- inserts if missing
d = {"a": 1, "b": 2}
print(d.setdefault("a", 99))   # 1 (existing, not modified)
print(d.setdefault("c", 3))    # 3 (inserted)
print(d)                        # {'a': 1, 'b': 2, 'c': 3}

# Practical: grouping with setdefault
words = ["apple", "banana", "avocado", "blueberry", "cherry"]
grouped = {}
for word in words:
    grouped.setdefault(word[0], []).append(word)
print(grouped)
# {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}

# Same with defaultdict (more Pythonic)
from collections import defaultdict
grouped = defaultdict(list)
for word in words:
    grouped[word[0]].append(word)
print(dict(grouped))

# Counting with setdefault vs Counter
text = "hello world"
counts = {}
for char in text:
    counts[char] = counts.get(char, 0) + 1  # get() for counting
print(counts)

# Better: use Counter
from collections import Counter
print(dict(Counter(text)))

1
None
0
{'a': 1, 'b': 2}
1
3
{'a': 1, 'b': 2, 'c': 3}
{'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}
{'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}
{'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}
{'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

Key Points

•get() returns default without modifying the dict
•setdefault() inserts default if key missing, then returns value
•setdefault() is useful for building lists/dicts as values
•defaultdict is often more Pythonic than setdefault()
•get() with default avoids KeyError and is cleaner than try/except

Gotchas

•get() returns None by default, not KeyError -- this can mask bugs
•setdefault() evaluates the default argument even if key exists (matters for expensive expressions)
•defaultdict creates entries on ANY access (even just reading), which may have side effects
•d.get(key) is None vs key not in d: get() cannot distinguish 'key has None value' from 'key missing'

get(key, default) returns default without modifying dict. setdefault(key, default) inserts default if key missing, then returns value. Use get() for reading, setdefault() for building.

•get() is read-only, setdefault() may insert
•defaultdict is often better for grouping

d = {"a": 1}
print(d.get("b", 0))        # 0, d unchanged
print(d.setdefault("b", 0)) # 0, d now has 'b': 0
print(d)                     # {'a': 1, 'b': 0}

0
0
{'a': 1, 'b': 0}

get() returns None by default -- cannot distinguish None value from missing key

Question 8 / 20

What is defaultdict and how does it differ from regular dict?

collections.defaultdict is a dict subclass that provides a default value for missing keys. When you access a missing key, it calls a factory function to create the default value and inserts it.

Constructor: defaultdict(default_factory)

Common factory functions:

int -- default 0 (for counting)
list -- default [] (for grouping)
set -- default set() (for unique grouping)
lambda: 'default' -- custom default value

Key difference from dict: Accessing a missing key in defaultdict creates the entry. In a regular dict, it raises KeyError.

Pseudo Code

from collections import defaultdict

dd = defaultdict(list)
dd['key'].append('value')  # auto-creates empty list for 'key'

dd = defaultdict(int)
dd['key'] += 1  # auto-creates 0 for 'key'

Regular dict:
d['missing_key']  # KeyError!
defaultdict:
dd['missing_key']  # creates and returns default

Code

from collections import defaultdict

# Counting with defaultdict(int)
text = "the cat sat on the mat"
word_count = defaultdict(int)
for word in text.split():
    word_count[word] += 1  # missing keys auto-initialize to 0
print(dict(word_count))  # {'the': 2, 'cat': 1, 'sat': 1, 'on': 1, 'mat': 1}

# Grouping with defaultdict(list)
students = [
    ("Alice", "Math"),
    ("Bob", "Science"),
    ("Alice", "Science"),
    ("Bob", "Math"),
    ("Charlie", "Math")
]

by_student = defaultdict(list)
for name, subject in students:
    by_student[name].append(subject)
print(dict(by_student))
# {'Alice': ['Math', 'Science'], 'Bob': ['Science', 'Math'], 'Charlie': ['Math']}

# Unique grouping with defaultdict(set)
by_subject = defaultdict(set)
for name, subject in students:
    by_subject[subject].add(name)
print(dict(by_subject))
# {'Math': {'Alice', 'Bob', 'Charlie'}, 'Science': {'Alice', 'Bob'}}

# Custom default with lambda
config = defaultdict(lambda: "unknown")
config["name"] = "Alice"
print(config["name"])    # Alice
print(config["email"])   # 'unknown' (auto-created)
print(dict(config))      # {'name': 'Alice', 'email': 'unknown'}

# Nested defaultdict
tree = defaultdict(lambda: defaultdict(int))
tree["sales"]["q1"] = 100
tree["sales"]["q2"] = 200
print(dict(tree["sales"]))  # {'q1': 100, 'q2': 200}

# defaultdict vs regular dict
regular = {}
try:
    regular["missing"]
except KeyError:
    print("KeyError with regular dict")

dd = defaultdict(int)
print(dd["missing"])  # 0 (auto-created, no error)
print("missing" in dd)  # True (key was created!)

# CAUTION: accessing creates entries
dd = defaultdict(list)
if dd["key"]:  # creates empty list even if just checking!
    pass
print(dict(dd))  # {'key': []} -- entry was created!

{'the': 2, 'cat': 1, 'sat': 1, 'on': 1, 'mat': 1}
{'Alice': ['Math', 'Science'], 'Bob': ['Science', 'Math'], 'Charlie': ['Math']}
{'Math': {'Bob', 'Charlie', 'Alice'}, 'Science': {'Bob', 'Alice'}}
Alice
unknown
{'name': 'Alice', 'email': 'unknown'}
{'q1': 100, 'q2': 200}
KeyError with regular dict
0
True
{'key': []}

Key Points

•defaultdict auto-creates missing keys using a factory function
•Common factories: int (0), list ([]), set (set())
•Eliminates the need for key-existence checks
•Perfect for counting, grouping, and accumulating
•Accessing a missing key CREATES the entry

Gotchas

•Accessing a missing key creates it -- even with 'if dd[key]:' check
•Use 'key in dd' instead of 'dd[key]' to check without creating
•default_factory=None makes it behave like a regular dict
•Convert to regular dict before serializing (JSON, etc.)

defaultdict(factory) auto-creates missing keys. defaultdict(int) for counting, defaultdict(list) for grouping. Unlike regular dict, accessing missing keys does not raise KeyError.

•Auto-creates missing keys with factory function
•int for counting, list for grouping

from collections import defaultdict

counts = defaultdict(int)
for word in "a b a c b a".split():
    counts[word] += 1
print(dict(counts))  # {'a': 3, 'b': 2, 'c': 1}

{'a': 3, 'b': 2, 'c': 1}

Accessing a missing key creates the entry

Question 9 / 20

What is OrderedDict and is it still needed in modern Python?

Since Python 3.7, regular dict maintains insertion order as a language guarantee. Before that, collections.OrderedDict was the only way to get ordered dictionaries.

Is OrderedDict still useful? Yes, in specific cases:

Equality comparison considers order: OrderedDict([('a',1),('b',2)]) != OrderedDict([('b',2),('a',1)]) but {'a':1,'b':2} == {'b':2,'a':1}
move_to_end(key, last=True): Reorder entries efficiently
popitem(last=True): Remove from either end
Explicit intent: Signals that order matters in your code
LRU cache implementation: move_to_end is useful

For most new code, regular dict is sufficient.

Pseudo Code

Regular dict (Python 3.7+):
  Maintains insertion order
  Equality ignores order: {'a':1,'b':2} == {'b':2,'a':1}

OrderedDict:
  Maintains insertion order
  Equality considers order
  Has move_to_end() and popitem(last=True/False)
  More explicit about order being important

Code

from collections import OrderedDict

# Regular dict preserves insertion order (Python 3.7+)
d = {"b": 2, "a": 1, "c": 3}
print(list(d.keys()))  # ['b', 'a', 'c']

# OrderedDict
od = OrderedDict([("b", 2), ("a", 1), ("c", 3)])
print(list(od.keys()))  # ['b', 'a', 'c']

# Key difference: equality
d1 = {"a": 1, "b": 2}
d2 = {"b": 2, "a": 1}
print(d1 == d2)  # True (dict ignores order in equality)

od1 = OrderedDict([("a", 1), ("b", 2)])
od2 = OrderedDict([("b", 2), ("a", 1)])
print(od1 == od2)  # False (OrderedDict considers order)

# move_to_end
od = OrderedDict([("a", 1), ("b", 2), ("c", 3)])
od.move_to_end("a")        # move to end
print(list(od.keys()))      # ['b', 'c', 'a']

od.move_to_end("a", last=False)  # move to beginning
print(list(od.keys()))             # ['a', 'b', 'c']

# popitem with last parameter
od = OrderedDict([("a", 1), ("b", 2), ("c", 3)])
print(od.popitem(last=True))   # ('c', 3) LIFO
print(od.popitem(last=False))  # ('a', 1) FIFO

# LRU Cache pattern with OrderedDict
class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key):
        if key in self.cache:
            self.cache.move_to_end(key)
            return self.cache[key]
        return -1

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)  # remove oldest

lru = LRUCache(3)
lru.put("a", 1)
lru.put("b", 2)
lru.put("c", 3)
lru.get("a")        # moves 'a' to end
lru.put("d", 4)     # evicts 'b' (oldest)
print(list(lru.cache.keys()))  # ['c', 'a', 'd']

['b', 'a', 'c']
['b', 'a', 'c']
True
False
['b', 'c', 'a']
['a', 'b', 'c']
('c', 3)
('a', 1)
['c', 'a', 'd']

Key Points

•Regular dict maintains insertion order since Python 3.7
•OrderedDict equality considers order; regular dict does not
•OrderedDict has move_to_end() and popitem(last=True/False)
•OrderedDict is useful for LRU cache implementations
•For most cases, regular dict is sufficient

Gotchas

•OrderedDict uses more memory than regular dict
•OrderedDict is slightly slower than regular dict
•In Python 3.7+, dict ordering is guaranteed, not just implementation detail
•OrderedDict equality: od1 == regular_dict compares without order

Regular dict maintains insertion order since Python 3.7. OrderedDict is still useful when equality should consider order, or when you need move_to_end() and popitem(last=False) for LRU caches.

•Dict is ordered since 3.7
•OrderedDict for order-sensitive equality and move_to_end()

from collections import OrderedDict

# Equality difference
print({"a":1,"b":2} == {"b":2,"a":1})  # True (dict)
od1 = OrderedDict(a=1, b=2)
od2 = OrderedDict(b=2, a=1)
print(od1 == od2)  # False (OrderedDict)

True
False

OrderedDict uses more memory than regular dict

Question 10 / 20

What is collections.deque and when should you use it instead of a list?

collections.deque (double-ended queue) is optimized for O(1) append and pop from both ends.

When to use deque over list:

When you need a queue (FIFO): appendleft() + pop()
When you need a stack with two ends
When you frequently insert/remove at the beginning
When you need a fixed-size sliding window (maxlen)

Performance comparison:

Operation	list	deque
Append right	O(1)	O(1)
Pop right	O(1)	O(1)
Append left	O(n)	O(1)
Pop left	O(n)	O(1)
Index access	O(1)	O(n)

Trade-off: deque has O(n) random access, so use lists when you need frequent indexing.

Pseudo Code

from collections import deque

Queue (FIFO): append() + popleft()
Stack (LIFO): append() + pop()
Sliding window: deque(maxlen=n)

O(1) both ends, O(n) random access

Code

from collections import deque

# Basic deque
d = deque([1, 2, 3])
d.append(4)         # right: [1, 2, 3, 4]
d.appendleft(0)     # left:  [0, 1, 2, 3, 4]

right = d.pop()     # 4, deque: [0, 1, 2, 3]
left = d.popleft()  # 0, deque: [1, 2, 3]

# Extend both ends
d.extend([4, 5])        # right: [1, 2, 3, 4, 5]
d.extendleft([0, -1])   # left:  [-1, 0, 1, 2, 3, 4, 5]
# Note: extendleft reverses the order

# Fixed-size deque (sliding window)
recent = deque(maxlen=3)
for i in range(5):
    recent.append(i)
    print(list(recent))
# [0]
# [0, 1]
# [0, 1, 2]
# [1, 2, 3]  -- 0 was dropped
# [2, 3, 4]  -- 1 was dropped

# Queue implementation (FIFO)
queue = deque()
queue.append("first")    # enqueue
queue.append("second")
queue.append("third")
print(queue.popleft())   # 'first' (dequeue) -- O(1)
print(queue.popleft())   # 'second'

# Rotate
d = deque([1, 2, 3, 4, 5])
d.rotate(2)     # rotate right by 2
print(list(d))  # [4, 5, 1, 2, 3]

d.rotate(-2)    # rotate left by 2
print(list(d))  # [1, 2, 3, 4, 5]

# Performance comparison
import timeit

# List: insert at beginning is O(n)
lst_time = timeit.timeit(
    lambda: [0] + list(range(1000)),
    number=1000
)

# Deque: appendleft is O(1)
def deque_test():
    d = deque(range(1000))
    d.appendleft(0)

deq_time = timeit.timeit(deque_test, number=1000)
print(f"List insert(0): {lst_time:.4f}s")
print(f"Deque appendleft: {deq_time:.4f}s")

# BFS with deque
def bfs(graph, start):
    visited = set()
    queue = deque([start])
    order = []
    while queue:
        node = queue.popleft()
        if node not in visited:
            visited.add(node)
            order.append(node)
            queue.extend(graph.get(node, []))
    return order

graph = {"A": ["B", "C"], "B": ["D"], "C": ["D"], "D": []}
print(bfs(graph, "A"))  # ['A', 'B', 'C', 'D']

[0]
[0, 1]
[0, 1, 2]
[1, 2, 3]
[2, 3, 4]
first
second
[4, 5, 1, 2, 3]
[1, 2, 3, 4, 5]
List insert(0): 0.0060s
Deque appendleft: 0.0063s
['A', 'B', 'C', 'D']

Key Points

•O(1) append/pop from both ends
•Use for queues, stacks, and sliding windows
•maxlen creates a fixed-size deque (drops from opposite end)
•rotate() efficiently shifts elements
•O(n) random access -- use list if you need frequent indexing

Gotchas

•deque has O(n) random access: d[500] is slow
•extendleft() reverses the order of added elements
•deque does not support slicing directly: use itertools.islice()
•maxlen deque silently drops elements from the opposite end

deque provides O(1) append/pop from both ends. Use for queues (append + popleft), sliding windows (maxlen), and any operation needing fast insertion at the beginning.

•O(1) both ends, O(n) random access
•maxlen for sliding windows

from collections import deque

q = deque()
q.append("a"); q.append("b")
print(q.popleft())  # 'a' (O(1))

window = deque(maxlen=3)
for i in range(5):
    window.append(i)
print(list(window))  # [2, 3, 4]

a
[2, 3, 4]

O(n) random access -- use list for frequent indexing

Question 11 / 20

When should you use a list vs tuple vs set vs dict?

List -- ordered, mutable, duplicates allowed

Use for: ordered collections that may change, stacks, sequences
Examples: shopping cart items, task queue, log entries

Tuple -- ordered, immutable, duplicates allowed

Use for: fixed data, function return values, dict keys, data integrity
Examples: coordinates (x, y), RGB colors, database row

Set -- unordered, mutable, NO duplicates

Use for: unique collections, membership testing, set operations
Examples: tags, visited nodes, removing duplicates

Dict -- ordered (3.7+), mutable, unique keys

Use for: key-value mapping, lookup tables, configuration
Examples: user profiles, word counts, caches

Performance cheat sheet:

Operation	list	set	dict
Lookup	O(n)	O(1)	O(1)
Insert	O(1)*	O(1)	O(1)
Delete	O(n)	O(1)	O(1)

Pseudo Code

Need order + mutation? -> list
Need order + immutability? -> tuple
Need uniqueness + fast lookup? -> set
Need key-value pairs? -> dict

Need fast lookup in ordered data? -> dict (or list + set)
Need stack? -> list (append/pop)
Need queue? -> collections.deque

Code

# List: ordered, mutable, allows duplicates
tasks = ["write code", "test code", "write code"]
tasks.append("deploy")
tasks.remove("write code")  # removes first occurrence
print(tasks)  # ['test code', 'write code', 'deploy']

# Tuple: ordered, immutable, allows duplicates
coord = (3.14, 2.72)
rgb_red = (255, 0, 0)
# Hashable: can be dict key
color_map = {(255, 0, 0): "red", (0, 255, 0): "green"}

# Set: unordered, unique elements, fast membership
tags = {"python", "programming", "tutorial"}
tags.add("python")  # no duplicate added
print("python" in tags)  # True -- O(1)

# Remove duplicates from list
lst = [1, 2, 2, 3, 3, 4]
unique = list(set(lst))  # order not preserved
unique_ordered = list(dict.fromkeys(lst))  # order preserved

# Dict: key-value mapping, fast lookup
user = {"name": "Alice", "age": 30}
print(user["name"])  # O(1) lookup

# Decision flowchart example
def choose_structure(needs_order, needs_unique, needs_kv, needs_mutable):
    if needs_kv:
        return "dict"
    if needs_unique:
        if needs_mutable:
            return "set"
        return "frozenset"
    if needs_order:
        if needs_mutable:
            return "list"
        return "tuple"
    return "set"  # default for unique, unordered

# Performance demonstration
import timeit

data_list = list(range(100000))
data_set = set(range(100000))
data_dict = {i: True for i in range(100000)}

print("Lookup 99999:")
print(f"  list: {timeit.timeit(lambda: 99999 in data_list, number=1000):.4f}s")
print(f"  set:  {timeit.timeit(lambda: 99999 in data_set, number=1000):.4f}s")
print(f"  dict: {timeit.timeit(lambda: 99999 in data_dict, number=1000):.4f}s")

['test code', 'write code', 'deploy']
True
Alice
Lookup 99999:
list: 0.3145s
set:  0.0000s
dict: 0.0000s

Key Points

•List: ordered mutable sequence with duplicates
•Tuple: ordered immutable sequence (hashable)
•Set: unordered unique collection with O(1) lookup
•Dict: key-value mapping with O(1) lookup
•Choose based on: order, uniqueness, mutability, lookup speed needs

Gotchas

•set() removes duplicates but does not preserve order
•dict preserves insertion order in Python 3.7+ but is not the same as OrderedDict
•Converting list to set and back loses order -- use dict.fromkeys() to preserve
•Sets and dict keys require hashable elements

List: ordered, mutable, duplicates OK. Tuple: ordered, immutable. Set: unique, O(1) lookup. Dict: key-value, O(1) lookup. Choose based on whether you need order, uniqueness, mutability, or key-value pairs.

•List=ordered mutable, Tuple=ordered immutable, Set=unique, Dict=key-value
•Set/dict for O(1) lookup, list for O(1) index

# List for ordered, mutable sequences
tasks = ["a", "b", "c"]
# Tuple for fixed, hashable data
point = (3, 4)
# Set for unique, fast lookup
tags = {"py", "js", "go"}
# Dict for key-value pairs
config = {"debug": True}

set() loses order when deduplicating

Question 12 / 20

What is the difference between shallow copy and deep copy for nested data structures?

For nested data structures (list of lists, dict of dicts, etc.), the copy behavior matters critically:

Shallow copy: Copies the outer container but inner objects are shared references. Deep copy: Recursively copies everything -- fully independent.

Shallow copy methods:

list.copy(), dict.copy()
Slice: lst[:]
Constructors: list(original), dict(original)
copy.copy()

Deep copy:

copy.deepcopy()

The difference only matters when you have nested mutable objects (lists within lists, dicts within dicts). For flat structures with only immutable elements, shallow copy is sufficient.

Pseudo Code

Shallow: new outer, shared inner
  modify inner -> both affected
  modify outer (add/remove) -> only copy affected

Deep: new outer, new inner (recursive)
  modify anything -> only copy affected

Code

import copy

# Shallow copy -- inner lists are shared
original = {"users": ["Alice", "Bob"], "config": {"debug": True}}
shallow = original.copy()

# Modifying outer level -- only affects copy
shallow["new_key"] = "value"
print("new_key" in original)  # False -- outer not shared

# Modifying inner level -- affects both!
shallow["users"].append("Charlie")
print(original["users"])  # ['Alice', 'Bob', 'Charlie'] -- shared!

shallow["config"]["debug"] = False
print(original["config"])  # {'debug': False} -- shared!

# Deep copy -- fully independent
original = {"users": ["Alice", "Bob"], "config": {"debug": True}}
deep = copy.deepcopy(original)

deep["users"].append("Charlie")
print(original["users"])  # ['Alice', 'Bob'] -- not affected!

deep["config"]["debug"] = False
print(original["config"])  # {'debug': True} -- not affected!

# List of lists example
matrix = [[1, 2], [3, 4]]
shallow = [row[:] for row in matrix]  # shallow copy of each row = effective deep copy for 2D
shallow[0][0] = 99
print(matrix[0][0])  # 1 (unaffected because we copied each inner list)

# But for 3+ levels deep, need deepcopy
nested = [[[1, 2]], [[3, 4]]]
shallow_2d = [row[:] for row in nested]  # only copies one level
shallow_2d[0][0].append(99)
print(nested[0][0])  # [1, 2, 99] -- inner-inner is shared!

deep = copy.deepcopy(nested)
deep[0][0].append(100)
print(nested[0][0])  # [1, 2, 99] -- not affected

# Deep copy handles circular references
a = [1, 2]
a.append(a)  # circular reference
b = copy.deepcopy(a)  # handles this correctly
print(b[0])  # 1
print(b[2] is b)  # True (circular ref preserved in copy)

False
['Alice', 'Bob', 'Charlie']
{'debug': False}
['Alice', 'Bob']
{'debug': True}
1
[1, 2, 99]
[1, 2, 99]
1
True

Key Points

•Shallow copy: new outer container, shared inner references
•Deep copy: fully recursive independent copy
•Only matters for nested mutable objects
•[row[:] for row in matrix] gives effective deep copy for 2D lists
•copy.deepcopy() handles circular references

Gotchas

•dict.copy() and list.copy() are SHALLOW -- a common source of bugs
•deepcopy is slow for large structures -- use only when necessary
•deepcopy preserves object identity within the copy (circular refs work)
•Custom objects may need __copy__ and __deepcopy__ methods

Shallow copy shares inner objects; deep copy is fully independent. Use copy.deepcopy() for nested mutable structures. dict.copy() and list.copy() are shallow.

•Shallow shares inner objects, deep is independent
•Use deepcopy for nested mutable structures

import copy
orig = {"list": [1, 2]}
shallow = orig.copy()
shallow["list"].append(3)
print(orig["list"])  # [1, 2, 3] -- shared!

deep = copy.deepcopy(orig)
deep["list"].append(4)
print(orig["list"])  # [1, 2, 3] -- unaffected

[1, 2, 3]
[1, 2, 3]

dict.copy() is shallow -- nested dicts are shared

Question 13 / 20

How do dict comprehensions work?

Dict comprehensions create dictionaries using a concise syntax:

{key_expr: value_expr for item in iterable if condition}

They work similarly to list comprehensions but produce dictionaries.

Common patterns:

Transform values: {k: v*2 for k, v in d.items()}
Filter entries: {k: v for k, v in d.items() if v > 0}
Invert dict: {v: k for k, v in d.items()}
From two lists: {k: v for k, v in zip(keys, values)}
From iterable: {x: x**2 for x in range(5)}

Pseudo Code

Basic: {key: value for item in iterable}
Filtered: {key: value for item in iterable if condition}
From items: {k: transform(v) for k, v in dict.items()}
Invert: {v: k for k, v in dict.items()}

Code

# Basic dict comprehension
squares = {x: x**2 for x in range(6)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# From two lists
keys = ["name", "age", "city"]
values = ["Alice", 30, "NYC"]
person = {k: v for k, v in zip(keys, values)}
print(person)  # {'name': 'Alice', 'age': 30, 'city': 'NYC'}
# Or simpler: dict(zip(keys, values))

# Filter entries
scores = {"Alice": 95, "Bob": 60, "Charlie": 85, "David": 45}
passing = {name: score for name, score in scores.items() if score >= 70}
print(passing)  # {'Alice': 95, 'Charlie': 85}

# Transform values
prices = {"apple": 1.00, "banana": 0.50, "cherry": 2.00}
taxed = {item: round(price * 1.08, 2) for item, price in prices.items()}
print(taxed)  # {'apple': 1.08, 'banana': 0.54, 'cherry': 2.16}

# Invert dict (swap keys and values)
original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print(inverted)  # {1: 'a', 2: 'b', 3: 'c'}

# Transform keys
data = {"First Name": "Alice", "Last Name": "Smith"}
normalized = {k.lower().replace(" ", "_"): v for k, v in data.items()}
print(normalized)  # {'first_name': 'Alice', 'last_name': 'Smith'}

# Conditional value assignment
numbers = range(-5, 6)
sign_map = {n: ("positive" if n > 0 else "negative" if n < 0 else "zero") for n in numbers}
print(sign_map)  # {-5: 'negative', ..., 0: 'zero', ..., 5: 'positive'}

# Nested comprehension: flatten nested dict
nested = {"math": {"Alice": 95, "Bob": 87}, "science": {"Alice": 92, "Bob": 88}}
flat = {f"{subject}_{student}": grade
        for subject, students in nested.items()
        for student, grade in students.items()}
print(flat)  # {'math_Alice': 95, 'math_Bob': 87, 'science_Alice': 92, 'science_Bob': 88}

# Count character frequency
text = "hello world"
freq = {char: text.count(char) for char in set(text)}
print(freq)  # {'h': 1, 'e': 1, 'l': 3, 'o': 2, ...}

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{'name': 'Alice', 'age': 30, 'city': 'NYC'}
{'Alice': 95, 'Charlie': 85}
{'apple': 1.08, 'banana': 0.54, 'cherry': 2.16}
{1: 'a', 2: 'b', 3: 'c'}
{'first_name': 'Alice', 'last_name': 'Smith'}
{-5: 'negative', -4: 'negative', -3: 'negative', -2: 'negative', -1: 'negative', 0: 'zero', 1: 'positive', 2: 'positive', 3: 'positive', 4: 'positive', 5: 'positive'}
{'math_Alice': 95, 'math_Bob': 87, 'science_Alice': 92, 'science_Bob': 88}
{'r': 1, 'h': 1, 'd': 1, 'e': 1, 'l': 3, ' ': 1, 'o': 2, 'w': 1}

Key Points

•Syntax: {key: value for item in iterable if condition}
•Can transform keys, values, or both
•Can filter with if clause
•Common for inverting dicts, normalizing keys, filtering entries
•More readable than dict() with map/filter for simple transforms

Gotchas

•Inverting a dict loses values if multiple keys map to the same value
•Dict comprehension evaluates key expression first, then value
•Duplicate keys: last value wins (just like regular dict)
•For complex logic, a regular for loop is more readable

Dict comprehensions: {key: value for item in iterable if condition}. Used to transform, filter, and create dicts concisely.

•{key: value for item in iterable if condition}
•Concise way to create/transform dicts

squares = {x: x**2 for x in range(5)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Filter
d = {"a": 1, "b": 2, "c": 3}
filtered = {k: v for k, v in d.items() if v > 1}
print(filtered)  # {'b': 2, 'c': 3}

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
{'b': 2, 'c': 3}

Duplicate keys: last value wins

Question 14 / 20

How do you sort lists of complex objects in Python?

Python's sorted() and list.sort() accept a key parameter -- a function applied to each element before comparison.

Common key functions:

key=len -- sort by length
key=str.lower -- case-insensitive sort
key=lambda x: x[1] -- sort by second element
key=lambda x: x.attribute -- sort by attribute
key=operator.itemgetter(1) -- faster than lambda for items
key=operator.attrgetter('name') -- faster than lambda for attributes

Multi-key sort:

Return a tuple: key=lambda x: (x.grade, x.name)
Use negative values for reverse on specific keys: key=lambda x: (-x.grade, x.name)

Python's sort is stable (Timsort): equal elements maintain their original order.

Pseudo Code

sorted(data, key=func)  # sort by func(element)
sorted(data, key=lambda x: x.attr)  # sort by attribute
sorted(data, key=lambda x: (x.a, x.b))  # multi-key
sorted(data, key=lambda x: (-x.a, x.b))  # desc a, asc b

Code

# Sort by length
words = ["banana", "apple", "fig", "cherry"]
print(sorted(words, key=len))  # ['fig', 'apple', 'banana', 'cherry']

# Case-insensitive sort
words = ["Banana", "apple", "Cherry"]
print(sorted(words, key=str.lower))  # ['apple', 'Banana', 'Cherry']

# Sort tuples by second element
pairs = [(1, 'b'), (3, 'a'), (2, 'c')]
print(sorted(pairs, key=lambda x: x[1]))  # [(3, 'a'), (1, 'b'), (2, 'c')]

# Sort dicts by value
scores = {"Alice": 95, "Bob": 87, "Charlie": 92}
sorted_names = sorted(scores, key=scores.get, reverse=True)
print(sorted_names)  # ['Alice', 'Charlie', 'Bob']

# Sort objects by attribute
class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade
    def __repr__(self):
        return f"Student({self.name}, {self.grade})"

students = [
    Student("Alice", 95),
    Student("Bob", 87),
    Student("Charlie", 92)
]

by_grade = sorted(students, key=lambda s: s.grade, reverse=True)
print(by_grade)  # [Student(Alice, 95), Student(Charlie, 92), Student(Bob, 87)]

# Multi-key sort: grade desc, name asc
students = [
    Student("Alice", 95),
    Student("Bob", 95),
    Student("Charlie", 87),
    Student("David", 87)
]
result = sorted(students, key=lambda s: (-s.grade, s.name))
print(result)  # Alice(95), Bob(95), Charlie(87), David(87)

# operator.itemgetter and attrgetter (faster than lambda)
from operator import itemgetter, attrgetter

pairs = [("b", 2), ("a", 3), ("c", 1)]
print(sorted(pairs, key=itemgetter(1)))  # by second element
print(sorted(pairs, key=itemgetter(0)))  # by first element

result = sorted(students, key=attrgetter('grade'), reverse=True)
print(result)

# Stable sort: equal elements keep original order
data = [("a", 2), ("b", 1), ("c", 2), ("d", 1)]
result = sorted(data, key=lambda x: x[1])
print(result)  # [('b', 1), ('d', 1), ('a', 2), ('c', 2)]
# b before d, a before c -- original order preserved for equal keys

['fig', 'apple', 'banana', 'cherry']
['apple', 'Banana', 'Cherry']
[(3, 'a'), (1, 'b'), (2, 'c')]
['Alice', 'Charlie', 'Bob']
[Student(Alice, 95), Student(Charlie, 92), Student(Bob, 87)]
[Student(Alice, 95), Student(Bob, 95), Student(Charlie, 87), Student(David, 87)]
[('c', 1), ('b', 2), ('a', 3)]
[('a', 3), ('b', 2), ('c', 1)]
[Student(Alice, 95), Student(Bob, 95), Student(Charlie, 87), Student(David, 87)]
[('b', 1), ('d', 1), ('a', 2), ('c', 2)]

Key Points

•key= parameter takes a function applied to each element
•lambda for simple custom keys, operator.itemgetter for tuples
•Return tuple for multi-key sort
•Negate numeric values for descending on specific keys
•Python's sort is stable (Timsort) -- equal elements keep original order

Gotchas

•key function is called once per element, not per comparison
•Cannot negate strings for reverse -- use two separate sorts instead
•sort() returns None (in-place), sorted() returns a new list
•Sorting mixed types (int and str) raises TypeError

Use key= parameter for custom sorting. key=len for length, key=lambda x: x[1] for element access. Return tuples for multi-key sort. Python sort is stable.

•key= takes a function applied to each element
•Stable sort preserves order of equal elements

words = ["banana", "fig", "cherry"]
print(sorted(words, key=len))  # ['fig', 'banana', 'cherry']

pairs = [(1,'b'), (2,'a')]
print(sorted(pairs, key=lambda x: x[1]))  # [(2,'a'), (1,'b')]

['fig', 'banana', 'cherry']
[(2, 'a'), (1, 'b')]

sort() returns None, sorted() returns a new list

Question 15 / 20

How do you remove duplicates from a list while preserving order?

Several approaches with different trade-offs:

1. dict.fromkeys() (best for simple cases): Dicts preserve insertion order (Python 3.7+). dict.fromkeys(lst) creates a dict with list elements as keys (duplicates removed), then convert back.

2. set() with tracking (manual): Iterate and track seen items.

3. set() alone (does NOT preserve order): list(set(lst)) -- fast but loses order.

4. more_itertools.unique_everseen(): Third-party, handles unhashable elements.

5. Pandas Series.drop_duplicates(): For data analysis contexts.

Pseudo Code

Preserving order:
  list(dict.fromkeys(lst))  # simplest, Python 3.7+
  seen = set(); [x for x in lst if not (x in seen or seen.add(x))]

Not preserving order:
  list(set(lst))  # fast but unordered

Code

# Method 1: dict.fromkeys() -- simplest, preserves order
lst = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
unique = list(dict.fromkeys(lst))
print(unique)  # [3, 1, 4, 5, 9, 2, 6]

# Method 2: set with tracking
def unique_ordered(lst):
    seen = set()
    result = []
    for item in lst:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

print(unique_ordered([3, 1, 4, 1, 5, 9]))  # [3, 1, 4, 5, 9]

# Method 3: set comprehension trick (clever but less readable)
lst = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
seen = set()
unique = [x for x in lst if not (x in seen or seen.add(x))]
print(unique)  # [3, 1, 4, 5, 9, 2, 6]

# Method 4: set() alone -- does NOT preserve order
lst = [3, 1, 4, 1, 5, 9]
unique_unordered = list(set(lst))  # order not guaranteed
print(unique_unordered)

# For unhashable elements (e.g., lists)
def unique_unhashable(lst):
    result = []
    for item in lst:
        if item not in result:  # O(n) check each time
            result.append(item)
    return result

print(unique_unhashable([[1, 2], [3, 4], [1, 2]]))  # [[1, 2], [3, 4]]

# Remove duplicates from list of dicts by key
users = [
    {"id": 1, "name": "Alice"},
    {"id": 2, "name": "Bob"},
    {"id": 1, "name": "Alice Duplicate"}
]

seen_ids = set()
unique_users = []
for user in users:
    if user["id"] not in seen_ids:
        seen_ids.add(user["id"])
        unique_users.append(user)
print(unique_users)  # [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]

# Performance comparison
import timeit

lst = list(range(1000)) * 10  # 10000 items with dupes

print("dict.fromkeys:", timeit.timeit(lambda: list(dict.fromkeys(lst)), number=1000))
print("set tracking:", timeit.timeit(lambda: unique_ordered(lst), number=1000))
print("set (no order):", timeit.timeit(lambda: list(set(lst)), number=1000))

[3, 1, 4, 5, 9, 2, 6]
[3, 1, 4, 5, 9]
[3, 1, 4, 5, 9, 2, 6]
[1, 3, 4, 5, 9]
[[1, 2], [3, 4]]
[{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]
dict.fromkeys: 0.08173433388583362
set tracking: 0.08387241698801517
set (no order): 0.03643654100596905

Key Points

•dict.fromkeys(lst) is simplest for order-preserving dedup
•set() tracking loop for more control
•list(set(lst)) is fastest but loses order
•For unhashable elements, use 'in' check (O(n^2))
•dict.fromkeys() requires hashable elements

Gotchas

•list(set(lst)) does NOT preserve order
•dict.fromkeys() only works with hashable elements
•The set comprehension trick (seen.add(x)) relies on add() returning None
•For very large lists, set-based approaches are much faster than O(n^2) 'in' checks

Preserve order: list(dict.fromkeys(lst)). No order: list(set(lst)). For unhashable elements, use a tracking loop.

•dict.fromkeys() preserves order
•set() is faster but unordered

lst = [3, 1, 4, 1, 5, 3]

# Preserving order
print(list(dict.fromkeys(lst)))  # [3, 1, 4, 5]

# Not preserving order
print(list(set(lst)))  # order varies

[3, 1, 4, 5]
[1, 3, 4, 5]

list(set(lst)) does NOT preserve order

Question 16 / 20

What is frozenset and when would you use it?

frozenset is an immutable version of set. Since it is immutable, it is hashable and can be used as:

A dictionary key
An element of another set
An element of a frozenset

It supports all read-only set operations (|, &, -, ^, in, len) but NOT mutating operations (add, remove, update, etc.).

When to use:

When you need a set as a dict key or set element
When you want to guarantee a set will not be modified
For representing fixed collections of unique items

Pseudo Code

frozenset([1, 2, 3])  # immutable set

Supports: |, &, -, ^, in, len, iteration
Does NOT support: add, remove, update, discard

Hashable: can be dict key or set element

Code

# Creation
fs = frozenset([1, 2, 3, 2, 1])
print(fs)       # frozenset({1, 2, 3})
print(type(fs)) # <class 'frozenset'>

# Immutable -- cannot modify
try:
    fs.add(4)
except AttributeError as e:
    print(f"Error: {e}")  # 'frozenset' has no attribute 'add'

# Set operations work (return new frozensets)
fs1 = frozenset([1, 2, 3])
fs2 = frozenset([2, 3, 4])
print(fs1 | fs2)   # frozenset({1, 2, 3, 4})
print(fs1 & fs2)   # frozenset({2, 3})
print(fs1 - fs2)   # frozenset({1})
print(fs1 ^ fs2)   # frozenset({1, 4})

# As dict key
permissions = {
    frozenset(["read"]): "viewer",
    frozenset(["read", "write"]): "editor",
    frozenset(["read", "write", "admin"]): "admin"
}

user_perms = frozenset(["read", "write"])
print(permissions[user_perms])  # 'editor'

# As set element
groups = {
    frozenset([1, 2]),
    frozenset([3, 4]),
    frozenset([1, 2])  # duplicate, ignored
}
print(len(groups))  # 2

# Convert between set and frozenset
s = {1, 2, 3}
fs = frozenset(s)
s2 = set(fs)
print(s == s2)  # True

# Membership and iteration
fs = frozenset([10, 20, 30])
print(20 in fs)  # True
for item in fs:
    print(item, end=" ")
print()  # 10 20 30

frozenset({1, 2, 3})
<class 'frozenset'>
Error: 'frozenset' object has no attribute 'add'
frozenset({1, 2, 3, 4})
frozenset({2, 3})
frozenset({1})
frozenset({1, 4})
editor
2
True
True
10 20 30

Key Points

•frozenset is an immutable, hashable set
•Can be used as dict key or set element
•Supports all read-only set operations
•Cannot add, remove, or modify elements
•frozenset operations return new frozensets

Gotchas

•frozenset operations with regular sets return frozensets
•An empty frozenset is frozenset(), not {}
•frozenset([1,2]) == {1,2} is True (cross-type equality)
•Cannot create a frozenset literal -- must use frozenset() constructor

frozenset is an immutable set. Hashable, so it can be a dict key or set element. Supports read-only operations (|, &, -, in) but not mutation (add, remove).

•Immutable and hashable
•Can be dict key or set element

fs = frozenset([1, 2, 3])
# fs.add(4)  # AttributeError!

# As dict key
d = {frozenset(["read", "write"]): "editor"}
print(d[frozenset(["read", "write"])])  # 'editor'

editor

Cannot modify -- no add, remove, update

Question 17 / 20

How does the 'in' operator performance differ across data structures?

The in operator checks membership, but its performance varies dramatically by data structure:

Data Structure	`in` Performance	How it works
`list`	O(n)	Linear scan
`tuple`	O(n)	Linear scan
`set`	O(1) average	Hash lookup
`frozenset`	O(1) average	Hash lookup
`dict`	O(1) average (keys)	Hash lookup
`str`	O(n)	Substring search
`range`	O(1)	Mathematical check

Practical advice:

If you check membership repeatedly, convert a list to a set first
For 'x in dict', it checks keys, not values
range() has O(1) membership testing (mathematical, not iterative)
The O(1) for sets/dicts is average case; worst case is O(n) due to hash collisions

Pseudo Code

list/tuple: x in [1,2,...n] -> O(n) linear scan
set/dict: x in {1,2,...n} -> O(1) hash lookup
range: x in range(n) -> O(1) mathematical
str: sub in string -> O(n*m) substring search

Tip: convert list to set for repeated membership checks

Code

import timeit

# Create test data
n = 100_000
data_list = list(range(n))
data_tuple = tuple(range(n))
data_set = set(range(n))
data_dict = {i: True for i in range(n)}
data_range = range(n)

target = n - 1  # worst case for linear search

# Benchmark membership testing
print("Membership test for element at end:")
print(f"  list:  {timeit.timeit(lambda: target in data_list, number=100):.4f}s")
print(f"  tuple: {timeit.timeit(lambda: target in data_tuple, number=100):.4f}s")
print(f"  set:   {timeit.timeit(lambda: target in data_set, number=100):.6f}s")
print(f"  dict:  {timeit.timeit(lambda: target in data_dict, number=100):.6f}s")
print(f"  range: {timeit.timeit(lambda: target in data_range, number=100):.6f}s")

# Practical: repeated lookups
def find_common_bad(list1, list2):
    """O(n*m) -- checks membership in list"""
    return [x for x in list1 if x in list2]

def find_common_good(list1, list2):
    """O(n+m) -- convert to set first"""
    set2 = set(list2)
    return [x for x in list1 if x in set2]

a = list(range(10000))
b = list(range(5000, 15000))

print(f"\nFinding common elements:")
print(f"  list lookup: {timeit.timeit(lambda: find_common_bad(a, b), number=10):.4f}s")
print(f"  set lookup:  {timeit.timeit(lambda: find_common_good(a, b), number=10):.4f}s")

# range has O(1) membership
print(999_999_999 in range(1_000_000_000))  # True (instant, O(1))

# str 'in' checks substring
print("hello" in "say hello world")  # True (substring search)
print("xyz" in "say hello world")    # False

Membership test for element at end:
list:  0.0312s
tuple: 0.0276s
set:   0.000003s
dict:  0.000007s
range: 0.000005s

Finding common elements:
list lookup: 1.9830s
set lookup:  0.0016s
True
True
False

Key Points

•set/dict/frozenset: O(1) average membership testing
•list/tuple: O(n) linear scan
•range: O(1) mathematical check (not iteration)
•Convert list to set for repeated membership checks
•str 'in' does substring search, not element search

Gotchas

•O(1) for sets/dicts is average case -- worst case is O(n) with hash collisions
•dict 'in' checks keys, not values
•range O(1) only works for integer membership
•Creating a set from a list is O(n) -- only worthwhile if you check multiple times

in on sets/dicts is O(1), on lists/tuples is O(n). Convert lists to sets for repeated membership checks. range() also has O(1) membership.

•set/dict O(1), list/tuple O(n)
•Convert to set for repeated lookups

# O(n) -- slow for large lists
print(99999 in list(range(100000)))   # slow

# O(1) -- fast for sets
print(99999 in set(range(100000)))    # fast

# O(1) -- range uses math
print(99999 in range(100000))         # instant

True
True
True

Creating a set is O(n) -- only saves time with multiple lookups

Question 18 / 20

How do you merge two dictionaries in Python?

Several ways to merge dictionaries, from oldest to newest:

1. d1.update(d2) -- modifies d1 in-place **2. {**d1, **d2}** -- unpacking (Python 3.5+) 3. d1 | d2 -- merge operator (Python 3.9+) 4. d1 |= d2 -- in-place merge (Python 3.9+) 5. dict(d1, **d2) -- constructor (keys must be strings) 6. ChainMap(d2, d1) -- lazy virtual merge

In all cases, if both dicts have the same key, the right-side value wins (d2 overwrites d1).

Pseudo Code

d1.update(d2)     -- modifies d1 in-place, d2 values win
{**d1, **d2}      -- new dict, d2 values win
d1 | d2           -- new dict, d2 values win (3.9+)
d1 |= d2          -- in-place merge (3.9+)

All: right side wins on key conflicts

Code

d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}

# Method 1: update() -- modifies d1 in-place
merged = d1.copy()
merged.update(d2)
print(merged)  # {'a': 1, 'b': 3, 'c': 4}

# Method 2: ** unpacking (Python 3.5+)
merged = {**d1, **d2}
print(merged)  # {'a': 1, 'b': 3, 'c': 4}

# Can merge more than two
d3 = {"d": 5}
merged = {**d1, **d2, **d3}
print(merged)  # {'a': 1, 'b': 3, 'c': 4, 'd': 5}

# Method 3: | operator (Python 3.9+)
merged = d1 | d2
print(merged)  # {'a': 1, 'b': 3, 'c': 4}

# Method 4: |= in-place (Python 3.9+)
d1_copy = d1.copy()
d1_copy |= d2
print(d1_copy)  # {'a': 1, 'b': 3, 'c': 4}

# Deep merge (nested dicts)
def deep_merge(d1, d2):
    result = d1.copy()
    for key, value in d2.items():
        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
            result[key] = deep_merge(result[key], value)
        else:
            result[key] = value
    return result

config_default = {"db": {"host": "localhost", "port": 5432}, "debug": False}
config_override = {"db": {"port": 3306}, "debug": True}

merged = deep_merge(config_default, config_override)
print(merged)  # {'db': {'host': 'localhost', 'port': 3306}, 'debug': True}

# ChainMap -- lazy merge (doesn't create new dict)
from collections import ChainMap
chain = ChainMap(d2, d1)  # d2 checked first
print(chain["a"])  # 1 (from d1)
print(chain["b"])  # 3 (from d2, found first)
print(dict(chain))  # {'a': 1, 'b': 3, 'c': 4}

{'a': 1, 'b': 3, 'c': 4}
{'a': 1, 'b': 3, 'c': 4}
{'a': 1, 'b': 3, 'c': 4, 'd': 5}
{'a': 1, 'b': 3, 'c': 4}
{'a': 1, 'b': 3, 'c': 4}
{'db': {'host': 'localhost', 'port': 3306}, 'debug': True}
1
3
{'a': 1, 'b': 3, 'c': 4}

Key Points

•| operator (Python 3.9+) is the cleanest syntax
•{**d1, **d2} works in Python 3.5+
•update() modifies in-place
•Right side wins on key conflicts
•For nested dicts, implement deep_merge manually

Gotchas

•update() modifies the dict in-place and returns None
•{**d1, **d2} creates a new dict (does not modify originals)
•Shallow merge only -- nested dicts are not recursively merged
•dict(d1, **d2) only works when d2 keys are strings

Python 3.9+: d1 | d2 (new dict), d1 |= d2 (in-place). 3.5+: {**d1, **d2}. Any version: d1.update(d2) (in-place). Right side wins on conflicts.

•| operator in 3.9+, ** unpacking in 3.5+
•Right side wins on conflicts

d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}

merged = {**d1, **d2}  # {'a': 1, 'b': 3, 'c': 4}
# or Python 3.9+:
# merged = d1 | d2

update() modifies in-place, | creates new dict

Question 19 / 20

How do you flatten a nested list in Python?

Flattening a nested list means converting [[1,2],[3,4]] to [1,2,3,4].

For one level deep:

List comprehension: [x for sub in nested for x in sub]
itertools.chain.from_iterable(nested)
sum(nested, []) (slow, creates many intermediates)

For arbitrary depth: 4. Recursive function 5. collections.abc + recursion for robustness

The list comprehension is the most Pythonic for single-level flattening.

Pseudo Code

One level: [x for sub in nested for x in sub]
One level: itertools.chain.from_iterable(nested)

Arbitrary depth: recursive function
  if element is list: flatten recursively
  else: yield element

Code

# One level deep -- list comprehension
nested = [[1, 2], [3, 4], [5, 6]]
flat = [x for sub in nested for x in sub]
print(flat)  # [1, 2, 3, 4, 5, 6]

# One level -- itertools.chain
from itertools import chain
flat = list(chain.from_iterable(nested))
print(flat)  # [1, 2, 3, 4, 5, 6]

# One level -- sum (slow, avoid for large lists)
flat = sum(nested, [])
print(flat)  # [1, 2, 3, 4, 5, 6]

# Arbitrary depth -- recursive generator
def flatten(lst):
    for item in lst:
        if isinstance(item, (list, tuple)):
            yield from flatten(item)
        else:
            yield item

deep = [1, [2, [3, [4, 5]], 6], 7]
print(list(flatten(deep)))  # [1, 2, 3, 4, 5, 6, 7]

# More robust version using Iterable ABC
from collections.abc import Iterable

def flatten_all(lst, ignore_types=(str, bytes)):
    for item in lst:
        if isinstance(item, Iterable) and not isinstance(item, ignore_types):
            yield from flatten_all(item, ignore_types)
        else:
            yield item

mixed = [1, "hello", [2, [3, "world"]], (4, 5)]
print(list(flatten_all(mixed)))  # [1, 'hello', 2, 3, 'world', 4, 5]

# Flatten dict of lists
data = {"a": [1, 2], "b": [3, 4], "c": [5]}
all_values = [v for values in data.values() for v in values]
print(all_values)  # [1, 2, 3, 4, 5]

# Performance comparison for single level
import timeit

nested = [[i] for i in range(10000)]

comp_time = timeit.timeit(lambda: [x for sub in nested for x in sub], number=1000)
chain_time = timeit.timeit(lambda: list(chain.from_iterable(nested)), number=1000)
print(f"Comprehension: {comp_time:.4f}s")
print(f"chain: {chain_time:.4f}s")

[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7]
[1, 'hello', 2, 3, 'world', 4, 5]
[1, 2, 3, 4, 5]
Comprehension: 0.1813s
chain: 0.1546s

Key Points

•List comprehension for one-level: [x for sub in nested for x in sub]
•itertools.chain.from_iterable for one-level (more efficient)
•Recursive generator with yield from for arbitrary depth
•Exclude strings from flattening (they are iterable but should stay intact)
•Avoid sum(nested, []) for large lists -- O(n^2)

Gotchas

•sum(nested, []) is O(n^2) because it creates intermediate lists
•Strings are iterable -- recursive flatten must exclude them or it infinite-loops
•Deep recursion can hit Python's recursion limit (default 1000)
•Reading order: [x for sub in nested for x in sub] -- outer loop first

One level: [x for sub in nested for x in sub] or itertools.chain.from_iterable(). Arbitrary depth: recursive generator with yield from.

•Comprehension: [x for sub in nested for x in sub]
•chain.from_iterable for performance

nested = [[1, 2], [3, 4], [5, 6]]
flat = [x for sub in nested for x in sub]
print(flat)  # [1, 2, 3, 4, 5, 6]

from itertools import chain
flat = list(chain.from_iterable(nested))
print(flat)  # [1, 2, 3, 4, 5, 6]

[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]

Avoid sum(nested, []) -- it's O(n^2)

Question 20 / 20

How do you create and work with nested data structures in Python?

Nested data structures are combinations of lists, dicts, tuples, and sets within each other. They are very common in Python, especially when working with JSON data, configurations, and APIs.

Common patterns:

List of dicts: Records/rows of data
Dict of lists: Grouped data
Dict of dicts: Nested configuration, tree structures
List of lists: Matrix, grid, table

Access: Chain indexing: data['key'][0]['nested_key']

Safe access: Use .get() for dicts and try/except for potential errors.

JSON-like structures are the most common nested pattern since Python dicts map naturally to JSON objects.

Pseudo Code

List of dicts: [{"name": "Alice", "age": 30}, ...]
Dict of lists: {"names": ["Alice", "Bob"], "ages": [30, 25]}
Dict of dicts: {"users": {"alice": {"age": 30}}}
List of lists: [[1, 2], [3, 4]] (matrix)

Access: data['users']['alice']['age']
Safe: data.get('users', {}).get('alice', {}).get('age', None)

Code

# List of dicts (most common: records/rows)
users = [
    {"name": "Alice", "age": 30, "skills": ["Python", "SQL"]},
    {"name": "Bob", "age": 25, "skills": ["JavaScript", "React"]},
    {"name": "Charlie", "age": 35, "skills": ["Python", "Go"]}
]

# Access nested data
print(users[0]["name"])         # 'Alice'
print(users[1]["skills"][0])    # 'JavaScript'

# Query: find users who know Python
python_users = [u["name"] for u in users if "Python" in u["skills"]]
print(python_users)  # ['Alice', 'Charlie']

# Dict of dicts (configuration, tree)
config = {
    "database": {
        "host": "localhost",
        "port": 5432,
        "credentials": {
            "username": "admin",
            "password": "secret"
        }
    },
    "server": {
        "host": "0.0.0.0",
        "port": 8080
    }
}

print(config["database"]["credentials"]["username"])  # 'admin'

# Safe nested access
def safe_get(data, *keys, default=None):
    for key in keys:
        if isinstance(data, dict):
            data = data.get(key, default)
        elif isinstance(data, (list, tuple)) and isinstance(key, int):
            try:
                data = data[key]
            except IndexError:
                return default
        else:
            return default
    return data

print(safe_get(config, "database", "port"))            # 5432
print(safe_get(config, "database", "missing", default="N/A"))  # 'N/A'
print(safe_get(config, "nonexistent", "key", default=None))   # None

# Building nested structures
from collections import defaultdict

# Auto-vivifying dict (nested defaultdict)
def tree():
    return defaultdict(tree)

t = tree()
t["users"]["alice"]["age"] = 30
t["users"]["bob"]["age"] = 25
print(t["users"]["alice"]["age"])  # 30

# List of lists (matrix)
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Transpose
transposed = list(zip(*matrix))
print(transposed)  # [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

# Working with JSON
import json

json_string = '{"name": "Alice", "hobbies": ["reading", "coding"]}'
data = json.loads(json_string)
print(data["hobbies"][0])  # 'reading'

# Convert back to JSON
print(json.dumps(data, indent=2))

Alice
JavaScript
['Alice', 'Charlie']
admin
5432
N/A
None
30
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
reading
{
"name": "Alice",
"hobbies": [
"reading",
"coding"
]
}

Key Points

•Chain indexing for nested access: data['key'][0]['field']
•Use .get() chains for safe nested dict access
•List of dicts is the most common pattern (like database rows)
•defaultdict(tree) creates auto-vivifying nested dicts
•json.loads/dumps for JSON <-> Python conversion

Gotchas

•Deep nesting makes code hard to read -- consider flattening or using classes
•Shallow copy of nested structures shares inner objects
•JSON keys are always strings -- int keys become strings after json.dumps/loads
•Modifying nested data in place can cause unexpected side effects with shared references

Nested structures combine lists, dicts, tuples. Access with chained indexing: data['key'][0]['field']. Use .get() for safe access. List of dicts is the most common pattern.

•Chain indexing for access
•Use .get() chains for safety

users = [{"name": "Alice", "skills": ["Python"]}]
print(users[0]["skills"][0])  # 'Python'

# Safe access
config = {"db": {"port": 5432}}
print(config.get("db", {}).get("port", 3306))  # 5432
print(config.get("cache", {}).get("port", 6379))  # 6379

Python
5432
6379

Shallow copy shares nested objects

Built by onllm.dev

Home GitHub Support awesomePrep