Data Types

A list is mutable — you append, insert, or remove; a tuple is immutable once created. They also differ in CPython: list over-allocates so append is amortized O(1), while tuple is fixed-size, more compact, and cached via free lists.

A mapping gives keyed access to values via methods like get, keys, values, items. The canonical one is dict; the stdlib adds defaultdict, OrderedDict, Counter. Keys must be hashable; values may be anything.

A set is an unordered collection of unique, hashable elements with no indexing or slicing, with fast in checks and the |, &, - operators. set is mutable (add, remove); frozenset is its immutable, hashable twin, usable as a dict key.

It returns a new sub-sequence from start (inclusive) up to stop (exclusive), taking every step-th item. All three are optional; negative indices count from the end and s[:] makes a shallow copy. Out-of-range bounds are clamped, not errors.

No — str is immutable. s[0] = 'x' raises TypeError; every "edit" like replace or + builds a brand-new string object and rebinds the name, leaving the original untouched. Immutability is what makes strings hashable and valid dict keys.

Any hashable object can be a key: int, str, a hashable tuple, even a function or module. list, dict, set cannot — they're mutable and unhashable. A tuple's hash is recursive, so a tuple holding a dict inside is itself unhashable.

zero

0 None False

2 avocado

3.5 3 -4 2

C

False True

3x3.14=9.4

2 8 3.0

4 3

Prints start, then a TypeError

n p 6

[[5, 0], [5, 0]]

True False 1

zero 4 True

6 5

A sequence is an ordered iterable with integer-index access via __getitem__ and a length via __len__. Built-ins: list, tuple, range, str, bytes. It supports indexing, slicing, in, len(), and iteration.

4 2 [1]

bcd ace ef

None 1

[2, 3] 2 3

Prints hello, then a TypeError

A TypeError is raised

(1) default — or returns the first truthy operand (an empty list is falsy). (2) 5 — the first truthy value. (3) '' — and returns the first falsy operand, or the last if all are truthy. or/and return one of the operands, not a bool — the basis of x = val or default.

False True False True

The right side is iterated and bound positionally to the targets; the counts must match or you get a ValueError. A single starred target like a, *rest = seq absorbs the surplus into a list, so it can sit anywhere. It works on any iterable.

range(n) yields integers 0..n-1 lazily; enumerate(seq) yields (index, item) pairs; zip(a, b) yields tuples pairing elements until the shortest input ends. All three are lazy iterators in Python 3 — wrap in list() to materialize. zip(*rows) transposes.

They return dynamic view objects, not lists. A view reflects later changes to the dict live, supports len(), iteration, and in, and the keys/items views behave set-like. Python 2 returned fresh lists here; Python 3 made views the default.

An object is hashable if it has a stable __hash__ (constant over its lifetime) plus __eq__, and equal objects must hash equally. Immutable built-ins (int, str, a hashable tuple) qualify; mutable list, dict, set do not.

True False then True True. CPython caches small integers from −5 to 256, so a and b are the same object (is → True); 257 is outside that range, so c and d are distinct objects (is → False). == compares value and is always True. Use is only for identity (e.g. x is None).

dict and set are hash tables: lookup averages O(1) — Python hashes the key and jumps to a slot. list and tuple have no value index, so x in seq scans linearly at O(n). The trade-off: hashing needs hashable elements and more memory.

Element by element, left to right (lexicographic). == is True only when lengths match and every pair is equal. For <, Python compares items at the first difference; if one side runs out first, the shorter is smaller. Items must be comparable or it raises TypeError.

str is an immutable sequence of Unicode code points; bytes is an immutable sequence of raw 0–255 octets. encode turns a str into bytes through a codec like UTF-8; decode reverses it. Mixing them, or guessing the wrong codec, raises UnicodeError — Python 3 does no implicit conversion.

Prints 5, 2, 2. In Python bool is a subclass of int, with True == 1 and False == 0, so booleans participate directly in arithmetic. True + 4 is 1 + 4, and sum of booleans counts the True values. This is why summing a list of conditions counts how many are true.

