Python Backend Interview Master

Python is a high-level, interpreted, general-purpose programming language. It is known for its simplicity, readability, and vast library support, maki...

Lists are mutable (can be changed) and use square brackets []. Tuples are immutable (cannot be changed) and use parentheses (). Lists are generally sl...

PEP 8 is the official Style Guide for Python Code. It provides guidelines on how to format code to improve readability and consistency across the Pyth...

Python uses a private heap to manage memory. It includes a built-in garbage collector that uses reference counting and a cycle-detecting algorithm to ...

Namespaces are containers that store names (identifiers) mapping to objects. They ensure that names are unique and don't conflict, such as local, glob...

'is' checks for identity (if two variables point to the same object in memory), while '==' checks for equality (if the values are the same).

Decorators are a powerful way to modify or wrap the behavior of a function or class without changing its source code. They use the @decorator_name syn...

List comprehension is a concise way to create lists based on existing lists or iterables. Example: [x*x for x in range(10) if x%2==0].

A docstring (documentation string) is a string literal used as the first statement in a module, function, class, or method to describe its purpose. It...

*args allows a function to accept any number of positional arguments as a tuple. **kwargs allows a function to accept any number of keyword arguments ...

A shallow copy creates a new object but references the nested objects of the original. A deep copy creates a new object and recursively copies all nes...

Using try, except, else, and finally blocks. Code that might fail goes in try, handling logic in except, success logic in else, and cleanup in finally...

'self' represents the instance of the class. It allows access to the attributes and methods of the specific object being worked with.

A lambda function is a small, anonymous, one-line function defined using the 'lambda' keyword. It can take any number of arguments but has only one ex...

The 'with' statement simplifies resource management (like file handling) by ensuring that resources are properly closed or released, even if an error ...

'pass' is a null statement. It is used as a placeholder when a statement is syntactically required but no action is needed.

In Python 2, range returns a list, while xrange returns an iterator (memory efficient). In Python 3, range behaves like xrange, and xrange no longer e...

You can use the list.reverse() method (in-place) or slicing [::-1] (creates a new list).

Global variables are defined outside any function and accessible throughout the module. Local variables are defined inside a function and only accessi...

'yield' is used in functions to return a generator. Unlike 'return', it pauses the function's execution and saves its state, allowing it to resume lat...

A dictionary is an unordered, mutable collection of key-value pairs. Keys must be unique and immutable (hashable).

