Question 1

bool is a subclass of int

Accepted Answer

bool is a subclass of int in Python, so True has the integer value 1 and False has the value 0. Arithmetic on booleans works just like arithmetic on integers. This is why sum([True, False, True, True]) counts the number of True values - a pattern that comes up often in data filtering.

Question 2

Reference semantics on list assignment

Accepted Answer

Assignment binds a name to an object, not a copy of it. Both x and y point to the same list, so appending through y also changes what x sees. The tempting wrong answer is [1, 2, 3] - that would only be correct if y were a copy, which requires y = x[:] or y = list(x).

Question 3

String + int raises TypeError

Accepted Answer

Python does not silently coerce types the way JavaScript does. Adding a string to an integer raises a TypeError at runtime. You must convert explicitly: int("3") + 3 gives 6, and str(3) + "3" gives "33". This strict behavior is intentional - Python won't guess at your intent.

Question 4

is vs ==

Accepted Answer

a == b calls a.__eq__(b) and asks whether the two objects represent the same value. a is b compares their id() - it returns True only if they are literally the same object in memory. The practical rule: use == for value comparisons, and reserve is for checking against singletons like None, True, and False. Writing x == None works but is considered bad style because a custom class could define __eq__ to return True unexpectedly; x is None is always correct.

Question 5

isinstance vs type() equality

Accepted Answer

isinstance checks the full inheritance chain, so isinstance(True, int) returns True because bool is a subclass of int. type(True) == int returns False because the exact type is bool, not int. In practice you almost always want the subclass-aware check, especially when working with third-party types that extend built-ins.

Question 6

Shallow copy still shares inner objects

Accepted Answer

a[:] creates a shallow copy - a new outer list, but the inner lists are still shared between a and b. b[0] and a[0] point to the same inner list object, so appending to b[0] also changes a[0]. To get fully independent copies of nested structures, you need copy.deepcopy(a).

Question 7

None vs falsy - index at 0

Accepted Answer

The target 1 is at index 0, so first_index returns 0. The problem is that 0 is falsy in Python, so 'if index' evaluates to False even though the item was found. The correct check is 'if index is not None', which distinguishes a valid result of 0 from an actual absence of the item. This is one of the most common bugs in Python search functions.

Question 8

Hashability and dict keys

Accepted Answer

Only hashable objects can be dictionary keys. Tuples are hashable when all their elements are immutable - (1, 2, 3) qualifies. Lists, sets, and dicts are mutable and not hashable. The tricky option is (1, [2, 3]): even though it's a tuple, it contains a mutable list, making the whole tuple unhashable. In interview problems, use tuples to key dictionaries with coordinates or character-count pairs.

Question 9

bytes vs str

Accepted Answer

str is a sequence of Unicode code points - you think in terms of characters and symbols. bytes is a sequence of integers from 0 to 255, representing raw binary data. Converting between them requires an explicit encoding: 'hello'.encode('utf-8') gives b'hello', and b'hello'.decode('utf-8') gives 'hello' back. A common mistake is mixing them, which raises a TypeError because Python 3 will not silently coerce one to the other.

Question 10

Integer identity caching

Accepted Answer

CPython caches small integer objects in the range -5 to 256, so a and b are the exact same object in memory. Integers outside that range are not cached, so c and d are two separate objects with the same value - 'is' tests identity, not equality. The takeaway: always use == to compare values; 'is' is for identity checks like 'x is None'. Relying on integer identity caching is an implementation detail, not a language guarantee.

Question 11

Augmented assignment on immutable vs mutable

Accepted Answer

Tuples are immutable, so += cannot mutate the existing object in place. Instead, Python creates a brand-new tuple (1, 2, 3) and rebinds x to it, leaving y still pointing to the original (1, 2). Compare this to x += [3] on a list: lists are mutable, so += calls list.__iadd__ which mutates in place, and both names see the change. This difference in behavior between mutable and immutable types under += is a frequent interview question.

Question 12

Chained assignment and mutation

Accepted Answer

Chained assignment 'a = b = []' creates one list and binds both names to it - it does not create two separate empty lists. Every mutation through either name changes the same object, so after both appends a is [1, 2] and a is b is True. To get two independent lists, write a = []; b = []. This is the same reference-semantics rule that applies to all Python assignment.

Question 13

Reference counting

Accepted Answer

Every Python object has a reference count field. Binding a name or storing in a list increments it; rebinding or deleting decrements it. When the count hits zero, CPython frees the memory right away - no waiting for a garbage collection cycle. The limitation is reference cycles (a -> b -> a): the counts never reach zero even though neither object is reachable, which is why Python also has a cyclic garbage collector on top of reference counting.

Variables & Types