Python Interview Questions

def add_item(item, items=[]):  # BUG: shared across all calls
    items.append(item)
    return items
# add_item(1) returns [1]
# add_item(2) returns [1, 2]  -- surprise!

a = [1, 2, 3]
b = [1, 2, 3]
c = a

a == b   # True (same value)
a is b   # False (different objects in memory)
a is c   # True (c points to same object as a)

a = 256
b = 256
a is b  # True -- CPython caches integers -5 to 256

a = 257
b = 257
a is b  # False in the REPL, but may be True in a .py file!

x = 10  # Global

def outer():
    y = 20  # Enclosing

    def inner():
        nonlocal y   # Modifies enclosing scope's y
        global x     # Modifies module-level x
        x = 99
        y = 99

    inner()
    print(y)  # 99 (modified by nonlocal)

outer()
print(x)  # 99 (modified by global)

x = 10
def broken():
    print(x)  # UnboundLocalError!
    x = 20    # This assignment makes x local to entire function

[1, [2, 3]] == [1, [2, 3]]  # True -- deep comparison

def handle_command(command):
    match command:
        case ["quit"]:
            return "Exiting"
        case ["go", direction]:
            return f"Going {direction}"
        case ["get", item] if item != "sword":
            return f"Picking up {item}"
        case _:
            return "Unknown command"

# Without walrus -- duplicate call or temp variable
data = get_data()
if data:
    process(data)

# With walrus -- single expression
if (data := get_data()):
    process(data)

# Especially useful in while loops
while (chunk := file.read(8192)):
    process(chunk)

# And in list comprehensions with expensive filtering
results = [clean for item in items if (clean := expensive_transform(item)) is not None]

my_list = [1, 2, 3]          # Literal (fastest)
my_list = list(range(10))    # From iterable
my_list = [0] * 100          # Pre-allocated (useful for performance)
my_list = [x**2 for x in range(10)]  # Comprehension (Pythonic)

# Loop version (~30% slower in CPython benchmarks)
squares = []
for x in range(1000):
    squares.append(x**2)

# Comprehension (faster -- no repeated attribute lookup for .append)
squares = [x**2 for x in range(1000)]

# Nested comprehension (flattening)
flat = [x for row in matrix for x in row]

# Dict comprehension
word_lengths = {word: len(word) for word in words}

# Set comprehension
unique_lengths = {len(word) for word in words}

# Conditional expression (ternary in comprehension)
labels = ["even" if x % 2 == 0 else "odd" for x in range(10)]

groups = {}
for item in items:
    groups.setdefault(item.category, []).append(item)

merged = dict1 | dict2      # Creates new dict (dict2 wins on conflicts)
dict1 |= dict2              # In-place merge

# This fails -- sets are not hashable
# my_set = {  {1, 2}, {3, 4}  }  # TypeError

# This works -- frozensets are hashable
my_set = { frozenset({1, 2}), frozenset({3, 4}) }
cache_key = frozenset(user_permissions)  # Use as dict key

my_set = {1, 2, 3}
my_set.union([4, 5, 6])    # Works -- accepts list
my_set | [4, 5, 6]         # TypeError -- operator needs set on both sides

# Find users with both permissions (intersection)
admin_users = set(admins) & set(active_users)

# Find new users who signed up but have not verified (difference)
unverified = set(signups) - set(verified_emails)

# Find features unique to either A/B test group (symmetric diff)
unique_features = set(group_a_features) ^ set(group_b_features)

# Check if required permissions are all present (subset)
if required_perms <= user_perms:
    grant_access()

import copy

original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)

# Shallow copy shares nested objects
shallow[0][0] = 99
print(original[0][0])  # 99 -- original affected!

# Deep copy is fully independent
deep[0][0] = 88
print(original[0][0])  # Still 99 -- original unaffected

# A config template shared across requests
config_template = {"db": {"host": "localhost", "port": 5432}}

def get_config(user):
    config = config_template.copy()  # SHALLOW -- shares nested dict
    config["db"]["host"] = user.db_host  # Mutates template!
    return config
# After first call, config_template is corrupted for all future calls

from collections import defaultdict