All three print True. Python chains comparisons with an implicit and: (1) is 1 < 2 and 2 < 3; (2) is 3 > 2 and 2 == 2; (3) is (False == False) and (False in [False]) → True and True. The third surprises people because == and in chain together.

A hash collision is two different keys producing the same hash value, or landing in the same table slot. dict and set resolve it by probing other slots, so a collision costs lookup speed, not correctness — it never returns a wrong value.

Both print {1: 1, 2: 2, 3: 3}. b = a binds a second name to the same dict object — it does not copy it, so edits through either name are visible through both. To get an independent dict use a.copy() or dict(a) (a shallow copy). a is b is True here.

Prints [1, 2, 3, 'a', 'b', 'c']. extend iterates its argument and appends each item; a string is iterable over its characters, so each char is added separately. To add the whole string as one element use l.append('abc'), which gives [1, 2, 3, 'abc'].

Take the first element of each tuple: [t[0] for t in data]. A one-element tuple is written ('x',) with a trailing comma, so indexing [0] pulls the single value out. Equivalent forms are [v for (v,) in data] (tuple unpacking in the loop target) or list(map(lambda t: t[0], data)).

False. 0.1 + 0.2 is 0.30000000000000004 because these values are not exactly representable in binary floating point, so the sum differs from the literal 0.3. Compare with a tolerance instead — math.isclose(0.1 + 0.2, 0.3).

Double the braces: print(f'Curly brackets: {{}}') prints Curly brackets: {}. In an f-string {{ is an escaped literal { and }} a literal }; a single {...} is a replacement field that must contain an expression, so an empty {} raises a SyntaxError at compile time.

Prints z then y. A negative index counts from the end: -1 is the last element, -2 the second-to-last. It is equivalent to var[len(var) - 1]. This works on any sequence — str, list, tuple — and an out-of-range negative index raises IndexError.

[1, 2, 3, 4] then [1, 2, 3]. += on a list calls __iadd__, mutating the object in place, so b (same object) sees it. a = a + [4] builds a new list and rebinds a, leaving b pointing at the original — mutation versus rebinding.

[[1, 0, 0], [1, 0, 0], [1, 0, 0]]. The outer * 3 copies the reference to the same inner list three times, so mutating one row mutates all. Fix with a comprehension that builds independent rows: grid = [[0] * 3 for _ in range(3)].

(1) succeeds → ([1, 99], 2): the tuple is immutable, but the list it references is mutable. (2) is the famous trap: += mutates the list AND tries to reassign t[0], so it raises TypeError — yet the list is still mutated to [1, 99, 100]. The operation half-succeeds.

// is floor division, so average([1, 2]) returns 1, not 1.5. An empty list also raises ZeroDivisionError. Fix: use / for true division and guard the empty case: return sum(nums) / len(nums) if nums else 0.

counts[w] += 1 reads counts[w] before the key exists → KeyError on the first sight of each word. Fix: counts[w] = counts.get(w, 0) + 1, or use collections.defaultdict(int), or simply collections.Counter(text.split()).

Removing items during iteration shifts the indices under the iterator, so it skips elements. Never mutate a list while iterating it. Fix: iterate over a copy (for n in nums[:]:), or rebuild with a comprehension: nums = [n for n in nums if n % 2].

Strings are immutable, so each s += ... builds a brand-new string — O(n²) for n words, slow on large inputs. It is functionally correct, but the complexity is the bug. Fix: return ' '.join(words), which is O(n) and idiomatic.

A CPython dict is a sparse hash table; each slot holds the key's hash plus key and value refs. Lookup takes the hash's low bits as a slot offset and probes on collision. About a third of slots stay empty; when full it grows and entries reinsert.

It evaluates to {True: 'c'}. True, 1, 1.0 are equal (True == 1 == 1.0) and hash identically, so they're one key. The first inserted key (True) is kept, but each assignment overwrites the value — final value 'c'.