Python Developer Interview Questions & Answers

Answer: By defining it under the [tool.poetry.scripts] section as 'scriptname = "module:function"'.

Answer: Use the 'markers' property in the dependency specification (e.g., { version = "...", markers = "sysplatform == 'win32'" }).

Answer: pip install --no-cache-dir <package

Answer: It over-allocates memory (e.g., ~1.125x + constant) to avoid frequent reallocations.

Answer: It lists versions but not cryptographic hashes, allowing for 'Package Poisoning' where an attacker replaces a file on PyPI without changing the version number.

Answer: DetachedInstanceError. The session is closed, so the object cannot reach out to the DB to lazy-load the 'profile'.

Answer: It relies on the server's system clock. 'Today' changes at different moments globally, leading to off-by-one errors.

Answer: The resolution depends on the OS system clock. It may not update every microsecond, causing jitter or coarse granularity.

Answer: Race condition: Concurrent clients can read the same value and overwrite each other's increments. Use INCR.

Answer: It can spawn unbounded concurrent tasks, exhausting resources.

Answer: The counter increments only for GET and not for other methods.

Answer: It raises an AttributeError because Python is importing the local json.py file instead of the standard library module.

Answer: Logical Error. Correlation does not imply causation.

Answer: The wheel was built against a glibc version newer than what the user's OS provides.

Answer: The virtual environment contains absolute paths in the 'bin/' scripts pointing to the OLD location. Renaming the parent folder invalidates them.

Answer: Pytest offers four main scopes: function (default), class, module, and session. Broader scopes like session or module significantly reduce test runtime by reusing expensive setup (e.g., a database container). However, they introduce the risk of shared state. If one test modifies the shared resource and fails to clean it up, subsequent tests may fail or exhibit flaky behavior, making debugging difficult.

Answer: asyncio.gather is faster for total execution time because it starts all 1000 requests concurrently. However, it requires storing all 1000 results in memory at once. An async generator (if used with a semaphore or task queue) is more memory-efficient and provides the first result much faster (lower 'time to first byte'). Without extra logic, a plain async for loop over a generator is sequential and would be much slower than gather.

Answer: Time-Based expiration (TTL) removes data after a fixed duration; it is simple but risks serving stale data. Explicit Invalidation involves the application removing or updating the cache entry as soon as the source data changes. Explicit Invalidation is generally preferred for strict consistency because it ensures the cache is never out of sync with the primary database, though it increases application complexity.

Answer: The Cache Hit Ratio is the percentage of total requests served by the cache rather than the primary data source. A low ratio indicates that the cache is frequently missing, forcing slow database lookups and increasing latency. This often signals a need for a larger cache size, a better eviction policy, or a longer TTL.

Answer: Standard Python lists are implemented as contiguous arrays. The list.pop(0) Problem: When you remove the first element of a list using pop(0), every subsequent element in the array must be shifted one position to the left to fill the gap. This is an O(n) operation. If your queue has 100,000 items, a single pop(0) requires moving 99,999 pointers. Doing this inside a loop results in O(n^2) total complexity, which causes severe performance degradation as data size grows. The deque Solution: collections.deque is implemented as a doubly-linked list of blocks. Adding or removing items from either end (left or right) involves updating pointers and potentially allocating/deallocating a block, which is a guaranteed O(1) operation. In production, always use deque for queues or sliding window algorithms.

Answer: Yes, a namedtuple can be used as a dictionary key if and only if all its elements are hashable. Reasoning: A namedtuple is a subclass of tuple. Tuples are immutable and are hashable by default. Because dictionary keys in Python must be hashable (to maintain stable positions in the hash table), namedtuple is an excellent choice for complex, multi-part keys (e.g., using Point(x, y) as a coordinate key). However, if the namedtuple contains a mutable object (e.g., Record(id=1, tags=[])), it becomes unhashable and will raise a TypeError if used as a key.

Answer: In Python 3, zip() returns an iterator (a zip object). Complexity: Time: $O(1)$ to create the zip object. It does no work upfront. When iterated, each step takes time proportional to the number of iterables being zipped (e.g., if zipping 3 lists, it calls next() 3 times). Space: $O(1)$. It only stores references to the input iterators and the current tuple being yielded. Vs Python 2: Python 2's zip() returned a list of tuples immediately. This consumed $O(n)$ memory and required processing the entire sequence before returning, which was inefficient for large datasets.

Answer: Yes, with A() as a, B() as b: works. Handling: It acts like nested blocks: with A() as a: with B() as b:. Error Handling: If A().enter succeeds but B().enter raises an exception, A().exit is called immediately to cleanup A. Python ensures that any successfully entered context is correctly exited, even if a subsequent context in the chain fails.

Answer: Yes, a closure can mutate an object (like appending to a list or setting a dict key) without nonlocal. Reason: This is because you are not changing what the variable name data points to; you are dereferencing data to find the list object, and then calling a method on that object. nonlocal is only required if you want to assign a new object to the name data (data = []), which changes the binding in the scope.