# Groups items by category -- no KeyError, no setdefault boilerplate
word_counts = defaultdict(int)      # Missing keys get 0
grouped = defaultdict(list)         # Missing keys get []
nested = defaultdict(lambda: defaultdict(int))  # Nested defaults

for word in words:
    word_counts[word] += 1          # No need to check if key exists

for item in items:
    grouped[item.category].append(item)  # No need for setdefault

d = defaultdict(int)
d["a"] = 1
print(d["b"])  # Returns 0 but ALSO creates key "b" in the dict
print(len(d))  # 2, not 1!

class Person:
    species = "Human"  # Class attribute (shared by all instances)

    def __init__(self, name, age):
        self.name = name   # Instance attribute
        self.age = age

    def greet(self):
        return f"Hello, I am {self.name}"

p = Person("Alice", 30)

# dataclasses (Python 3.7+) -- eliminates boilerplate
from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int
    email: str = ""  # Default value

# Gets __init__, __repr__, __eq__ for free
# Also supports frozen=True for immutability, slots=True for memory

# NamedTuple -- lightweight immutable records
from typing import NamedTuple

class Point(NamedTuple):
    x: float
    y: float

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    @classmethod
    def from_string(cls, date_string):
        year, month, day = map(int, date_string.split('-'))
        return cls(year, month, day)  # cls, not Date -- works with subclasses!

    @classmethod
    def today(cls):
        import datetime
        t = datetime.date.today()
        return cls(t.year, t.month, t.day)

class MathUtils:
    @staticmethod
    def is_even(n):
        return n % 2 == 0

class Animal:
    def speak(self):
        raise NotImplementedError

class Dog(Animal):
    def speak(self):
        return "Woof"

class A:
    def method(self): return "A"

class B(A):
    def method(self): return "B"

class C(A):
    def method(self): return "C"

class D(B, C):
    pass

D().method()  # Returns "B" -- MRO is D -> B -> C -> A -> object

class B(A):
    def method(self):
        return super().method()  # Calls C.method(), NOT A.method()!

def func(pos_only, /, normal, *, kw_only, **kwargs):
    pass
# pos_only: positional-only (Python 3.8+, before /)
# normal: positional or keyword
# kw_only: keyword-only (after *)
# **kwargs: catches remaining keyword args

# 1. Wrapper/decorator functions -- must pass through all arguments
def timing_decorator(func):
    def wrapper(*args, **kwargs):  # Accept anything
        start = time.time()
        result = func(*args, **kwargs)  # Pass through everything
        print(f"Took {time.time() - start:.3f}s")
        return result
    return wrapper

# 2. Extending parent class methods
class Child(Parent):
    def __init__(self, extra_param, *args, **kwargs):
        self.extra = extra_param
        super().__init__(*args, **kwargs)  # Forward to parent

# 3. Unpacking into function calls
args_tuple = (1, 2, 3)
kwargs_dict = {"name": "Alice", "age": 30}
func(*args_tuple, **kwargs_dict)  # Equivalent to func(1, 2, 3, name="Alice", age=30)

def example(a, b, /, c, d, *, e, f):
    pass
# a, b: positional only (cannot pass as keywords)
# c, d: either positional or keyword
# e, f: keyword only (cannot pass positionally)

# Sorting with custom key (most common legitimate use)
users.sort(key=lambda u: u.last_login)
sorted(items, key=lambda x: (x.priority, -x.created_at))

# Quick callbacks
button.on_click(lambda event: print(f"Clicked at {event.x}"))

# Simple transformations with map/filter
names = list(map(lambda u: u.name, users))

# BAD: Assigning lambda to a variable (use def instead)
square = lambda x: x**2  # flake8 E731 violation
# GOOD:
def square(x):
    return x**2

# BAD: Complex logic crammed into a lambda
process = lambda x: x.strip().lower().replace(' ', '_') if x else 'unknown'
# GOOD: Named function with clear intent
def normalize_name(x):
    if not x:
        return 'unknown'
    return x.strip().lower().replace(' ', '_')

from operator import itemgetter, attrgetter
# Instead of: sorted(items, key=lambda x: x['name'])
sorted(items, key=itemgetter('name'))        # Faster, clearer
sorted(users, key=attrgetter('last_login'))   # Same for attributes

@my_decorator
def func():
    pass
