Python Interview Questions: The Tested Question Set Companies Actually Ask

Q1 What is the difference between a list and a tuple, and when does it matter?

Easy

A list is mutable and a tuple is immutable. The practical point interviewers want: because tuples are immutable and hashable, they can be dictionary keys or set members, while lists cannot. Tuples also carry a small memory and speed advantage for fixed collections.

Q2 How does is differ from ==?

Easy

== compares values, is compares identity, meaning whether two names point to the same object in memory. A frequent trap: small integers and short strings are cached by CPython, so a is b can return True for 256 but False for 257. The rule to state is that is should be reserved for None checks.

Q3Explain mutable versus immutable with a bug it causes.

Easy

Strings, numbers, and tuples are immutable; lists, dicts, and sets are mutable. The classic bug is a mutable default argument:

def add(item, bucket=[]):   # bucket is created once    bucket.append(item)    return bucket add(1)   # [1]add(2)   # [1, 2]  not [2]

The fix is bucket=None then assign inside the function.

Q4 What does a list comprehension give over a loop, and where is a generator better?

Easy+

A comprehension is faster and reads as one expression. A generator expression, written with parentheses, produces items lazily and holds one at a time, so it wins on memory for large or infinite streams. Saying "use a generator when the full list will not fit comfortably in memory" lands well.

Q5 What is the Global Interpreter Lock, and how does it shape design?

Medium

The GIL is a mutex in CPython that lets only one thread execute Python bytecode at a time. Threads still help with input and output bound work because the lock releases during blocking calls, but they do not speed up CPU bound work. For parallel computation the answer is multiprocessing or a native extension. Worth adding: the free-threaded build introduced in 3.13 is moving toward removing this constraint.

Q6 How does Python manage memory and garbage collection?

Medium

CPython uses reference counting as the primary mechanism, freeing an object the moment its count hits zero. A cyclic garbage collector runs on top to catch reference cycles that counting alone cannot reclaim. Mentioning that objects live in a private heap managed by the interpreter shows depth.

Q7 Deep copy versus shallow copy: what actually differs?

Medium

A shallow copy duplicates the outer container but shares references to nested objects, so mutating a nested list shows up in both copies. A deep copy recursively duplicates everything. Naming copy.copy and copy.deepcopy and the performance cost of the deep version is the complete answer.

Q8 What is the difference between __init__ and __new__?

Medium+

__new__ creates and returns the instance; __init__ initialises the already-created instance. Overriding __new__ is rare and shows up when subclassing immutable types or building singletons. Most day-to-day code only touches __init__.

Q9 Explain method resolution order and how Python handles multiple inheritance.

Hard

Python uses the C3 linearisation algorithm to build a single, predictable ordering of parent classes. ClassName.__mro__ or .mro() reveals it. The diamond problem is resolved by this order, and super() follows the MRO rather than calling a parent directly, which is why cooperative super() calls matter in mixins.

Q10 Class variable versus instance variable, with a gotcha.

Medium

A class variable is shared across instances; an instance variable belongs to one object. The gotcha is a mutable class variable such as a shared list, where appending through one instance is visible to all. Reassigning through an instance quietly creates a new instance variable instead.

Q11 What do @staticmethod and @classmethod do?

Medium

A class method receives the class as its first argument (cls) and is commonly used for alternative constructors. A static method receives neither instance nor class and is a plain function grouped inside the class for organisation. Giving the from_string factory example for a class method scores well.

Q12 Write a decorator that times a function.

Medium

import functools, time def timed(fn):    @functools.wraps(fn)    def wrapper(*args, **kwargs):        start = time.perf_counter()        result = fn(*args, **kwargs)        print(f"{fn.__name__}: {time.perf_counter()-start:.4f}s")        return result    return wrapper

The detail interviewers wait for is functools.wraps, which preserves the wrapped function's name and docstring. Forgetting it is a common ding.

Q13 What is the difference between an iterator and a generator?

Medium

An iterator is any object implementing __iter__ and __next__. A generator is a simpler way to build one using yield, which suspends and resumes state automatically. Generators are lazy and memory-light, which is the reason to reach for them on large data.

Q14 What does yield do, and how does a generator hold state?

Medium+

yield pauses the function, returns a value, and freezes local state until the next call resumes right after the yield. Because state lives in the frame, the whole sequence never needs to exist in memory at once.

Q15 Explain async and await in plain terms.

Hard

Asyncio runs a single-threaded event loop. await hands control back to the loop while a coroutine waits on I/O, letting other coroutines run in the gap. It is concurrency without threads, ideal for thousands of network calls, and it does not help with CPU bound work because nothing yields during pure computation.

Q16What is a context manager and why use with?

Medium

A context manager defines __enter__ and __exit__ so setup and cleanup happen automatically, even if an exception fires. The everyday case is file handling, where with open(...) guarantees the file closes. The contextlib.contextmanager decorator builds one from a generator.

Q17 Solve Two Sum and explain the trade-off.

Medium

def two_sum(nums, target):    seen = {}    for i, n in enumerate(nums):        need = target - n        if need in seen:            return [seen[need], i]        seen[n] = i    return []

The brute force is O(n squared). The hash map version trades O(n) extra space for O(n) time. Stating that trade-off out loud is often worth more than the code itself.

Q18 Find the first non-repeating character in a string.

Medium

from collections import Counter def first_unique(s):    counts = Counter(s)    for i, ch in enumerate(s):        if counts[ch] == 1:            return i    return -1

Reaching for collections.Counter signals fluency with the standard library, a detail Salesforce and Uber reviewers note.

Q19 Reverse a singly linked list in place.

Hard

def reverse(head):    prev = None    while head:        nxt = head.next        head.next = prev        prev = head        head = nxt    return prev

The three-pointer walk is the expected O(1) space solution. Doing it recursively is fine too, but the interviewer will ask about stack depth.

Q20 How would exceptions be handled in a service that must never crash on one bad record?

Medium

Catch the narrowest exception type around the risky operation, log the offending record with context, continue the loop, and surface a count of failures at the end. The anti-pattern to call out is a bare except: that swallows everything including KeyboardInterrupt.