Answer: 1. Cache-Aside: The app checks the cache. On miss, it reads from the DB, then updates the cache. Most common but puts the logic burden on the app. 2. Write-Through: The app writes to the cache, and the cache synchronously updates the DB. Ensures consistency but adds write latency. 3. Write-Back: The app writes to the cache only. The cache asynchronously flushes data to the DB later. Provides best write performance but risks data loss on cache failure.

Answer: Python modules are Singletons by default. The Mechanism: When you run import mymodule, Python checks the dictionary sys.modules. 1. Hit: If 'mymodule' is already a key in sys.modules, Python simply returns the existing module object. It does not re-read the file or re-execute the code. This makes subsequent imports $O(1)$ operations. 2. Miss: If not found, Python finds the file, compiles it to bytecode, executes the module-level code to build the module object, adds it to sys.modules, and then returns it. Production Impact: This caching ensures that global state (like database connection pools defined at module level) is shared across the application. However, it also means side effects at the top level of a module run only once.

Answer: Server-side load balancing uses a central proxy (like F5 or NGINX) that distributes requests to a pool of backends. Client-side load balancing (like using gRPC stubs with a service registry) lets the client select the instance directly. Client-side reduces the 'extra hop' latency but increases the complexity and resource usage of the client applications.

Answer: Python lists are implemented as dynamic arrays (contiguous blocks of pointers). When you create a list, Python allocates a specific amount of memory capacity. The Algorithm: When you append() an item and the list is full, Python does not allocate just one more slot. Instead, it allocates a significantly larger block (over-allocation), copies the existing items to the new block, and frees the old one. The growth factor is roughly 1.125x (specifically newallocated = newsize + (newsize 3) + 6). Amortized Complexity: Although the resize operation is expensive ($O(n)$), it happens rarely. For $N$ appends, you only resize $\log N$ times. If you average the cost of the few expensive resizes over the many cheap insertions, the cost per append() approaches constant time $O(1)$. This is crucial for performance; without it, building a list would be $O(n^2)$.

Answer: Python's GC categorizes objects into three generations based on how many collection cycles they have survived. Generation 0 is for new objects. When a collection happens and an object survives, it is promoted to Generation 1, and eventually to Generation 2. This optimizes performance because younger objects are much more likely to be short-lived, so the GC scans Generation 0 more frequently than Generations 1 and 2, reducing the total scanning work.

Answer: Python's lambda syntax lambda args: expression does not support inline type annotations for arguments or return values (e.g., lambda x: int is invalid). However, you can use the typing module to annotate the variable the lambda is assigned to. For example: myfunc: Callable[[int], int] = lambda x: x + 1.

Answer: Blue/Green Deployment: Maintains two identical environments (Blue=Live, Green=New). You deploy the new model to Green, test it, and then switch 100% of traffic from Blue to Green instantly. Rollback is easy (switch back), but if Green fails, all users are affected immediately. Canary Deployment: Rolls out the new model to a small subset of users (e.g., 5%) first. If metrics look good, traffic is gradually increased to 100%. Safety: Canary is safer for major updates because it limits the blast radius of a bad model to a small percentage of users.

