Python remains one of the most popular programming languages for backend development, data science, and automation. This guide covers the questions you need to master for any Python interview.

Python Fundamentals

Lists are mutable (can be modified), tuples are immutable (cannot be modified after creation). Tuples are faster and use less memory. Use tuples for fixed data, lists for dynamic collections.

The GIL is a mutex that protects access to Python objects, preventing multiple threads from executing Python bytecode simultaneously. It limits multi-threaded CPU-bound programs. Use multiprocessing for CPU-bound tasks.

*args allows passing variable number of positional arguments as a tuple. **kwargs allows passing variable number of keyword arguments as a dictionary. They enable flexible function signatures.

def example(*args, **kwargs):
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(f"{key}: {value}")

example(1, 2, 3, name="John", age=25)

Object-Oriented Python

Decorators are functions that modify the behavior of other functions without changing their code. They use the @decorator syntax and are commonly used for logging, authentication, and caching.

def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"Took {time.time() - start:.2f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)

@staticmethod has no access to class or instance. @classmethod receives the class as first argument (cls) and can access/modify class state. Use classmethod for factory methods, staticmethod for utility functions.

Advanced Python

Generators use yield to produce a sequence of values lazily, one at a time. They are memory efficient for large datasets. Use for: processing large files, infinite sequences, and pipeline processing.

async/await enables asynchronous programming for I/O-bound operations. async defines a coroutine, await pauses execution until the awaited coroutine completes. Use asyncio for concurrent I/O operations.