Use the '#' symbol for single-line comments. For multi-line comments, triple quotes (''' or """) are often used as docstrings or multi-line strings.

'break' exits the loop. 'continue' skips the current iteration. 'pass' does nothing (placeholder).

Using the built-in len() function. Example: len("hello").

Slicing allows you to extract a portion of a sequence (list, string, tuple) using the [start:stop:step] syntax.

map() applies a given function to each item of an iterable (like a list) and returns an iterator with the results.

filter() constructs an iterator from elements of an iterable for which a function returns true.

reduce() (from functools) applies a rolling computation to sequential pairs of values in an iterable, reducing it to a single value.

The __init__ method is the constructor of a class. It is called automatically when an object is created to initialize its attributes.

A list is an ordered collection that allows duplicates. A set is an unordered collection of unique elements.

Using the 'def' keyword followed by the function name and parentheses. Example: def my_func(): pass

A module is a file containing Python definitions and statements. It can be imported into other scripts using the 'import' keyword.

A package is a directory containing a collection of modules and a special __init__.py file (optional in modern Python).

The 'global' keyword allows you to modify a variable defined at the global scope from within a function.

'nonlocal' is used in nested functions to refer to a variable in the nearest enclosing scope (excluding global).

An iterable is any object capable of returning its members one at a time, allowing it to be looped over in a for loop (e.g., list, string, dict).

An iterator is an object that implements the iterator protocol (__iter__ and __next__ methods). It tracks the current position during iteration.

A generator is a type of iterator created using a function with 'yield' or a generator expression. It produces values lazily (one at a time).

Using the int() function. Example: int("10").

Using the type() function or isinstance() (preferred for inheritance checks).

dir() returns a list of valid attributes and methods for an object or the current local scope.

help() is a built-in function used to display documentation for modules, classes, functions, and keywords.

Using the input() function. It always returns the input as a string.

append() adds a single element to the end of a list. extend() adds all elements of an iterable to the end of the list.

join() concatenates elements of an iterable (like a list of strings) using a separator string. Example: ", ".join(["a", "b"]).

split() breaks a string into a list of substrings based on a delimiter (default is whitespace).

getattr(obj, name) gets the value of an attribute by name. setattr(obj, name, value) sets the value of an attribute by name.

sorted() returns a new sorted list from an iterable. sort() sorts the list in-place and returns None.

A data type that can have one of two values: True or False. Note the capitalization.

Using open("filename", "w"). "w" overwrites the file, while "a" appends to it.

The GIL is a mutex that protects access to Python objects, preventing multiple native threads from executing Python bytecodes at once. This simplifies...

Using the multiprocessing module (separate processes), using C extensions that release the GIL, or for I/O bound tasks, using threading or asyncio.

Threading shares the same memory space (efficient but limited by GIL). Multiprocessing creates separate memory spaces (sidesteps GIL, better for CPU-b...

Monkey patching is the practice of modifying or extending the behavior of a module or class at runtime, often used for testing or bug fixes without ch...

Class methods (@classmethod) take 'cls' as the first argument and can access class-level state. Static methods (@staticmethod) don't take an implicit ...

MRO is the order in which Python searches for base classes when a method is called. Python uses the C3 Linearization algorithm to determine this order...

super() is used to call methods of a parent class or sibling class. It handles MRO correctly, ensuring that each parent is called only once.

Metaclasses are 'classes of classes'. They define how a class is constructed. The default metaclass is 'type'. You can use them to automatically modif...

ABCs (from 'abc' module) define a set of methods that a subclass must implement. They cannot be instantiated directly and are used to define interface...

Pickling is the process of converting a Python object into a byte stream (serialization). Unpickling is the reverse (deserialization).

An object that defines the runtime context when executing a 'with' statement. It implements __enter__ and __exit__ methods.

By implementing a class with __enter__ and __exit__, or using the @contextmanager decorator from contextlib module.

A programming style where an object's suitability is determined by the presence of certain methods and properties, rather than its actual type ('If it...

Formatted string literals (introduced in 3.6) that use f"..." syntax. They allow embedding expressions inside curly braces for concise and performant ...

@property allows you to define a method that can be accessed like an attribute. It's used for encapsulation and validation (getter/setter/deleter).

A descriptor is an object that defines __get__, __set__, or __delete__ for an attribute. Built-in descriptors include property, classmethod, and stati...

__slots__ is a list of attributes that limits the attributes an instance can have. It saves memory by preventing the creation of the __dict__ for each...

Introduced in 3.8, it allows you to assign a value to a variable as part of an expression. Example: if (n := len(data)) > 10: print(n).

Threading uses OS-level pre-emptive multitasking. Asyncio uses cooperative multitasking (event loop) on a single thread. Asyncio is better for scaling...

A coroutine is a specialized generator-like object defined with 'async def'. It can pause execution (await) and yield control back to the event loop.

A modern, high-performance web framework for building APIs with Python 3.7+ based on standard Python type hints. It is extremely fast due to Starlette...

A high-level Python web framework that encourages rapid development and clean, pragmatic design. It follows the 'batteries included' philosophy.

A micro web framework for Python. It is lightweight and modular, allowing developers to choose their own tools and libraries.

WSGI (Web Server Gateway Interface) is synchronous. ASGI (Asynchronous Server Gateway Interface) supports asynchronous features like WebSockets and HT...

A library used for data validation and settings management using Python type annotations. It's heavily used in FastAPI.

An asynchronous task queue/job queue based on distributed message passing. It's used for running background tasks in web applications.

A lightweight database migration tool for use with SQLAlchemy. It handles evolution of database schemas over time.

A powerful SQL toolkit and Object Relational Mapper (ORM) that gives developers the full power and flexibility of SQL.

Testing individual components of code in isolation. Common libraries include 'unittest' (built-in) and 'pytest' (popular third-party).

The process of replacing parts of your system with mock objects that simulate their behavior, allowing you to isolate the code being tested.

Fixtures are functions that run before (and optionally after) tests to provide setup and teardown logic (e.g., DB connections, test data).

A tool to create isolated Python environments where you can install dependencies without affecting the global system Python.

The Python Package Index (PyPI) is the official repository for third-party Python software packages.

Modern dependency management tools that replace pip and virtualenv. They provide deterministic builds using lock files.

A Python WSGI HTTP Server for UNIX. It is a pre-fork worker model and is commonly used to deploy Django and Flask apps.

A lightning-fast ASGI server implementation, used for running FastAPI and other asynchronous web frameworks.

Cross-Origin Resource Sharing is a security feature that controls which domains can access your API resources.

JSON Web Tokens are used for secure authentication. Libraries like PyJWT are used to encode and decode tokens.

Sessions are stored on the server (stateful). Tokens (like JWT) are stored on the client (stateless), making them better for scaling.

Code that sits between the request and response. It can inspect/modify requests before they reach the view or responses before they reach the client.

Nginx acts as a reverse proxy, load balancer, and static file server, sitting in front of the application server (Gunicorn/Uvicorn).

Using Common Table Expressions (CTEs) or specific ORM features like 'adjacency list' patterns for hierarchical data.

A performance issue where the ORM executes one query to get a list and then N additional queries to get related data for each item. Solved using 'eage...

Caching, session storage, real-time analytics, and as a message broker for Celery.

A protocol for real-time, full-duplex communication over a single TCP connection. Supported by ASGI frameworks like FastAPI and Django Channels.

Using the 'cProfile' module to measure where the time is spent in your application.

Occurs when Module A imports B and B imports A. Fix by refactoring, using local imports inside functions, or moving imports to the bottom.

A weak reference is a reference that doesn't prevent its object from being garbage collected. Useful for caches.

A collection of functions that create iterators for efficient looping (e.g., chain, cycle, groupby, product).

Higher-order functions for working with functions (e.g., lru_cache for memoization, partial for pre-filling arguments).

Primary mechanism is reference counting. For cyclic references, it uses a generational collector that periodically scans three 'generations' of object...

Bytecode (.pyc) is an intermediate representation optimized for the Python Virtual Machine (PVM). Machine code is what the CPU understands. CPython is...

Just-In-Time compilation (used in PyPy) compiles hot spots of code directly to machine code for significantly better performance.

Frames track the execution of a block of code (like a function). They contain the local namespace, the stack, and references to previous frames.

The ability of a program to examine the type or properties of an object at runtime using functions like hasattr(), getattr(), dir(), type().

Use built-in functions, avoid global variables, use local variables, use joins for strings, use generator expressions, use C extensions (Cython/Numba)...

Data descriptors implement both __get__ and __set__. Non-data descriptors only implement __get__. Data descriptors take precedence over instance __dic...

Techniques to avoid copying data in memory during I/O, often using 'memoryview' and 'buffer protocol'.

A built-in that allows you to access internal buffers of objects (like bytes) without copying the data. Essential for performance in large data proces...

An attack where malicious SQL is injected into queries. Prevent by using parameterized queries (provided by almost all Python DB drivers and ORMs).

Cross-Site Scripting. Prevent by auto-escaping templates (Django/Jinja2 do this) and validating all user inputs.

Synchronous (HTTP/gRPC) or Asynchronous (RabbitMQ/Kafka/Selaery).

A high-performance RPC framework using Protocol Buffers and HTTP/2. Better for internal microservice communication than REST.

A sequence of local transactions where each one updates the DB and publishes an event to trigger the next one. Handles failures with 'compensation' tr...

Consistency, Availability, and Partition Tolerance. A distributed system can only guarantee two of the three.

Horizontal: adding more machines (stateless apps are easier). Vertical: adding more CPU/RAM to one machine.

Deploying individual functions (AWS Lambda/Google Cloud Functions) that scale automatically. Python is great for this due to small startup times.

Organizing code into layers (Entities, Use Cases, Adapters) to keep business logic independent of external frameworks/DBs.

A set of best practices for building scalable, maintainable SaaS apps (e.g., config in env, stateless processes, dev/prod parity).

A technique used in distributed caching (like Redis Cluster) to minimize data movement when nodes are added or removed.

Splitting a large database into smaller pieces (shards) across different servers to improve performance and capacity.

Token Bucket, Leaky Bucket, Fixed Window, and Sliding Window logs. Important for API stability.

A pattern to detect failures and encapsulate the logic of preventing a failure from cascading. Libraries like 'poly' help here.

Using OpenTelemetry, Jaeger, or Zipkin to track requests as they flow through multiple services.

Storing the state of the system as a sequence of events rather than just the current state.

Command Query Responsibility Segregation. Splitting read and write operations into different models for better performance and scalability.

Uses selectors to wait for I/O events. Tasks are scheduled and run on a single thread. It maintains a ready queue and a scheduled queue.

A module for managing context-local state that works across asynchronous tasks (unlike threading.local).

DataClasses are mutable and feature-rich. NamedTuples are immutable and more memory-efficient.

Using static type checkers like Mypy, Pyright, or Pytype to find bugs before runtime.

A language that serves as a superset of Python, allowing you to write C extensions with Python-like syntax for extreme performance.

An open-source JIT compiler that translates a subset of Python and NumPy code into fast machine code using LLVM.

Using the importlib module and implementing meta path finders and loaders.

Python automatically caches short strings and identifiers to save memory and speed up comparisons (sys.intern() can be used manually).

The static method that actually creates the object, while __init__ initializes it. Used mostly in metaclasses and singletons.

Everything in Python is an object, including types and functions. Objects have an ID, type, and value.

The algorithm Python uses to compute Method Resolution Order (MRO) for multiple inheritance.

Offload to Celery or Dramatiq using Redis or RabbitMQ as a broker.

Pessimistic: Locks the row (SELECT FOR UPDATE). Optimistic: Checks for changes at the end (using version/timestamp columns).

Indexes, Explain Plan, Partial Indexes, Covering Indexes, Denormalization when needed.

Blue-Green: Swapping two identical environments. Canary: Slowly Rolling out to a small subset of users.

An auxiliary container (e.g., logging/proxy) running alongside your Python container in the same pod.

Use Secrets Managers (AWS Secrets Manager, HashiCorp Vault) and inject via env vars.

Two-step process: Add new column (nullable), backfill, then remove old logic/column in next release.

When many clients request a stale cache entry at once, causing a surge on the database. Fix with 'locking' or 'probabilistic early expiration'.

A query language for APIs. Libraries like Graphene or Ariadne are used with Python frameworks.

Robots.txt, rate limiting, human-like behavior (rotating UX), using BeautifulSoup or Scrapy.

Monitoring tells you 'what' went wrong. Observability tells you 'why', using logs, metrics, and traces.

Shared DB with ID, Schema-based, or separate DBs per tenant.

Purposely breaking things in production (e.g., killing a pod) to ensure the system is resilient.

Use a generator for memory efficiency.

def fib(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

Use slicing.

def is_pal(s):
    return s == s[::-1]

Use a set or dictionary.

def finds_dups(l):
    return set([x for x in l if l.count(x) > 1])

Use sorted() with a lambda or itemgetter.

sorted(data, key=lambda x: x['age'])

Iterate over the file object.

with open('f.txt') as f:
    for line in f:
        print(line)

Use recursion or a nested comprehension.

def flatten(l):
    return [item for sub in l for item in sub]

Use collections.Counter.

from collections import Counter
counts = Counter([1, 2, 2, 3])

Function returning a wrapper.

def my_dec(f):
    def wrapper(*a, **k):
        print('Start')
        return f(*a, **k)
    return wrapper

Use | (3.9+) or {**d1, **d2}.

merged = d1 | d2

Standard recursive call.

def fact(n):
    return 1 if n <= 1 else n * fact(n-1)

Compare length with set length.

len(l) == len(set(l))

Use dict() constructor.

d = dict([('a', 1), ('b', 2)])

Use set intersection.

intersect = list(set(l1) & set(l2))

Using __new__.

class Singleton:
    _instance = None
    def __new__(cls):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

List comprehension.

[x for x in l if x % 2 == 0]

Split, reverse, join.

' '.join(s.split()[::-1])

Counter.most_common().

Counter(l).most_common(1)

Use time module.

import time
start = time.time()
func()
print(time.time() - start)

Split and title().

''.join(x.title() for x in s.split('_'))

Slicing.

l[-n:]

Iterative approach.

while low <= high:
    mid = (low+high)//2
    # comparison...

Slicing in a loop.

[l[i:i+n] for i in range(0, len(l), n)]

strip() or replace().

s.replace(' ', '')

string and random modules.

''.join(random.choice(string.ascii_letters) for _ in range(10))

isinstance().

isinstance(v, int)

Filter.

[x for x in l if x is not None]

datetime module.

from datetime import datetime
now = datetime.now()

strftime().

now.strftime('%Y-%m-%d')

Using 'from'.

raise NewError from old_error

copy.deepcopy().

import copy
new_obj = copy.deepcopy(old_obj)

Loop check.

all(n % i for i in range(2, int(n**0.5) + 1))

Sum difference.

sum(range(n+1)) - sum(arr)

Use a list with append/pop.

s = []
s.append(1)
s.pop()

Use collections.deque.

from collections import deque
q = deque()
q.append(1)
q.popleft()

Recursion.

def map_nested(f, l):
    return [map_nested(f, x) if isinstance(x, list) else f(x) for x in l]

Dict comprehension with intersection.

{k: d1[k] for k in d1.keys() & d2.keys()}

os.environ.

import os
val = os.environ.get('KEY')

dict(zip(l1, l2)).

d = dict(zip(keys, values))

tempfile module.

import tempfile
with tempfile.NamedTemporaryFile() as t: ...

Sort and compare.

sorted(s1) == sorted(s2)

math.gcd().

import math
math.gcd(10, 20)

bin().

bin(10)

Context manager.

class Timer:
    def __enter__(self): self.start = time.time(); return self
    def __exit__(self, *a): print(time.time() - self.start)

functools.cmp_to_key.

sorted(l, key=cmp_to_key(my_cmp))

sys.getsizeof().

import sys
sys.getsizeof(obj)

contextlib.redirect_stdout.

with redirect_stdout(f): print('hello')

json.loads().

import json
data = json.loads(s)

os.path.exists().

os.path.exists('path')

async for.

async for item in async_gen(): print(item)

startswith().

s.startswith('pre')