Answer: A service map is a visual representation of the dependencies between microservices. It is generated by analyzing distributed traces; specifically, the parent-child relationships between spans that cross service boundaries. When an incident occurs, the service map helps engineers see exactly where the bottleneck or error is (e.g., Service A is healthy, but Service B's calls to Service C are failing), allowing them to pinpoint the faulty service immediately.

Answer: Pip traditionally uses a linear resolution strategy which can lead to conflicts where the last installed package overwrites sub-dependencies of an earlier one. Poetry uses a deterministic resolver that checks the entire dependency tree (transitive dependencies) for all packages simultaneously. If a conflict occurs (e.g., Package A needs v1.0 and Package B needs v2.0 of the same library), Poetry will fail to install and provide a detailed explanation rather than leaving the environment in a broken state.

Answer: Yes, fixtures can request other fixtures as arguments. Order: Pytest builds a dependency graph. If user requests db, Pytest ensures db is fully set up (its yield hasn't finished) before user starts setup. Conversely, user is torn down before db is torn down. This allows building complex, layered environments (App - DB - Table - Row).

Answer: Strings in Python are immutable. This means they cannot be modified in place. The Concatenation Problem ($O(n^2)$): When you execute s += chunk, Python cannot just append the new data to the existing memory block of s. Instead, it must: 1. Allocate a new block of memory large enough for the old string + the new chunk. 2. Copy the entire contents of the old string into the new block. 3. Copy the chunk into the new block. In a loop of $N$ iterations, the first iteration copies length 1, the second copies length 2, ..., up to length $N$. The sum of these copy operations is $1+2+...+N = N(N+1)/2$, which is quadratic complexity. The Join Solution ($O(n)$): "".join(chunks) is optimized. It performs two passes: 1. It scans the list of chunks to calculate the total size of the final string. 2. It allocates the exact memory needed once. 3. It copies all chunks into the buffer sequentially. This ensures every byte is copied exactly once, resulting in linear complexity.

Answer: Built-in types (like list, dict) define the core data structures. Abstract Base Classes (ABCs) define the Interface or contract that a type must follow. Production Enforcement: In a plugin-based system (e.g., a data processor that supports multiple input formats), you define an ABC (e.g. DataSource). By using the @abstractmethod decorator, Python prevents the instantiation of any subclass that hasn't implemented the required methods. Virtual Subclassing: ABCs also support 'Virtual Subclassing' via register(). You can take an existing class (like a third-party library's connection object) and register it as a subclass of your ABC. This allows isinstance(obj, Plugin) to return True even if the developer of the third-party library never heard of your Plugin class. This provides a powerful way to enforce system boundaries and type safety across diverse codebases without rigid inheritance hierarchies.

Answer: Venvs follow host OS conventions. On POSIX (Linux/macOS), binaries live in bin/ and libraries in lib/pythonX.Y/site-packages/. On Windows, binaries live in Scripts/ and libraries in Libsite-packages. This is a friction point for cross-platform scripts (e.g., Makefiles). Robust systems use 'python -m' to avoid path dependencies or check the OS environment variable to resolve paths.

Answer: Python uses Reference Counting as its primary garbage collection strategy. Every object has an obrefcnt field. When a new variable points to an object, the count is incremented; when a variable is deleted or goes out of scope, it is decremented. The Concurrency Problem: In a multi-threaded system, if two threads try to increment the refcount of the same object simultaneously, a Race Condition occurs. Without synchronization, the count might only increment once instead of twice, leading to the object being prematurely deleted while still in use (causing a crash). The GIL's Role: The Global Interpreter Lock (GIL) solves this by ensuring that only one thread can execute Python bytecode at a time. This makes refcount operations implicitly thread-safe because the thread modifying the count holds the global lock. While this simplifies the interpreter's C-code and protects memory integrity, it prevents Python from utilizing multiple CPU cores for CPU-bound tasks, which is a major scaling trade-off in production.

Answer: list1 + list2 (Concatenation) creates a new list containing copies of references from both source lists. If l1 and l2 have 1 million items each, the result is a new 2 million item list. This triples the memory usage (l1 + l2 + result) and is an O(n+m) operation. itertools.chain(l1, l2) returns an iterator. It essentially yields items from l1 until exhausted, then yields from l2. It does not allocate memory for the combined sequence. It uses O(1) extra memory. This is critical for processing large streams of data.

Answer: lrucache(maxsize=N): Implements a Least Recently Used cache with a fixed size. When the cache reaches N items, the oldest (least recently accessed) entry is evicted. cache: An unbounded cache. It stores every result forever as long as the process is running. Production Recommendation: In a long-running web server, you should almost always prefer lrucache with a specific maxsize. An unbounded cache can cause a Memory Leak if the input domain is large (e.g., caching database results for millions of unique user IDs). Over time, the Python process will consume all available RAM and crash (OOM). Use cache only for functions with a very small, finite set of possible inputs (e.g., config settings).

Answer: An Edge-Optimized endpoint routes traffic through the nearest CloudFront Point of Presence (PoP), which reduces latency for geographically distributed users by getting the request onto the provider's high-speed backbone as quickly as possible. A Regional endpoint is intended for clients in the same region as the API and does not use a CDN, making it better for high-throughput internal communication or if you manage your own CDN.

Answer: RSA relies on the difficulty of factoring large primes, requiring massive keys (2048+ bits) for security. ECC relies on the discrete logarithm problem over elliptic curves, offering the same security with much smaller keys. ECC is preferred for IoT/Mobile because: 1. Performance: Smaller keys mean faster computations and less battery drain. 2. Bandwidth: Smaller certificates reduce data transmitted during handshakes, speeding up connections on slow networks.

Answer: Yes, inheritance is fully supported. Ordering: Python traverses the MRO in reverse order (from base to child). Fields from the base class come first in the generated init argument list, followed by fields from the child class. Constraint: If Base has a field with a default value (x: int = 0), then all fields in Child must also have default values. Otherwise, the init signature would have a non-default argument following a default argument (def init(self, x=0, y)), which is a SyntaxError.

Answer: A Source Distribution (sdist) contains the raw source code of a package and metadata. When a user installs an sdist, pip must first execute a build step (typically via setup.py or a build backend) to create a 'built' format before it can be installed. If the package contains C or Rust extensions, this build step requires the user to have the correct compilers (like gcc or msvc) and development headers installed on their system. This is a common point of failure for beginners and a significant time sink for large projects. A Wheel (.whl), conversely, is a 'Built Distribution' format. It is essentially a ZIP archive containing the already-compiled files ready to be moved into the site-packages directory. By shifting the compilation burden from the user to the package maintainer (who builds the wheels for various OS/Arch combinations), the installation becomes a simple 'unpack and move' operation. This guarantees consistent results, significantly reduces installation time (especially in CI/CD pipelines), and eliminates the need for end-users to manage complex system-level build dependencies.

Answer: No, Ternary Search is not necessarily better. While it reduces the number of iterations by dividing the range into three, it performs more comparisons (at least two) per iteration compared to Binary Search (one or two). In most computational environments, the constant factor in Binary Search's O(log2 n) is smaller than the constant factor in Ternary Search's O(log3 n).