INTERVIEWER GUIDE

Python Developer Evaluation

Confidential | For Interviewer Use Only

Role Python Developer (Mid / Senior)

Experience Band 6–11 Years

Interview Duration 60 Minutes (Structured)

Interview Format Conceptual Discussion + Live Coding on Platform

SECTION 1 — Interview Structure & Flow

60-Minute Interview Timeline

Time Block Duration Focus Area

0 – 5 min 5 min Candidate intro — name, current role, project context, tech stack

Block 1: Conceptual Python — Core Memory Model, Functions &

5 – 30 min 25 min
Execution Flow

Block 2: Live Coding — Problem Solving + Code Reading /

30 – 50 min 20 min
Output Prediction

Block 3: Advanced Topics — OOP, Concurrency, Iteration &

50 – 60 min 10 min
Pythonic Constructs (pick 2–3 questions)

NOTE: Timing is a guide, not a rule. If a candidate is struggling early, do not rush them into
coding. Depth in one block is more valuable than breadth with no signal.

Evaluation Rubrics (Platform-Configured)

Rubric Area What to Assess

Problem Solving Approach clarity, edge case awareness, solution correctness

Code Review Ability to read, analyze, and predict code behavior; identify bugs
Python — API Development REST patterns, request/response handling, integration thinking

Python — Fundamentals Core language knowledge: memory model, OOP, functions, iterators

Python — PySpark Spark concepts, RDD vs DataFrame, transformations vs actions.

(Good-to-have) Cover only if time permits.
SECTION 2 — Scoring Framework

Score Label Behavioral Indicators

Solves problems with clean, readable code. Explains reasoning

4 Strong Hire
proactively. Handles edge cases. Strong conceptual depth.

Solves core problem correctly. Minor gaps in edge cases or

3 Hire
optimization. Explains approach clearly.

Partial solution or significant prompting needed. Conceptual

2 Borderline
understanding present but struggles to code independently.

Cannot solve basic problems. Fundamental concepts unclear. Does

1 No Hire
not demonstrate readiness for the role.

Overall Recommendation Threshold

Recommended 7.5+ overall weighted score

Borderline (Prep-Worthy) 5.0–7.4 — Improvement Pointers REQUIRED in feedback

Not Recommended Below 5.0 — No improvement pointers required

CRITICAL: A correct, working solution is sufficient for a passing score. Do NOT penalize for a
suboptimal algorithm unless the candidate is targeting a 4 (Strong Hire) score. Optimal ≠
required.

THINK ALOUD: Candidates who verbalize their reasoning — even when the code has bugs —
should be rated higher than candidates who produce correct code silently. Verbal reasoning is a
scored dimension.
 SECTION 3 — Conceptual Question Bank

Pick 8–12 questions across the 5 categories below based on the candidate's experience level and how
the conversation flows. Do not run through the list linearly. Probe depth over breadth.

3.1 Core Python & Memory Model (20 Questions)

# Question Level

Q1 What is the difference between mutable and immutable data types in Python? Easy

Q2 Explain how Python's list, dict, and set differ in terms of storage and lookup. Easy

Q3 What is the difference between `is` and `==` in Python? Easy

How does Python handle memory management? Explain reference counting and
Q4 Medium
garbage collection.

Q5 What are `__str__` and `__repr__`, and when would you use each? Medium

Q6 What are descriptors in Python? Hard

Q7 How does hashing work for custom objects? Medium

Q8 Explain shallow vs deep copy in Python. Medium

Q9 What is the GIL and how does it impact threading? Hard

Q10 How are integers stored in Python (small int caching)? Medium

Q11 How does Python's method resolution order (MRO) work for multiple inheritance? Hard

What are descriptors, and how do they enable `@property`, `@classmethod`, and
Q12 Hard
`@staticmethod`?

What is the difference between `__slots__` and using `__dict__`? What are the
Q13 Hard
memory trade-offs?

Explain Python's weak references (`weakref` module). When would you use
Q14 `[Link]`, `WeakKeyDictionary`, or `WeakValueDictionary` to avoid memory Hard
leaks?

How does Python's `__missing__` method work, and in which built-in types can it be
Q15 Hard
overridden?

What are the exact steps Python follows when importing a module (e.g., `import
Q16 Hard
foo`)?

How does CPython manage memory for small objects (e.g., ints up to 256)
Q17 Hard
differently from large objects?

What is the difference between `is` and `==` for `None`, `True`, `False`, and small
Q18 Hard
integers?

