1. Overview
This roundup covers the Python questions that come up most often in technical interviews -- language fundamentals, common gotchas, and short code-tracing exercises. Use it as a rapid-fire review before an interview: read each question, try answering it yourself first, then check the explanation. The questions mix conceptual understanding (e.g., 'what is the GIL?') with tracing exercises where you predict a program's exact output.
Cricket analogy: Like a batsman facing throwdowns before a Test match, mixing yorkers (conceptual questions like 'what is the GIL?') with bouncers (tracing exercises) to sharpen reflexes before India tour.
2. Frequently Asked Questions
What is the difference between a list and a tuple?
A list is mutable (its contents can be changed after creation via append, remove, etc.) and is written with square brackets []. A tuple is immutable -- once created, its elements cannot be reassigned -- and is written with parentheses (). Because tuples are immutable, they can be used as dictionary keys or set elements, while lists cannot.
Cricket analogy: A list is like a squad list that can be edited right up to the toss -- players added or dropped -- while a tuple is like the final, locked playing XI announced once the match starts.
What are Python's mutable and immutable built-in types?
Immutable types include int, float, bool, str, tuple, and frozenset -- their values cannot change in place; any 'modification' creates a new object. Mutable types include list, dict, set, and bytearray -- their contents can be changed in place without creating a new object.
Cricket analogy: Immutable types are like a player's fixed date of birth or jersey number -- any 'update' issues a whole new record -- while mutable types are like the live scoreboard, edited in place ball by ball.
What is the difference between a deep copy and a shallow copy?
A shallow copy (via copy.copy(), list(x), or slicing x[:]) creates a new outer container but still references the same nested objects as the original. A deep copy (via copy.deepcopy()) recursively copies every nested object too, so the copy is fully independent of the original, even for nested mutable structures.
Cricket analogy: A shallow copy is like photocopying a team roster sheet -- new paper, but it still points to the same player profiles -- while a deep copy re-interviews and rewrites every player's stats independently.
What will the following code print?
def f(x, lst=[]):
lst.append(x)
return lst
print(f(1))
print(f(2))This is the classic mutable-default-argument pitfall: the default list [] is created only once, when the function is defined, and is reused across every call that doesn't supply its own lst. So f(1) prints [1], and the second call f(2) appends to the SAME list, printing [1, 2] -- not a fresh [2].
Cricket analogy: It's like a coach reusing the same physical scorecard for every net session instead of a fresh one -- marks from Kohli's session on Monday are still there when Root bats on Tuesday, so the tally keeps growing.
What is the difference between `is` and `==`?
== compares values for equality (calls __eq__), while is compares object identity -- whether two references point to the exact same object in memory. Two distinct lists with equal contents satisfy == but not is.
Cricket analogy: == is like comparing two players' final scores for equality, while is asks whether they're literally the same person -- two different batsmen can both score 50 without being the same player.
What are Python decorators and how do they work?
A decorator is a function that takes another function (or class) as input and returns a modified/wrapped version of it, typically adding behavior before/after the original call without changing its source code. Applying @my_decorator above a function definition is shorthand for func = my_decorator(func).
Cricket analogy: A decorator is like a team manager wrapping a bowler's normal over with extra instructions (bowl a bouncer first, then your usual line) without rewriting the bowler's technique itself.
Explain list comprehension vs generator expression.
A list comprehension [x*2 for x in range(5)] builds the entire list in memory immediately. A generator expression (x*2 for x in range(5)) produces a lazy generator that yields values one at a time on demand, which is far more memory-efficient for large or infinite sequences, at the cost of only being iterable once.
Cricket analogy: A list comprehension is like printing the full scorecard of every ball in an innings at once, while a generator is like a live radio commentator calling out each ball's outcome only as it happens.
What is the GIL?
The Global Interpreter Lock is a mutex in CPython that allows only one thread to execute Python bytecode at a time, which limits true CPU parallelism when using the threading module. Use multiprocessing for CPU-bound parallel work.
Cricket analogy: The GIL is like a single-net practice facility where only one bowler can bowl at a time even if five are lined up, limiting true parallel practice; multiprocessing is like renting five separate nets instead.
What do *args and **kwargs mean in a function signature?
*args collects any extra positional arguments into a tuple; **kwargs collects any extra keyword arguments into a dictionary. They let a function accept a variable number of arguments, e.g., def f(*args, **kwargs): ....
Cricket analogy: *args is like a team sheet that accepts any number of extra substitute players collected into one list, while **kwargs is like a labeled roles sheet (captain=Kohli, keeper=Pant) collected into a dictionary.
What is the output of the following code?
x = [1, 2, 3]
y = x
y.append(4)
print(x)y = x does not copy the list -- it makes y reference the exact same list object as x. So y.append(4) mutates that shared object, and print(x) outputs [1, 2, 3, 4].
Cricket analogy: y = x is like handing a second captain the exact same physical scorebook instead of a copy -- when they scribble a new entry, the original captain's book shows it too, since it's the same book.
3. Quick Reference
iscompares identity,==compares value equality.- Lists are mutable and use
[]; tuples are immutable and use(). - Never use a mutable default argument (
def f(x, lst=[])) -- useNoneand initialize inside the function instead. *argscollects extra positional args into a tuple;**kwargscollects extra keyword args into a dict.- List comprehensions build the full list eagerly in memory; generator expressions yield lazily.
4. Key Takeaways
- Mutable default arguments are shared across calls -- a very common interview trap.
- Assignment (
y = x) for mutable objects creates a second reference, not a copy. - Understand
isvs==, shallow vs deep copy, and list vs generator memory tradeoffs -- these come up constantly. - Decorators wrap a callable to extend behavior without modifying its source.
- The GIL affects threading's suitability for CPU-bound vs I/O-bound work.
Practice what you learned
1. What does `is` compare in Python?
2. What is the output of `print([1,2,3] == [1,2,3])`?
3. Which of these built-in types is immutable?
4. What is a common pitfall with default mutable arguments like `def f(x, lst=[])`?
5. What does `**kwargs` collect in a function signature?
6. Which is true about generator expressions vs list comprehensions?
7. What does the GIL primarily restrict?
8. What does a Python decorator do?
Was this page helpful?
You May Also Like
Functions in Python
How to define, call, and document reusable blocks of code with Python functions, including the def keyword and implicit None return.
Exceptions in Python
What exceptions are, how Python's built-in exception hierarchy is structured, and how errors propagate through a program.
Decorators in Python
Learn how Python decorators use the @syntax to wrap functions, adding behavior like logging or timing without changing the original function's code.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics