Python Interview Questions & Answers for All Levels

Lists are mutable (can be modified after creation) while tuples are immutable (cannot be changed). Tuples are hashable (can be used as dictionary keys or set elements) if all their elements are hashable. When to use tuples: • Fixed collections of heterogeneous data (like a database row) • Dictionary keys or set elements • Function return values with multiple elements When to use lists: • Collections that need to grow, shrink, or be sorted • Homogeneous sequences you plan to iterate and modify Performance considerations: • Tuples are slightly faster to create and iterate due to immutability optimizations • Tuples use less memory — Python can cache small tuples and reuse them • In practice, the choice signals intent: a tuple says 'this data won't change,' which helps readers understand your code

The GIL is a mutex in CPython that allows only one thread to execute Python bytecode at a time. This means CPU-bound multithreaded Python code doesn't achieve true parallelism — threads take turns rather than running simultaneously. When the GIL doesn't matter: • The GIL is released during I/O operations (network requests, file reads, database queries) • I/O-bound multithreading is still effective and widely used Workarounds for CPU-bound parallelism: • Use the multiprocessing module — separate processes, each with its own GIL • Use libraries like NumPy that release the GIL during C-level computations • Use concurrent.futures.ProcessPoolExecutor for a higher-level API Recent developments: • Python 3.13 introduced an experimental free-threaded mode (--disable-gil) that removes the GIL entirely, though it's not yet the default

A decorator is a function that takes another function as input and extends its behavior without modifying its source code. It's syntactic sugar for higher-order functions. Simple example: def timer(func): def wrapper(*args, **kwargs): start = time.time() result = func(*args, **kwargs) print(f'{func.__name__} took {time.time()-start:.2f}s') return result return wrapper Usage: @timer above a function definition. Under the hood, @timer on def my_func is equivalent to my_func = timer(my_func). Common real-world decorators: • @functools.lru_cache — memoization • @property — computed attributes • @staticmethod — static methods • Framework decorators like Flask's @app.route Best practice: Always use @functools.wraps(func) in your wrapper to preserve the original function's metadata.

Python's dict uses a hash table with open addressing (specifically, a probe sequence using perturbation). How insertion works: 1. Python computes the key's hash 2. Maps it to a table index 3. Stores the key-value pair there 4. If two keys hash to the same index (collision), Python probes the next available slot using a perturbation-based sequence Time complexity: • Average-case: O(1) for get, set, and delete • Worst-case (all keys collide): O(n), but Python's hash function makes this extremely unlikely Key details: • Since Python 3.7, dictionaries maintain insertion order (implementation detail in 3.6, guaranteed in 3.7+) • Python over-allocates the hash table (resizing at 2/3 capacity) to keep collisions low, trading memory for speed • Keys must be hashable — implementing __hash__ and __eq__ is required for custom objects used as keys

Core distinction: • __new__ is the class constructor — it creates and returns a new instance of the class • __init__ is the initializer — it sets up the instance after it's been created Call sequence: 1. obj = MyClass.__new__(MyClass) 2. MyClass.__init__(obj) When to override __new__: In practice, you rarely override __new__. The main use cases are: • Implementing singletons (return the same instance every time) • Subclassing immutable types (str, int, tuple) — you must set the value in __new__ since the object is immutable by the time __init__ runs • Metaclass programming Important caveat: If __new__ doesn't return an instance of the class, __init__ won't be called.