How does Python's `copy` module implement deep copying? What is the role of
Q19 Hard
`__deepcopy__`?

What is the GIL (Global Interpreter Lock) in CPython? How does it affect
Q20 Hard
multithreading vs multiprocessing?
3.2 Functions & Execution Flow (20 Questions)

# Question Level

Q21 What are *args and **kwargs? Easy

Q22 Explain Python decorators. Medium

Q23 What is a closure in Python? Medium

Q24 How does a default mutable argument cause bugs? Medium

Q25 Explain the LEGB rule. Easy

Q26 What is the difference between yield and return? Medium

Q27 How do lambda functions differ from regular functions? Easy

Q28 Explain partial application with [Link]. Medium

Q29 What is the difference between a function and a generator function? Medium

Q30 How does Python's `nonlocal` keyword work? Medium

Q31 Explain how decorators with arguments work (decorator factories). Hard

Q32 What is the difference between `@staticmethod` and `@classmethod`? Medium

Q33 How does `[Link]` preserve the metadata of a wrapped function? Medium

Q34 Explain Python's call stack and how recursion limit is enforced. Hard

Q35 What is tail recursion and does Python support it? Why or why not? Hard

Q36 How does `functools.lru_cache` work internally? Hard

Q37 What is the difference between positional-only and keyword-only arguments? Medium

Q38 Explain how Python resolves variable names at compile time vs runtime. Hard

What happens when you define a function inside a loop and capture the loop
Q39 Medium
variable?

Q40 How does `[Link]` work and when would you use it? Hard
3.3 Object-Oriented & Design in Python (20 Questions)

# Question Level

Q41 What is the difference between class variables and instance variables?
(OOP Easy
)

Q42 Explain `__init__`, `__new__`, and `__del__` in Python.

(OOP Medium
)

Q43 What is method resolution order (MRO) and how does C3 linearization work?
(OOP Hard
)

Q44 How does multiple inheritance work in Python? When would you use mixins?
(OOP Hard
)

Q45 What is duck typing and how does it relate to Python's design philosophy?
(OOP Easy
)

Q46 Explain abstract base classes (ABC) and when to use them.
(OOP Medium
)

Q47 What are dunder/magic methods? Name at least 5 and their use cases.
(OOP Medium
)

Q48 How does Python implement operator overloading?

(OOP Medium
)

Q49 What is the difference between `__getattr__` and `__getattribute__`?

(OOP Hard
)

Q50 How would you implement a Singleton pattern in Python?

(OOP Hard
)

Q51 Explain the difference between composition and inheritance. When would you prefer
(OOP each? Medium
)

Q52 What is the purpose of `super()` and how does it work with MRO?
(OOP Hard
)

Q53 How do dataclasses differ from regular classes?

(OOP Medium
)

Q54 What is `__slots__` and how does it affect memory usage and attribute access?
(OOP Hard
)

Q55 Explain Python's descriptor protocol (`__get__`, `__set__`, `__delete__`).

(OOP Hard
)
 Q56 What is a metaclass? When and why would you use one?
(OOP Hard
)

Q57 How does `type` relate to metaclasses and class creation?

(OOP Hard
)

Q58 Explain the difference between `__repr__`, `__str__`, and `__format__`.

(OOP Medium
)

Q59 How does Python's pickle protocol interact with custom classes?
(OOP Hard
)

Q60 What is the observer pattern and how would you implement it in Python?
(OOP Hard
)

3.4 Iteration, Data Processing & Pythonic Constructs

# Question Level

Q44 Explain zip() and zip_longest. Easy

Q45 How does dict comprehension work? Easy

Q46 What is a generator and how is it different from a function? Medium

Q47 Explain map(), filter(), reduce() and Pythonic alternatives. Medium

Q48 What is [Link] and when is it useful? Easy

Q49 Explain Counter from collections. Easy

Q50 How does any() and all() work with iterables? Easy

What is the difference between `map`, `filter`, and list comprehensions? Which is
Q123 Hard
preferred and why?

Explain Python's iterator protocol: `__iter__` and `__next__`. What is the relationship
Q124 Hard
between iterables and iterators?

What are `[Link]` and `[Link]`? Provide a scenario where

Q125 Hard
groupby is useful.

How does Python's `sorted()` work with custom key functions? What is the
Q126 Hard
Schwartzian transform?

Q127 Explain the `zip` function and its behavior with iterables of different lengths. Hard

