Python technical interview interview questions and answers (Part 3)

121.What does a Lock do and what is a deadlock?

A Lock allows one thread at a time into a section of code. A deadlock happens when threads wait for each other's locks in a cycle and none can continue. Avoid it by taking locks in a fixed order and using with so locks are always released.

122.Why is queue.Queue used between threads?

It has locking built in, so several threads can put and get without extra locks. get waits when empty, which gives a simple producer-consumer pattern. The queue module is the safest way to hand work between threads.

123.What is the difference between concurrency and parallelism?

Concurrency is managing many tasks that overlap in time, even on one core. Parallelism is running tasks at exactly the same time on several cores. asyncio and threads give concurrency, and with the GIL only processes give true parallel Python code.

124.What is a free-threaded build of Python?

It is an optional build of CPython, first offered in version 3.13, that runs without the GIL, so threads can use several cores for Python code. It is not the default, some extension modules may not support it yet, and single-thread speed can differ. The standard build still has the GIL.

125.How does Python manage memory?

CPython uses reference counting to free most objects as soon as nothing refers to them, plus a generational cyclic garbage collector for reference cycles. Objects live on a private heap managed by Python, with small-object allocators for speed. The programmer does not free memory by hand.

Follow-up: Is this true for every Python implementation? No. PyPy and others use different garbage collectors, so objects may be freed later than in CPython.

Common mistake: Saying Python has no memory management. It has automatic management, and you can still leak memory.

126.What are the garbage collector generations?

There are three: generation 0 for new objects, then 1 and 2 for survivors. Each has a threshold, and a collection of a younger generation runs often and is cheap. The idea is that most objects die young, so checking only young ones saves time.

127.What is the difference between shallow copy and deep copy?

A shallow copy makes a new outer container but shares the inner objects, so a change inside is visible in both. A deep copy copies all levels, so the two are independent. Use copy.copy and copy.deepcopy, or the copy() methods for shallow copies.

Follow-up: When is a shallow copy enough? When the contents are immutable, like numbers and strings, or you will replace items and not change them in place.

128.What does __del__ do and why is it risky?

__del__ is a finalizer called just before an object is freed. When it runs is not guaranteed outside CPython's immediate counting, and it may never run at exit. For cleanup, prefer context managers with with or weakref.finalize.

129.What is __slots__ and when do you use it?

__slots__ lists the allowed attribute names, so instances have no __dict__ and use less memory. It helps when you create millions of small objects. The costs are that you cannot add other attributes, and inheritance needs care.

130.What is the difference between mutable and immutable objects for memory?

Immutable objects, such as int, str and tuple, cannot change, so every change makes a new object, and sharing them is safe. Mutable objects, such as lists and dicts, change in place, so aliases see the change. This is the source of many aliasing bugs.

131.Why can you not reuse a generator, and how do you work around it?

A generator keeps one position and moves only forward, so once it is exhausted it gives nothing. Create a new generator for each pass, or store the items in a list if you need to read them several times. The list costs memory, so choose by the size of the data.

Follow-up: Does reading an exhausted generator raise an error? No. A loop over it just does nothing, which makes the bug silent.

132.When would you write a context manager as a class and when as a generator?

Use @contextmanager for simple setup and cleanup because it is short. Use a class when you need extra methods, state kept between uses, or exact control over exceptions in __exit__. Both work with with in the same way.

133.Does the GIL make counter += 1 safe?

No. The statement is several steps, read, add and write, and a thread switch can happen between them. Two threads can read the same value and lose an update. Use a Lock, an atomic structure or a queue.

134.What is reference counting and what are its limits?

CPython counts references to each object and frees it when the count reaches zero, which is quick and predictable. Its limit is cycles, whose counts never reach zero. A cyclic garbage collector handles those.

135.How do you find which part of a program uses the most memory?

Use tracemalloc to take snapshots and compare them, or check object counts with gc.get_objects(). Look for growing caches, global lists and objects kept alive by references. Fix the owner of the reference, not the symptom.

136.What is a weak reference good for?

It lets you refer to an object without keeping it alive, which avoids leaks in caches and registries. When the object is freed, the weak reference returns None, or the entry disappears from a WeakValueDictionary. The object must support weak references, so plain int and str do not.

137.Why is 0.1 + 0.2 == 0.3 false?

Floats are stored in binary and 0.1 has no exact binary form. The sum is slightly above 0.3. Compare with round(), math.isclose, or store money in whole cents.

Follow-up: Does the same happen with integers? No. Python ints are exact and have no size limit, so 2 ** 100 never overflows.

Common mistake: Blaming Python. Every language that uses IEEE 754 floats behaves this way.

138.What does s[::-1] do?

It takes the whole string with a step of -1, so it walks backward and returns a reversed copy. It works for lists and tuples too.