# Is exactly equivalent to:
func = my_decorator(func)

import functools

def my_decorator(func):
    @functools.wraps(func)  # CRITICAL: preserves __name__, __doc__, __module__
    def wrapper(*args, **kwargs):
        # Before logic
        result = func(*args, **kwargs)
        # After logic
        return result
    return wrapper

def retry(max_attempts=3, delay=1):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception:
                    if attempt == max_attempts - 1:
                        raise
                    time.sleep(delay)
        return wrapper
    return decorator

@retry(max_attempts=5, delay=2)
def fetch_data(url):
    return requests.get(url)

class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        return self.func(*args, **kwargs)

def make_multiplier(factor):
    def multiply(x):
        return x * factor  # 'factor' is a free variable, captured by closure
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5))   # 10
print(triple(5))   # 15
print(double.__closure__[0].cell_contents)  # 2 -- the captured value

# BUG: All functions return 4 (the final value of i)
functions = []
for i in range(5):
    functions.append(lambda: i)
print([f() for f in functions])  # [4, 4, 4, 4, 4]

# FIX 1: Default argument captures current value
functions = []
for i in range(5):
    functions.append(lambda i=i: i)
print([f() for f in functions])  # [0, 1, 2, 3, 4]

# FIX 2: Use functools.partial
from functools import partial
functions = [partial(lambda i: i, i) for i in range(5)]

def fibonacci():
    a, b = 0, 1
    while True:
        yield a        # Pauses here, returns value
        a, b = b, a + b  # Resumes here on next() call

gen = fibonacci()     # No code executes yet -- returns generator object
next(gen)  # 0 -- executes until first yield
next(gen)  # 1 -- resumes after yield, executes until next yield
next(gen)  # 1

# List: allocates ALL 10M items in memory at once
data = [process(x) for x in range(10_000_000)]  # ~400MB for ints

# Generator: processes ONE item at a time, ~negligible memory
data = (process(x) for x in range(10_000_000))  # ~120 bytes

def accumulator():
    total = 0
    while True:
        value = yield total   # yield sends total, then pauses; send() resumes with value
        total += value

acc = accumulator()
next(acc)          # Initialize (runs to first yield) -- returns 0
acc.send(10)       # Returns 10
acc.send(20)       # Returns 30

def read_lines(path):
    with open(path) as f:
        for line in f:
            yield line.strip()

def filter_errors(lines):
    for line in lines:
        if "ERROR" in line:
            yield line

def parse_timestamp(lines):
    for line in lines:
        yield line.split()[0]

# Pipeline processes one line at a time -- handles files larger than RAM
pipeline = parse_timestamp(filter_errors(read_lines("huge.log")))

def process_user(
    name: str,
    age: int,
    emails: list[str],              # Python 3.9+ (lowercase generics)
    metadata: dict[str, Any] | None = None  # Python 3.10+ (union with |)
) -> User:
    ...

from typing import (
    Optional,    # Optional[X] == X | None
    Union,       # Union[X, Y] == X | Y (use | in 3.10+)
    Any,         # Disables type checking for this value
    TypeVar,     # Generic type variable
    Protocol,    # Structural subtyping (duck typing for type checkers)
    TypeAlias,   # Explicit type alias
    Literal,     # Literal["read", "write"] -- exact values
    TypedDict,   # Dict with specific key types
)

from typing import Protocol

class Readable(Protocol):
    def read(self) -> str: ...

def process(source: Readable) -> str:
    return source.read()
# ANY object with a read() -> str method satisfies this -- no inheritance needed

class File:
    def read(self): return "file data"

class HttpResponse:
    def read(self): return "http data"

class MockData:
    def read(self): return "test data"

def process(source):
    return source.read()  # Works with ALL three -- no shared base class needed

process(File())         # Works
process(HttpResponse()) # Works
process(MockData())     # Works -- great for testing!

# Reading -- always specify encoding explicitly
with open('file.txt', 'r', encoding='utf-8') as f:
    content = f.read()         # Entire file into string (dangerous for large files)

# Line-by-line (memory-efficient for large files)
with open('huge.log', 'r', encoding='utf-8') as f:
    for line in f:             # File object is an iterator -- reads one line at a time
        process(line)