What are generator expressions? How do they differ from list comprehensions in
Q128 Hard
memory and evaluation?

Explain the walrus operator `:=` (PEP 572). Give an example where it improves
Q129 Hard
readability.
3.5 Concurrency, Performance & Ecosystem (20 Questions)

# Question Level

C1 What is the GIL and how does it affect concurrent programs? Hard

C2 Explain the difference between threading, multiprocessing, and asyncio in Python. Hard

When would you use `[Link]` vs

C3 Hard
`ProcessPoolExecutor`?

C4 What is an event loop in asyncio? Hard

C5 Explain `async`/`await` syntax and how coroutines work. Hard

C6 What is the difference between a coroutine and a thread? Hard

C7 How does Python handle race conditions in multithreaded programs? Hard

C8 Explain `[Link]`, `[Link]`, and `[Link]`. Hard

C9 What is `[Link]` and how does it differ from sequential awaits? Hard

C10 How would you profile a Python program for CPU vs I/O bottlenecks? Hard

C11 What are the limitations of Python for CPU-bound parallel work? Medium

C12 What is the purpose of `[Link]` in a producer-consumer pattern? Medium

C13 Explain `[Link]` and how it manages worker processes. Hard

C14 What is `[Link]` and how is it different from a coroutine? Hard

C15 How does `aiohttp` differ from `requests` in terms of concurrency model? Hard

C16 Explain Python's memory model for processes vs threads. Hard

C17 What is `contextvars` and when would you use it in an async application? Hard

C18 How does `subprocess` differ from `multiprocessing`? Medium

C19 What is `uvloop` and how does it improve asyncio performance? Hard

C20 How would you implement a rate-limited API caller using asyncio? Hard
 SECTION 4 — Coding Question Bank

The platform hosts 80 coding questions across 4 categories. During the live interview, select 2
problems — typically one from Problem Solving and one from Code Reading/Output Prediction. Debug
& Fix and Refactoring questions are optional based on time.

FORMAT: Problem 1 — Candidate receives a problem statement and implements the solution
live. Problem 2 — Candidate receives pre-written code and debugs/predicts output. Candidate
must execute code on the platform.

4.1 Problem Solving — Quick Logic Build (20 Questions)

# Question Level

Q61 Reverse a string without using built-in reverse. Easy

Q62 Find the second largest number in a list. Easy

Q63 Check if a string is a palindrome. Easy

Q64 Count the frequency of each character in a string. Easy

Q65 Remove duplicates from a list while preserving order. Easy

Q66 Flatten a nested list one level deep. Easy

Q67 Check if two strings are anagrams. Easy

Q68 Find all pairs in a list that sum to a target value. Medium

Q69 Implement a stack using a Python list. Easy

Q70 Write a function to check if brackets in a string are balanced. Medium

Q71 Find the longest common prefix in a list of strings. Medium

Q72 Write a binary search function. Medium

Q73 FizzBuzz — print numbers 1–100, replace multiples of 3 with Fizz, 5 with Buzz. Easy

Given a list of integers, return a new list where each element is the product of all
Q74 Medium
others.

Q75 Merge two sorted lists into one sorted list without using sort(). Medium

Q76 Find the most frequent element in a list. Easy

Q77 Write a function to rotate a list by k positions. Medium

Q78 Return the index of the first non-repeating character in a string. Medium

Q79 Write a function to check if a number is prime. Easy

Q80 Given a matrix, return its transpose. Medium

4.2 Code Reading & Output Prediction (20 Questions)

# Question Level

Q73 What does this print? `print(bool(''), bool('False'), bool([]), ...)` Easy

Q74 Predict: `a = (1, 2, [3, 4]); a[2].append(5); print(a)` Medium

Q75 What is printed? `print(0.1 + 0.2 == 0.3)` Easy

Q76 Output of: `print([i*i for i in range(5) if i % 2 == 0])` Easy

Q77 Predict: `x = 'abc'; print(x * 3); print(x + 3)` Easy

Q78 Output of: `import copy; a = [[1,2],[3,4]]; b = [Link](a); b[0][0] = 99; print(a)` Medium

Q79 Predict: `for i in range(3): pass; print(i)` Easy

Q80 What does this print? `print(True + True + False)` Easy

Q81 Predict the output: `def f(x=[]): [Link](1); return x; print(f(), f(), f())` Medium

Q82 What prints? `a = b = []; [Link](1); print(b)` Easy