Follow-up: What does s[5:2] return? An empty string, because with a positive step the start is already past the stop. Slices do not raise errors for that.

Common mistake: Thinking the stop index is included.

139.Is len(text) the number of bytes?

No. It counts characters (code points). The byte count depends on the encoding, so use len(text.encode()) for UTF-8 bytes.

Follow-up: Can two strings look the same but be unequal? Yes. A letter with an accent can be one code point or a letter plus a combining mark. unicodedata.normalize makes them comparable.

Common mistake: Assuming one visible character is always one code point.

140.What is the difference between a shallow and a deep copy?

A shallow copy makes a new outer container but reuses the inner objects. A deep copy, from copy.deepcopy, copies the inner objects too, so changes do not leak.

Follow-up: Is list(a) shallow or deep? Shallow. For a list of numbers that is enough, but for a list of lists it still shares the inner lists.

Common mistake: Using [:] on a list of lists and expecting full independence.

141.Why does count += 1 inside a function raise UnboundLocalError?

An assignment anywhere in a function makes the name local to that function. count += 1 reads the local before it has a value. Use global count, or better, pass the value in and return the new one.

Follow-up: When is nonlocal used? In a nested function to rebind a variable of the enclosing function, as in a counter.

Common mistake: Thinking Python reads the global first and only then creates a local.

142.How do you read a Python traceback?

From the bottom. The last line gives the exception type and message. The lines above show the calls in order, with the failing line last. I find my own file in the list and look at that line first.

Follow-up: What if the failing line is inside a library? I walk up to the last frame in my own code. That line passed the bad value into the library.

Common mistake: Reading only the top of the traceback and missing the real message.

143.A function prints None instead of a number. What do you check first?

That it has a return on every path. A function that falls off the end returns None. Methods like list.sort() also return None.

Follow-up: How do you see which branch returned None? Trace a small input, and add a test for each branch, including the empty input.

Common mistake: Checking the calling code first instead of the function.

144.How do you decide between 'error' and 'output' answers?

I look for a line that cannot run: a wrong operand type, a missing key or index, a name used before it has a value. If one exists, the output stops there, and I name the exception.

Follow-up: Does earlier output still print before the error? Yes. Lines before the failing one run and print normally.

Common mistake: Writing the output of the lines after the error.

145.Why state the brute force before the optimal solution?

It shows I understand the problem and gives a correct baseline. The repeated work inside it usually points straight to the better idea.

146.Is dict lookup O(1)?

It is O(1) on average because of hashing. In a very unlucky case many keys collide and it slows down, so I say 'on average'.

147.Does slicing cost anything?

Yes. a[i:j] creates a new list and copies its items, so it costs O(j - i) time and space. In a loop or a recursion, slices can quietly turn O(n) into O(n squared).

148.How do you describe the space cost of recursion?

Each pending call keeps a frame, so the space is the maximum depth. A tree of height h uses O(h) stack, and a recursive sum over n items uses O(n).

149.How do you choose between O(n) time with O(n) space and O(n log n) with O(1) space?

I ask which limit matters. With a large input and tight memory I may sort in place; otherwise a set or dict is usually simpler and faster.

150.How do you show that your solution is correct, not just fast?

I state the idea that makes it right, such as 'each step discards a value that cannot be part of the answer'. Then I test one normal case and two edge cases.

151.When does the two-pointer approach work?

When the data is sorted or has a structure that tells me which pointer to move, like a pair sum on a sorted list. Each step discards at least one value, so the pass is O(n).

152.What are prefix sums good for?

They answer many range-sum questions in O(1) after one O(n) pass. With a dict they also count subarrays with a given sum.

153.What is a monotonic stack?

A stack whose items stay in increasing or decreasing order, where each new item pops everything it beats. It answers 'next greater item' questions in O(n) because each item is pushed and popped once.

154.When do you use a deque instead of a list?

When I remove from the front, such as in a queue or breadth-first search, or need a window maximum. popleft is O(1) while list.pop(0) is O(n).

155.Can you use Counter in an interview?

Yes, it is standard Python and interviewers accept it. I also say what it does underneath, a dict of counts built in O(n), in case they ask me to write it by hand.

156.What do you do if two patterns both seem to fit?

I say both, compare their time and space for this input size, and pick the simpler one that meets the limits. Explaining the trade-off scores more than the choice itself.

157.Which traversal gives sorted output for a binary search tree?

Inorder: left, node, right. Because every left value is smaller and every right value is larger, the output is sorted.

158.How do you do level order traversal?

I use a deque and process len(queue) nodes per round to separate levels. The cost is O(n) time and up to O(n) space for the widest level.

159.Why must you track visited nodes?

