Python Mid
Is Python a compiled or interpreted language? Explain the role of .pyc files and the Python Virtual Machine (PVM).
Select the correct answer
Source is compiled straight to machine code stored in .pyc files for the PVM
Source is compiled to bytecode cached in .pyc files, then run by the PVM
Source is interpreted line by line and .pyc files hold optimized native binaries
Source is linked into an executable while .pyc files store the program's runtime state
What are the major differences between Python 2 and Python 3 that you should be aware of?
Select the correct answer
In Python 3 print is a function, strings are Unicode, and / does true division
In Python 3 range returns a list, input evaluates code, and tabs are required
In Python 3 print is a statement, strings are bytes, and / does floor division
In Python 3 xrange replaces range, and integers silently overflow to floats
Explain the LEGB rule. What happens to the scope when you use the global or nonlocal keywords inside a nested function?
Select the correct answer
Names resolve Local, Enclosing, Global, Built-in; global rebinds the enclosing scope, nonlocal rebinds module level
Names resolve Local, Enclosing, Global, Built-in; global rebinds module scope, nonlocal rebinds the enclosing one
Names resolve Built-in, Global, Enclosing, Local; both global and nonlocal create a brand-new local name
Names resolve Local, Enclosing, Global, Built-in; global and nonlocal both make the variable read-only everywhere
What happens if you use a mutable object like a list or dictionary as a default argument in a function, and why is this considered a gotcha?
Select the correct answer
Each call copies the default, yet the copies all still reference the same underlying buffer in memory.
The default is created once at definition time and shared across calls, so mutations persist between invocations.
The default is rebuilt on every call, but Python caches the first one and silently reuses it for speed.
The interpreter freezes the default as immutable, so any attempt to mutate it raises an error at runtime.
What is a closure in Python, and how does the interpreter 'remember' the values of the enclosing scope even after the outer function has finished executing?
Select the correct answer
A nested function captures enclosing variables in cell objects, which keep those references alive after the outer call.
A function copies all outer local values into its own namespace, freezing them when the outer function is defined.
A decorator stores enclosing variables in a global table, letting the inner function look them up on each call.
A nested function reads enclosing variables from the call stack, which Python preserves until the program exits.
Is Python 'call-by-value' or 'call-by-reference'? Explain the concept of 'call-by-object-reference' (or 'assignment').
Select the correct answer
Python is call-by-reference, so reassigning any parameter inside a function changes the caller's original variable too.
Python passes immutables by value and mutables by reference, choosing the strategy from each argument's type.
Python passes object references by value, so rebinding a parameter is local but mutating a shared object is visible.
Python is call-by-value, copying every argument fully, so functions can never modify the caller's objects at all.
How do Python's collections.deque and list differ in terms of time complexity for common operations?
Select the correct answer
deque offers O(1) random indexing, while list needs O(n) to reach any element by its position.
deque gives O(1) appends and pops at both ends, while list is O(1) at the end but O(n) at the front.
list provides O(1) front insertion, while deque requires O(n) to append items at either end.
Both list and deque provide O(1) appends at both ends, but deque uses O(n) memory to resize.
What requirements must an object meet to be used as a key in a Python dictionary, and how does Python handle hash collisions?
Select the correct answer
Keys must be unique objects by identity; collisions are handled by chaining values into nested dictionaries.
Keys must be hashable with consistent __hash__ and __eq__; collisions are resolved by probing for open slots.
Keys must be immutable strings or numbers only; collisions are stored together in a linked list per bucket.
Keys must implement __lt__ for ordering; collisions trigger a full resize and rehash of the entire table.
What is a frozenset, and how does it differ from a regular set?
Select the correct answer
An immutable set that is hashable and can be used as a key in a dictionary
A mutable set whose elements are automatically kept sorted in ascending order
An ordered set that preserves insertion order while rejecting any duplicates
A set that stores frozen copies of its objects to block their later mutation
Are Python dictionaries ordered? Explain the insertion-order guarantee introduced in Python 3.7.
Select the correct answer
No; ordering is arbitrary, so you must use OrderedDict to retain order
No; dicts order keys by hash value, so it depends on the keys that you insert
Yes; dicts have always kept their keys sorted alphabetically since early versions
Yes; since 3.7 dicts preserve insertion order of keys as a language guarantee
What are defaultdict, Counter, and OrderedDict in the collections module, and when would you use them?
Select the correct answer
defaultdict sorts keys, Counter limits duplicate keys, OrderedDict reverses insertion order
defaultdict supplies defaults for missing keys, Counter tallies items, OrderedDict tracks order
defaultdict locks keys, Counter caps values, OrderedDict sorts keys numerically
defaultdict caches lookups, Counter stores unique keys, OrderedDict indexes by position
Explain the 'Easier to Ask for Forgiveness than Permission' (EAFP) coding style. Why is it often preferred in Python over 'Look Before You Leap' (LBYL)?
Select the correct answer
Try the operation and handle exceptions if it fails, rather than checking conditions first
Check all preconditions with guards before attempting any potentially failing operation
Avoid exceptions entirely by returning error codes that the caller must inspect each time
Validate inputs at function boundaries so no exception can ever be raised at runtime
Why is it considered bad practice to use except Exception? Explain the Python exception hierarchy and where BaseException fits in.
Select the correct answer
It only catches custom errors; BaseException derives from Exception at the bottom
It also catches SystemExit and KeyboardInterrupt; both classes are identical
It hides bugs by catching unrelated errors; BaseException is the root, Exception sits below
It runs slowly at runtime; BaseException is the root but Exception sits above it
What is duck typing, and how does it differ from EAFP?
Select the correct answer
Duck typing checks an object's type with isinstance before calling any method on it
Duck typing judges an object by the methods it supports rather than its explicit type
Duck typing converts objects to one common type automatically before any operation is run
Duck typing requires objects to inherit from a shared base class before being used together
How do you define a custom exception, and what are the best practices for exception hierarchies?
Select the correct answer
Subclass object and raise it directly, since any class instance can be raised here.
Subclass str so the exception carries its message text without any extra attributes.
Subclass Exception and group related custom errors under a shared base exception class.
Subclass BaseException directly so the errors propagate through all interpreter layers.
What is exception chaining, and what does 'raise ... from ...' do?
Select the correct answer
It re-raises the original exception unchanged after running the intervening cleanup code.
It sets __cause__ on the new exception, explicitly linking it to the original cause.
It suppresses the original traceback entirely so only the new exception is ever displayed.
It merges both exceptions into a single object combining their messages and tracebacks.
What are the advantages of using @dataclass over a regular class or a namedtuple, and how does it handle default values and mutability?
Select the correct answer
It requires a default factory for every field and forbids inheritance from regular classes.
It enforces runtime type checking on all fields and rejects mismatched default values.
It produces immutable tuples like namedtuple but with faster attribute access by index.
It auto-generates __init__, __repr__, and __eq__ while allowing mutable, typed fields.
How do Python's 'dunder' (magic) methods allow for operator overloading and protocol implementation?
Select the correct answer
Python compiles dunder methods into C-level hooks that bypass normal method resolution order.
Python dispatches operators and built-in protocols to specially named methods like __add__.
Python requires registering each operator with a decorator before the dunder method takes effect.
Python overloads operators only for numeric types, ignoring dunder methods on other objects.
What is the relationship between __eq__ and __hash__, and what happens if you override one but not the other?
Select the correct answer
Overriding __hash__ without __eq__ sets __eq__ to None, making instances incomparable
Overriding __eq__ automatically regenerates a matching __hash__ from the new equality logic
Overriding __eq__ without __hash__ sets __hash__ to None, making instances unhashable
Overriding either one leaves the other unchanged, so instances stay hashable and comparable
What is the __call__ method, and how does it let you make instances of a class callable?
Select the correct answer
Defining __call__ makes instances callable, so instance() invokes instance.__call__()
Defining __call__ makes the class callable, so calling it returns a new bound method
Defining __call__ overrides __init__ so construction and invocation share logic
Defining __call__ lets instances be called only when used as decorators on functions
How does Python determine the truthiness of an object, and what role do __bool__ and __len__ play?
Select the correct answer
Python treats every object as truthy unless it defines both __bool__ and __len__
Python uses __len__ if defined, else __bool__ (zero is falsy), else the object is falsy
Python checks __bool__ and __len__ together, treating an object true only if both agree
Python uses __bool__ if defined, else __len__ (zero is falsy), else the object is truthy
What is the purpose of the abc module, and how does it help enforce an interface compared to standard inheritance?
Select the correct answer
Provides runtime checking of method arguments through decorators applied to entire classes.
Generates concrete default implementations for missing methods so subclasses always work.
Registers virtual subclasses but never prevents instantiation of incomplete child classes.
Defines abstract base classes that block instantiation until all abstract methods are implemented.
What is the purpose of the typing module? Does Python enforce these types at runtime, and if not, why are they used in modern production codebases?
Select the correct answer
Provides type hints; Python ignores them at runtime, but they aid tooling and readability.
Provides runtime casting so values are coerced into their annotated types automatically.
Provides decorators that validate types only inside functions marked for strict checking.
Provides type hints that Python enforces at runtime, raising errors on mismatched arguments.
How does Python's 'Duck Typing' philosophy differ from 'Strong Typing'?
Select the correct answer
Duck typing allows implicit conversions; strong typing requires explicit declarations of all types.
Duck typing concerns having the right behavior; strong typing concerns not coercing unrelated types.
Duck typing checks types at compile time; strong typing defers every check until program runtime.
Duck typing forbids inheritance; strong typing relies entirely on class hierarchies for its safety.
Why would you use typing.Annotated?
Select the correct answer
To mark a type as deprecated so that static checkers warn whenever the annotation is being used.
To attach extra metadata to a type that tools or libraries can read without changing the type.
To combine two types into a union that validators check against at the time of a function call.
To convert a runtime value into its annotated type by coercing it during each assignment made.
What is the difference between Final and ClassVar in type hinting?
Select the correct answer
Final makes an object truly immutable at runtime, while ClassVar enforces the attribute's type while running.
Final marks a private attribute name, while ClassVar marks an attribute each instance copies on write.
Final marks a name that must not be reassigned, while ClassVar marks an attribute shared at the class level.
Final marks an attribute shared at the class level, while ClassVar marks a name that must not be reassigned.
What is 'Duck Typing', and how does it influence the way you design interfaces in Python compared to a strictly typed language like Java?
Select the correct answer
An object is automatically cast to its parent type at runtime, encouraging deep inheritance hierarchies over composition.
An object's type must be declared up front, encouraging explicit interface inheritance like Java abstract base classes.
An object's methods are checked by a compiler before running, encouraging strict static contracts over flexible code.
An object's suitability is judged by the methods it supports, encouraging informal protocols over declared interfaces.
What is the difference between an iterable, an iterator, and a generator? What are the memory implications of using a generator over a list comprehension?
Select the correct answer
An iterator produces an iterable; a generator produces an iterator; all three load their entire contents into memory at once.
An iterable produces an iterator; an iterator yields items via next; a generator is a lazy iterator that saves memory.
An iterable yields items via next; an iterator produces an iterable; a generator builds the full list eagerly in memory.
An iterable and an iterator are identical; a generator differs only by syntax and stores every item in memory like a list.
How does the yield keyword work, and what is the difference between yield and yield from?
Select the correct answer
yield stops the generator permanently, while yield from restarts it from the beginning of the loop
yield creates a coroutine object, while yield from converts that coroutine into an awaitable async task
yield pauses and returns one value at a time, while yield from delegates iteration to a sub-iterable
yield returns all values at once eagerly, while yield from streams them one by one to save memory
What is the difference between an Iterator and an Iterable? How do you implement the Iterator protocol?
Select the correct answer
An iterable defines both __next__ and __iter__, while an iterator only needs __getitem__
An iterable defines __iter__ returning an iterator; an iterator defines __next__ to yield values
An iterator defines __iter__ returning an iterable; an iterable defines __next__ to yield values
An iterator defines __len__ and __iter__, while an iterable defines __next__ to produce values
How do decorators work, and how can you ensure the original function's metadata is preserved?
Select the correct answer
A decorator subclasses the function object; the __metadata__ attribute restores its original name and docs
A decorator wraps a function returning a new one; functools.wraps preserves the original metadata
A decorator renames a function in place; functools.wraps copies the wrapper metadata onto its callers
A decorator executes a function immediately; functools.cache preserves the original function metadata
How do decorators work under the hood? Explain the concept of a closure and how it allows a decorator to remember the state of the wrapped function.
Select the correct answer
A decorator copies the source of the original function and recompiles it with extra behavior injected inline
A decorator returns a wrapper closure that captures the original function from the enclosing scope and calls it
A decorator stores the wrapped function in a global registry and looks it up by name at every call
A decorator mutates the original function object directly so the wrapper closure is never actually needed
Explain how a decorator works conceptually. How would you write a decorator that accepts its own arguments?
Select the correct answer
Attach the arguments as attributes on the wrapped function before the decorator returns the wrapper
Declare the arguments as global variables so the single decorator function can read them when it runs
Pass the arguments directly to the wrapper function and read them from *args at call time only
Write an outer factory taking the arguments that returns a decorator, which returns the wrapper function
What are dictionary and set comprehensions, and when would you use them?
Select the correct answer
Concise expressions building a sorted dict and an ordered set that always preserve insertion order
Concise expressions that build immutable frozen dicts and sets which cannot be modified after creation
Concise expressions building a dict of key-value pairs or a set of unique values from an iterable
Concise expressions that lazily produce dict and set items one at a time without building them fully
How does functools.lru_cache work, and how does it help with memoization?
Select the correct answer
It stores results on disk between runs so the cache survives even after the program fully restarts
It precomputes every possible result at import time and stores them in an unbounded lookup dictionary
It caches results keyed only by the function name, sharing one stored value across all argument sets
It caches results keyed by the call arguments, returning the stored value on repeated calls
What does functools.partial do, and when would you use it?
Select the correct answer
It merges two separate functions into one callable that applies both of them to the given arguments
It splits a function into smaller callables that each run one statement of the original body in turn
It returns a callable that runs only part of a function and defers the remaining lines until later
It returns a new callable with some arguments of an existing function already fixed in advance
What is functools.reduce, and how does it differ from a simple loop?
Select the correct answer
It applies a two-argument function cumulatively across an iterable to produce a single accumulated result
It filters an iterable by a predicate and returns only the items for which the function is true
It splits an iterable into chunks and returns a nested list of accumulated partial sums
It applies a one-argument function to every element and returns a new lazy iterator of results
What is the itertools module, and what kinds of problems does it help solve?
Select the correct answer
A standard library of fast, memory-efficient iterator building blocks for combinatorics and looping
A built-in collection of mutable container types that replace lists, sets, and dictionaries
A third-party library of vectorized array operations for numerical and statistical data analysis
A standard library of functions for parsing, formatting, and converting iterable data structures
What is the walrus operator (:=), and in what situations is it useful?
Select the correct answer
It declares a variable as global inside an expression, useful for sharing state across functions
It unpacks an iterable into a variable within a statement, useful for splitting function arguments
It assigns a value to a variable as part of an expression, useful in comprehensions and while loops
It compares two values for identity and binds the result, useful when checking object equality
How do context managers work, and what is the difference between the __enter__/__exit__ and @contextmanager approaches?
Select the correct answer
Both require a class; @contextmanager simply renames __enter__ and __exit__ to shorter aliases
Both run on entry only; @contextmanager handles cleanup automatically while the methods need explicit calls
Both manage setup and teardown; @contextmanager uses a generator with yield instead of two methods
Both are async by default; @contextmanager provides synchronous behavior while the methods stay coroutine-based
What is Structural Pattern Matching (match/case) and how does it differ from a standard if/elif/else block?
Select the correct answer
It compiles a chain of conditions into a jump table for speed but otherwise behaves like nested branches
It evaluates every case in parallel and runs all blocks whose pattern happens to match the subject
It compares a value only for strict equality against constants, like a switch statement in other languages
It matches a value against structural patterns, destructuring and binding parts rather than just testing booleans
What does it mean that Python's sort is stable, and why does that matter?
Select the correct answer
Repeated sorts of the same list always run in identical time complexity
Elements comparing equal retain their original relative order after sorting
The sort never crashes or raises errors even with mixed-type elements present
Sorting always produces the same output regardless of the input order given
What is serialization with the pickle module, and what are its security concerns?
Select the correct answer
It compresses objects into bytes and automatically validates their integrity on load
It serializes objects to bytes; unpickling untrusted data can run arbitrary code
It serializes objects to JSON text and is always safe to load from external sources
It encrypts objects into bytes so untrusted sources cannot read or alter the data
What is the Global Interpreter Lock (GIL), and given its existence, how do you write concurrent code that actually runs in parallel across multiple CPU cores?
Select the correct answer
Use multiprocessing or C extensions that release the GIL to use multiple cores
Use the threading module since each thread runs on a separate CPU core in parallel
Increase the number of threads beyond the core count to bypass the GIL limitation
Use asyncio coroutines because the event loop schedules tasks across all CPU cores
Are Python threads 'real' native threads?
Select the correct answer
Yes, they are OS threads and the GIL lets them run bytecode fully in parallel
No, they are cooperative coroutines that yield control only at await points
Yes, they are real OS threads, but the GIL prevents parallel bytecode execution
No, they are green threads scheduled entirely by the Python interpreter itself
What is the GIL, and why was it originally implemented?
Select the correct answer
A queue ordering I/O operations across threads, added to guarantee deterministic execution order.
A mutex letting only one thread run Python bytecode at once, added to simplify memory management.
A scheduler distributing bytecode evenly across all CPU cores, added to maximize parallel speed.
A lock preventing multiple processes from sharing memory, added to improve security isolation.
What is the difference between a thread and a coroutine in the context of the Python runtime?
Select the correct answer
Threads suspend only at chosen await points; coroutines can be interrupted at any instruction.
Threads are scheduled preemptively by the OS; coroutines are scheduled cooperatively in one thread.
Threads always bypass the GIL for true parallelism; coroutines are limited to one core by the GIL.
Threads run in separate processes with isolated memory; coroutines share a single global process pool.
Why is multiprocessing often preferred over threading for CPU-bound tasks in CPython?
Select the correct answer
Each process has its own interpreter and GIL, so they run Python bytecode in true parallel.
Processes are lighter weight than threads, so spawning many of them costs almost nothing.
Threads cannot execute C extensions, while processes release the GIL during numeric loops.
Processes share memory faster than threads, reducing the copying overhead of CPU-bound work.
Explain the difference between preemptive multitasking (threading) and cooperative multitasking (asyncio). When is asyncio preferred over standard threading?
Select the correct answer
Threads share no memory; asyncio shares memory freely, best for parallel number-crunching tasks.
Threads run on many cores; asyncio also uses many cores, best for true CPU-bound parallelism.
Threads yield only at await points; asyncio preempts anytime, best for heavy CPU computations.
The OS switches threads anytime; asyncio yields at await, best for many I/O-bound connections.
How does asyncio achieve concurrency without using multiple threads or processes?
Select the correct answer
A single thread interleaves tasks at await points while waiting on non-blocking I/O via the loop.
The OS time-slices coroutines across cores, switching whenever a task has run long enough to yield.
The interpreter forks lightweight processes per coroutine that communicate through the event loop.
A pool of hidden threads runs each coroutine, and the loop merges their results when they finish.
When should you choose asyncio over threading for a high-concurrency task?
Select the correct answer
When handling many simultaneous I/O-bound connections that spend most time waiting on the network.
When you need true parallel execution of bytecode across threads without being limited by the GIL.
When running CPU-heavy computations that must fully utilize every available processor core at once.
When each task blocks on long synchronous calls that cannot be rewritten to use non-blocking APIs.
What is the difference between asyncio.gather() and asyncio.wait()?
Select the correct answer
gather() only accepts coroutines whereas wait() only accepts created future objects.
gather() collects ordered results and propagates errors; wait() returns done and pending sets.
gather() runs tasks sequentially while wait() runs every scheduled task concurrently.
gather() cancels all tasks on first error while wait() always waits for every task.
What is the difference between a shallow copy and a deep copy, and how does the copy module handle nested objects in each case?
Select the correct answer
A shallow copy duplicates every nested object while a deep copy shares them by reference.
A deep copy duplicates only the outer object while leaving inner references untouched.
A shallow copy duplicates the outer object but shares nested objects by reference.
Both copy types fully duplicate nested objects but differ only in execution speed.
How does Python handle circular imports, and what are the common strategies to resolve them?
Select the correct answer
Move imports inside functions or restructure modules to avoid partially initialized references.
Python automatically merges the two modules into one to silently break the cycle.
Duplicate the shared code into both modules since imports between them are impossible.
Circular imports always raise an immediate fatal error that cannot be worked around.
Why are strings immutable in Python, and what implications does that have for performance and memory?
Select the correct answer
Immutability makes string edits faster in place while increasing total memory usage.
Immutability prevents strings from being used as dictionary keys or set members.
Immutability allows safe sharing and hashing, but edits create new string objects.
Immutability means concatenation modifies the original buffer without new allocations.