Q83 Output of: `x = 5; f = lambda: x; x = 10; print(f())` Medium

Q84 Predict: `class A: x = 0; a = A(); a.x += 1; print(A.x, a.x)` Medium

Q85 What is the output? `print(type(lambda: None))` Easy

Q86 Output of: `d = {'a': 1}; e = d; e['b'] = 2; print(d)` Easy

Q87 Predict: `print(1 == True, 0 == False, 2 == True)` Easy

Q88 Output: `s = {1, 1, 2, 3}; print(len(s))` Easy

Q89 What prints? `for i in range(3): i = 10; print(i)` Medium

Q90 Predict: `a = [1,2,3]; b = a[:]; b[0] = 99; print(a[0])` Easy

Q91 Output: `def gen(): yield 1; yield 2; g = gen(); print(next(g), next(g))` Medium

Q92 What prints? `print('abc' in 'xabcd')` Easy

DEBUG & FIX (20 Qs) / IMPROVE & REFACTOR (20 Qs): These categories are available on
the platform. Use them if time permits or if the candidate has cleared Blocks 1 and 2 strongly
and you want to push further. They are not part of the default 60-minute flow.
 SECTION 5 — Key Answer Benchmarks

Use these benchmarks to calibrate your scoring. A candidate does not need to match these verbatim —
look for conceptual accuracy and clear communication.

What is the GIL and how does it impact threading?

Expected (Score 3–4): The GIL is a mutex in CPython that prevents multiple native threads
from executing Python bytecodes simultaneously. For CPU-bound tasks, threading does not
achieve true parallelism — use multiprocessing or native C extensions. For I/O-bound tasks
(network, disk), threading works well because threads release the GIL while waiting.

Explain shallow vs deep copy in Python.

Expected (Score 3–4): Shallow copy (`[Link]`) creates a new object but references the
same nested objects. Deep copy (`[Link]`) recursively copies all nested objects. A
mutable nested object in a shallow copy shares state with the original — modifying it affects
both. `__deepcopy__` can customize deep copy behavior.

What is a closure in Python?

Expected (Score 3–4): An inner function that captures variables from its enclosing scope,
retaining access after the outer function has returned. The captured variables are stored in the
function's `__closure__` attribute as cells. Common use cases: decorators, factory functions,
data encapsulation.

How does Python's MRO work for multiple inheritance?

Expected (Score 3–4): Python uses C3 linearization (C3 MRO). The resolution order is
computed such that a class always appears before its parents, and the order among siblings is
preserved. `super()` follows this MRO chain — it does not always call the direct parent. Use
`ClassName.__mro__` to inspect the chain.

What is the difference between `is` and `==`?

Expected (Score 3–4): `is` checks object identity (same memory address via `id()`). `==`
checks value equality via `__eq__`. For `None`, always use `is None` (never `== None`). Small
integers (-5 to 256) and interned strings are cached by CPython, so `is` may return True
unexpectedly — never rely on this for equality checks.

Predict output: `a = (1, 2, [3, 4]); a[2].append(5); print(a)`

Expected: `(1, 2, [3, 4, 5])` — The tuple is immutable, but the list inside it is mutable. `a[2]` is a
reference to the same list object. Strong candidates will immediately identify this as the
tuple-with-mutable-element gotcha.
 SECTION 6 — Interview Conduct & Platform Notes

Before the Interview

•​ Log into the Intervue platform 10 minutes early and verify the candidate's profile.
•​ Set up the coding environment: confirm the candidate can see the IDE and run code.
•​ Confirm the question set is loaded and rubric areas are visible.
•​ Have this guide open in a secondary window for question reference.

During the Interview

•​ Start with a 2-minute warm-up: ask about current role and tech stack. This reduces candidate
anxiety and gives you useful calibration context.
•​ For conceptual questions — after the candidate answers, probe one level deeper. Do not accept
first answers at face value.
•​ For coding — let the candidate think out loud. Silence is not a failure signal; narrate-and-code is a
strong signal.
•​ Do NOT provide hints proactively. If stuck for more than 3 minutes, offer a directional nudge, not
the answer.
•​ Record observations in the Panel Note field after each question — do not wait until the end.
•​ Watch for AI-assisted pattern: over-perfect recall on Hard questions, answers that sound
memorized, inability to explain when asked to paraphrase.

CONFIDENTIAL — FOR INTERVIEWER USE ONLY

This document is proprietary. Do not distribute, print, or share outside the designated interviewer pool.