# Writing
with open('output.txt', 'w', encoding='utf-8') as f:
    f.write('Hello World\n')

# Binary mode (images, protobuf, pickle)
with open('image.png', 'rb') as f:
    data = f.read()            # Returns bytes, not str

# DANGEROUS: truncates on open, data lost if crash before write completes
with open('config.json', 'w') as f:
    json.dump(config, f)

# SAFE: atomic write using temp file
import tempfile, os
with tempfile.NamedTemporaryFile('w', dir='.', delete=False, suffix='.tmp') as tmp:
    json.dump(config, tmp)
    tmp_path = tmp.name
os.replace(tmp_path, 'config.json')  # Atomic rename on POSIX

import csv

# Reading
with open('data.csv', 'r', encoding='utf-8') as f:
    reader = csv.DictReader(f)  # Prefer DictReader -- access by column name
    for row in reader:
        print(row['name'], row['email'])

# Writing
with open('output.csv', 'w', encoding='utf-8', newline='') as f:
    writer = csv.DictWriter(f, fieldnames=['name', 'age'])
    writer.writeheader()
    writer.writerow({'name': 'Alice', 'age': 30})

import json

# Serialization (Python -> JSON)
data = {'name': 'Alice', 'age': 30, 'active': True}
json_str = json.dumps(data, indent=2)        # To string
json.dump(data, open('data.json', 'w'))       # To file

# Deserialization (JSON -> Python)
parsed = json.loads(json_str)                 # From string
parsed = json.load(open('data.json', 'r'))    # From file

import datetime
from decimal import Decimal

def json_serializer(obj):
    if isinstance(obj, datetime.datetime):
        return obj.isoformat()
    if isinstance(obj, Decimal):
        return str(obj)
    raise TypeError(f"Not serializable: {type(obj)}")

json.dumps(data, default=json_serializer)

class DatabaseConnection:
    def __enter__(self):
        self.conn = connect_to_db()
        return self.conn       # Value bound by 'as' in 'with ... as'

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.conn.close()      # Always called, even if exception occurs
        return False           # False = re-raise exception, True = suppress it

from contextlib import contextmanager

@contextmanager
def timer(label):
    start = time.time()
    try:
        yield            # Code inside 'with' block runs here
    finally:
        elapsed = time.time() - start
        print(f"{label}: {elapsed:.3f}s")

with timer("data processing"):
    process_data()       # Automatically timed

# EAFP (Pythonic)
try:
    value = my_dict[key]
except KeyError:
    value = default

# LBYL (non-Pythonic in most cases)
if key in my_dict:
    value = my_dict[key]
else:
    value = default

# TERRIBLE -- hides all bugs, makes debugging impossible
try:
    complex_operation()
except:
    pass

# CORRECT -- catch specific exceptions, handle or log them
try:
    user = fetch_user(user_id)
except ConnectionError:
    logger.warning(f"DB connection failed for user {user_id}")
    user = get_cached_user(user_id)
except UserNotFoundError:
    raise HTTPException(status_code=404, detail="User not found")

BaseException
+-- SystemExit          # sys.exit() -- do NOT catch this
+-- KeyboardInterrupt   # Ctrl+C -- do NOT catch this
+-- GeneratorExit       # Generator cleanup
+-- Exception           # Base for all "normal" exceptions
    +-- StopIteration   # Signals iterator exhaustion
    +-- ArithmeticError
    |   +-- ZeroDivisionError
    +-- LookupError
    |   +-- IndexError
    |   +-- KeyError
    +-- OSError
    |   +-- FileNotFoundError
    |   +-- PermissionError
    |   +-- ConnectionError
    +-- ValueError
    +-- TypeError
    +-- AttributeError
    +-- RuntimeError
        +-- RecursionError

try:
    result = fetch_data(url)       # Code that might fail
except ConnectionError as e:
    logger.error(f"Connection failed: {e}")
    result = get_cached_data()     # Recovery logic
except ValueError as e:
    raise InvalidDataError(f"Bad response: {e}") from e  # Re-raise with chain
else:
    save_to_database(result)       # Only runs if NO exception in try block
    logger.info("Data saved successfully")
finally:
    cleanup_temp_files()           # ALWAYS runs (even if return/break/continue in try)

