Lists, dicts, sets, and comprehensions

Three containers, three different jobs. A list keeps order and allows duplicates. A set has no order and no duplicates — membership is what it is for. A dict maps a key to a value, and since Python 3.7 the language guarantees it iterates in insertion order. A set makes no such promise: never rely on the order a set comes out in.

scores = [90, 75, 90, 60]          # order and duplicates both matter
seen_ids = {1, 4, 4, 9}             # {1, 4, 9} — duplicates collapse
by_id = {1: "Nino", 4: "Ana"}        # look up by key

x in a_set and x in a_dict (checking the keys) are both O(1) on average. x in a_list is O(n) — it has to scan. Converting a list you check membership on repeatedly into a set is one of the cheapest optimisations available.

Comprehensions

A comprehension is a loop and a condition read in the order you think about them: what to keep, then where it comes from, then the filter.

nums = [1, 2, 3, 4, 5, 6]
evens_doubled = [n * 2 for n in nums if n % 2 == 0]   # [4, 8, 12]

by_parity = {n: "even" if n % 2 == 0 else "odd" for n in nums}
unique_lengths = {len(w) for w in ["a", "bb", "cc", "ddd"]}   # {1, 2, 3}

The list, dict, and set versions are the same shape with different brackets. Reach for a comprehension over a hand-written loop with .append the moment the loop's only job is building a new collection — it is usually shorter and, once the pattern is familiar, faster to read.

Try it

Hashability

A dict key or a set member must be hashable. Among the built-in types that means the immutable ones: str, int, float, bool, frozenset, and tuple (if everything inside the tuple is itself hashable) all work. list, dict, and set do not — Python refuses outright, because a mutable key could change after it was hashed and silently break the lookup.

{[1, 2]: "value"}    # TypeError: unhashable type: 'list'
{(1, 2): "value"}    # fine — a tuple is immutable

Interviews in other languages probe the same idea: a Java HashMap key that is mutated after insertion is just as lost, Java simply does not stop you from using one.

Common mistakes

• Removing items from a list while looping over it. The loop's index keeps moving while the items shift left, so the element right after each removal is never looked at — one 2 survives below.
• Adding or deleting dict keys while iterating over the dict. Python stops you with a RuntimeError; iterate over list(d) or build a new dict with a comprehension instead.
• Checking x in some_list inside a loop over another big list. Each check is a scan, so the whole thing is quadratic; build a set once.

What interviewers ask

• Why is in fast on a set and slow on a list? A set is a hash table, so a lookup hashes the value and checks one bucket on average; a list compares element by element.
• What can be a dict key? Anything hashable whose hash never changes: strings, numbers, tuples of hashable values, frozensets — not lists.
• How would you count occurrences of each word? A dict with .get(w, 0) + 1, or collections.Counter; then say how ties are broken, because "the most common" is ambiguous until you do.