Question 1

Dictionary missing key behavior

Accepted Answer

d.get(key, default) returns the default when the key is absent instead of raising a KeyError. Since "c" is not in d, the call returns 99. Using .get() with a default is the idiomatic way to handle optional keys - it keeps the code clean and avoids a try/except block for a very common case.

Question 2

List append() complexity

Accepted Answer

Python lists over-allocate storage, so most appends just write to an already-reserved slot in O(1). Occasionally the buffer fills and Python copies the list to a larger allocation - that copy is O(n), but it happens so rarely that the cost spreads out to O(1) per append on average. The key word is "amortized" - the worst case exists, but it is not representative of typical behavior.

Question 3

Set membership test

Accepted Answer

Sets only store unique elements, so adding 2 a second time has no effect - the set already contains it. Adding 4 does insert a new element, bringing the count from 3 to 4. This is the core property of sets: duplicates are silently ignored.

Question 4

list vs tuple

Accepted Answer

The defining difference is mutability: you can append, remove, or reassign elements in a list, but a tuple is fixed after creation. Both are ordered sequences that support indexing and can hold mixed types. Tuples are commonly used for things that should not change - function return values, dictionary keys, or fixed configuration data.

Question 5

dict vs set

Accepted Answer

Both use hash tables internally, which is why both offer O(1) average-case lookup. The structural difference is that a dict pairs each key with a value ({k: v}), while a set is just a collection of unique elements ({v}). You can think of a set as a dict where you threw away the values - Python even uses similar literal syntax for both.

Question 6

Dictionary insertion order

Accepted Answer

Starting in Python 3.7, the dict implementation guarantees that iteration yields keys in the order they were first inserted. Before 3.7 this was an implementation detail of CPython 3.6 but not part of the language spec. You can rely on this today in all modern Python, but if you need to communicate intent clearly, an explicit sorted() call or collections.OrderedDict still reads better.

Question 7

List reference vs copy

Accepted Answer

b = a makes b point at the same list object as a, so appending through b also grows a - len(a) becomes 4. a[:] creates a shallow copy, so c is a separate list. Appending 5 to c does not affect a. The difference between assignment and slicing is one of the most common sources of subtle bugs in Python.

Question 8

Tuple vs list as dict key

Accepted Answer

Dictionary keys must be hashable. Tuples are hashable because they are immutable, so (1, 2) works fine as a key. Lists are mutable and therefore not hashable - Python raises a TypeError when you try to use one as a key. After the TypeError the dict still has only the one entry added with the tuple, so len(d) is 1.

Question 9

When to prefer deque over list

Accepted Answer

Removing from the front of a Python list with pop(0) is O(n) because every remaining element shifts left by one slot. collections.deque is a doubly-linked structure where both appends and pops from either end are O(1). For queue workloads - first in, first out - deque is the correct choice and the performance difference becomes visible at a few thousand iterations.

Question 10

Nested list multiplication trap

Accepted Answer

The * 2 operator does not create two independent inner lists - it creates two references to the same inner list. So grid[0] and grid[1] point at the same object, and mutating one mutates both. To build a genuine 2D grid, use a list comprehension: [[0] * 3 for _ in range(2)]. This is one of the most common Python gotchas in coding interviews and data pipeline code alike.

Question 11

Set symmetric difference

Accepted Answer

The ^ operator on sets computes the symmetric difference - elements that are in one set or the other, but not both. 3 and 4 appear in both a and b, so they are excluded. 1 and 2 are only in a; 5 and 6 are only in b. Symmetric difference comes up whenever you need to find what changed between two snapshots - the elements unique to each side represent what was added or removed.

Question 12

dict.fromkeys() shared mutable value

Accepted Answer

dict.fromkeys(keys, value) maps every key to the same single value object. When that value is a mutable list, all keys share the same list - so appending to d['x'] is visible through d['y'] and d['z']. To get independent lists per key, use a comprehension instead: {k: [] for k in ['x', 'y', 'z']}. This is the same aliasing trap as list multiplication, just expressed through a different API.

Data Structures