try:
    data = json.loads(response)
except json.JSONDecodeError as e:
    raise ValidationError("Invalid JSON response") from e
# The original exception is preserved in __cause__ for debugging

class AppError(Exception):
    """Base exception for our application."""
    def __init__(self, message: str, code: str = "UNKNOWN", details: dict = None):
        self.message = message
        self.code = code
        self.details = details or {}
        super().__init__(self.message)

class ValidationError(AppError):
    """Raised when input validation fails."""
    def __init__(self, field: str, message: str):
        super().__init__(
            message=f"Validation failed for '{field}': {message}",
            code="VALIDATION_ERROR",
            details={"field": field}
        )

class NotFoundError(AppError):
    """Raised when a requested resource does not exist."""
    def __init__(self, resource: str, resource_id: str):
        super().__init__(
            message=f"{resource} '{resource_id}' not found",
            code="NOT_FOUND",
            details={"resource": resource, "id": resource_id}
        )

# BAD: meaningless exception
raise Exception("Something went wrong")

# GOOD: specific, actionable
raise InsufficientFundsError(account_id=acct, requested=100, available=50)

assert condition, "Error message"
# Equivalent to:
if __debug__:
    if not condition:
        raise AssertionError("Error message")

# DANGEROUS: Using assert for input validation
def withdraw(amount):
    assert amount > 0, "Amount must be positive"  # Removed by -O flag!
    self.balance -= amount  # Oops, negative withdrawal goes through

# CORRECT: Use explicit validation
def withdraw(amount):
    if amount <= 0:
        raise ValueError("Amount must be positive")
    self.balance -= amount

import os                          # Full module -- use os.path.join()
from os.path import join, exists   # Specific names -- use join() directly
from os.path import join as pjoin  # Alias -- when name conflicts exist
import numpy as np                 # Community-standard aliases (np, pd, plt)

# a.py imports b.py, b.py imports a.py -- ImportError or AttributeError

# Fix 1: Import inside function (lazy import)
def process():
    from other_module import helper  # Only imported when function is called
    return helper()

# Fix 2: Restructure into a third module
# Fix 3: Use TYPE_CHECKING for type hints only
from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from other_module import MyType  # Only imported by type checkers, not at runtime

# mypackage/__init__.py
from .core import Engine
from .config import Config
from .exceptions import AppError

__all__ = ['Engine', 'Config', 'AppError']  # Controls 'from mypackage import *'

def main():
    # Application logic here
    print("Running as main program")

if __name__ == '__main__':
    main()

uv venv                    # Create venv (10-100x faster than python -m venv)
source .venv/bin/activate  # Activate (Linux/Mac)
uv pip install flask       # Install (10-100x faster than pip)
uv pip compile requirements.in -o requirements.txt  # Lock dependencies

poetry init                # Create pyproject.toml
poetry add flask           # Add dependency (auto-resolves versions)
poetry lock                # Lock exact versions
poetry install             # Install from lock file

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
pip freeze > requirements.txt  # Pin current versions

# This:
for item in [1, 2, 3]:
    print(item)

# Is equivalent to:
it = iter([1, 2, 3])   # Calls list.__iter__(), returns list_iterator
while True:
    try:
        item = next(it)  # Calls iterator.__next__()
        print(item)
    except StopIteration:
        break

class CountDown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self       # Iterator returns itself

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1

nums = [1, 2, 3]         # Iterable -- can iterate multiple times
it = iter(nums)           # Iterator -- single pass
list(it)                  # [1, 2, 3]
list(it)                  # [] -- exhausted!

# I/O-bound: Scraping 100 URLs
# Sequential: ~100 seconds (1s per URL)
# Threading (10 threads): ~10 seconds
# asyncio (100 concurrent): ~1-2 seconds

# CPU-bound: Processing 1M images
# Sequential: ~1000 seconds
# Threading: ~1000 seconds (GIL prevents parallelism)
# Multiprocessing (8 cores): ~125 seconds

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

# Switch between threading and multiprocessing by changing one word
with ThreadPoolExecutor(max_workers=10) as executor:
    results = list(executor.map(fetch_url, urls))

with ProcessPoolExecutor(max_workers=8) as executor:
    results = list(executor.map(process_image, images))