A graph can contain cycles, so without a seen set the search loops forever or repeats work. With it each node is handled once, giving O(V + E).

160.How do you detect a cycle in a directed graph?

I run a topological sort with in-degrees: if fewer nodes than V get processed, a cycle exists. Alternatively DFS with three states (new, in progress, done) detects a back edge.

161.How do you decide if a problem is dynamic programming?

I look for a best value or a count, choices at every step, and the same smaller subproblems repeating. Writing the plain recursion and seeing repeated calls confirms it.

162.What do you do when the interviewer says the input does not fit in memory?

I say which part of my solution holds everything in memory, then change it to read in pieces or as a stream. If the problem needs sorting, I sort chunks and merge them.

163.What can you compute with O(1) memory on a stream?

Count, sum, minimum, maximum, and from them the mean. Things like the median, distinct count or most frequent value need more memory.

164.What changes if the data arrives as a stream and I can only look at each item once?

I cannot sort or revisit, so I keep a small running state, like counts, a heap or a window. I also say what answer I can give exactly and what only approximately.

165.What if the input has duplicates?

I check what my solution assumed. A set loses counts, so I use a Counter. Two pointers need to skip equal values to avoid repeated results.

166.How does a k-way merge work and what does it cost?

A heap holds the current front item of each of the k sorted inputs. I pop the smallest, push the next item from the same input, and repeat: O(n log k) for n items.

167.What if the data is updated between queries?

Static preprocessing like prefix sums then needs rebuilding, O(n) per update. I would mention a structure built for updates, such as a Fenwick tree or a segment tree, with O(log n) per update and query.

168.How do you manage a 45-minute coding round?

About 5 minutes to clarify and plan, 20 to code, 10 to test and discuss cost, and the rest for follow-ups. If I am slow I code the brute force first so there is a working answer.

169.What edge cases do you always test?

Empty input, one item, duplicates, negative numbers, the largest allowed size, and an input with no answer. I name them before coding so the code handles them.

170.How do you explain the cost of a recursive solution?

I count the number of calls and the work per call for time, and the maximum depth for space. With memoization the calls drop to the number of distinct states.

171.How do you talk about trade-offs?

I say what each choice costs and gains, like a dict that makes lookups O(1) but uses O(n) space. Then I say why my pick fits the stated limits.

172.How many problems should you solve before interviews?

Quality matters more than count. A set of 100 to 150 problems covering every pattern, each revised until you can explain it without notes, is a sound target.

173.How do you end a coding answer?

I summarise: what the code does, its time and space, and which edge cases I tested. Then I invite follow-ups.

174.What does is do and how is it different from ==?

== compares values and is compares identity, the same object in memory. I use is for None only.

Common mistake: Using is to compare strings or numbers. It may work by accident for small values and then fail.

175.Walk me through your idea for the longest stretch with no repeat.

Brute force: start at each position and extend until a repeat, O(n squared). Better: a window with a dictionary of last positions; when a code repeats inside the window, move the start just past the old copy. One pass, O(n).

Follow-up: Can it be faster than O(n)? No: every item must be read at least once, so O(n) is the best possible.

Common mistake: Jumping to the final code with no idea first. The interviewer wants to hear the path.

176.Why use @property instead of a plain attribute?

A property keeps obj.attr syntax but can check a value on set or compute a value on get. I can add the rule later without changing callers.

Follow-up: What is __repr__ for? It returns a text meant for developers, shown in logs and the shell, ideally enough to rebuild the object.

Common mistake: Writing get_x and set_x methods in Python by default.

177.Tell me about your Online Store API.

Sixty seconds: it lets clients list products, place orders and check stock. I own the order rules; stock cannot go below zero, and errors return a clear message and status. I used a dataclass for products and tests for each rule. Next I would add paging to the product list.

Follow-up: What was the hardest bug? Two orders for the last item both passed the check. I fixed it by doing the check and the update in one transaction.

Common mistake: Listing technologies only. Say what problem it solves and what you decided.

178.What is an index and when does it help?

An index is a sorted lookup structure on a column, so the database finds rows without reading the whole table. It helps with WHERE, JOIN and ORDER BY on that column, but costs space and slows writes.

Common mistake: Saying "indexes always make queries faster". They have a write cost.

179.How did you prepare for this interview?

I took three timed mocks, scored them, and sorted topics by score. I spent most time on the lowest ones, practised answers aloud, and kept a log of missed questions.

Follow-up: What improved most? My speed in explaining: I now answer in a definition, an example and a trap.

Common mistake: Saying "I read many notes". Show a plan and a result.

180.Why should we hire you for a Python role?

I know the basics well, solve problems with the standard library, write small classes with clear rules, query data with SQL and explain my choices. My projects show the same habits.

Common mistake: A list of adjectives. Give evidence from projects.