Python Engineer Interview Preparation 2026: Concepts & Design Questions

{`# List - mutable
fruits = ["apple", "banana"]
fruits.append("orange")  # Works

# Tuple - immutable
coords = (10, 20)
coords[0] = 15  # TypeError!`}

{`import functools
import time

def timer(func):
    @functools.wraps(func)  # Preserves function metadata
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "done"

# Equivalent to: slow_function = timer(slow_function)`}

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

a == b  # True (same values)
a is b  # False (different objects)
a is c  # True (same object)

# Gotcha: Python interns small integers
x = 256
y = 256
x is y  # True (interned)

x = 257
y = 257
x is y  # False (not interned)`}

{`# Regular function: creates entire list in memory
def get_squares_list(n):
    return [x**2 for x in range(n)]  # Uses O(n) memory

# Generator: produces values on demand
def get_squares_gen(n):
    for x in range(n):
        yield x**2  # Uses O(1) memory

# Generator expression (like list comprehension but lazy)
squares = (x**2 for x in range(1000000))

# Memory comparison for n=1,000,000:
# List: ~8MB | Generator: ~100 bytes`}

{`class A:
    def method(self):
        print("A")

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

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

class D(B, C):
    pass

D().method()  # Prints "B"
print(D.__mro__)
# (, , , , )`}

{`# Using a context manager
with open("file.txt") as f:
    data = f.read()
# File is automatically closed, even if exception occurs

# Creating a context manager (class-based)
class DatabaseConnection:
    def __enter__(self):
        self.conn = connect_to_db()
        return self.conn

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.conn.close()
        return False  # Don't suppress exceptions

# Creating a context manager (decorator-based)
from contextlib import contextmanager

@contextmanager
def timer():
    start = time.time()
    yield  # Code in 'with' block runs here
    print(f"Elapsed: {time.time() - start}s")`}

{`import asyncio
import aiohttp

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = ["http://example.com"] * 100
    async with aiohttp.ClientSession() as session:
        # Run 100 requests concurrently
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
    return results

# Synchronous: 100 requests × 0.1s = 10 seconds
# Async: All concurrent ≈ 0.1 seconds`}

{`# FastAPI example (modern, async, auto-docs)
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

app = FastAPI()

class User(BaseModel):
    name: str
    email: str
    age: Optional[int] = None

users_db = {}

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    if user_id not in users_db:
        raise HTTPException(status_code=404, detail="User not found")
    return users_db[user_id]

@app.post("/users", status_code=201)
async def create_user(user: User):
    user_id = len(users_db) + 1
    users_db[user_id] = user.dict()
    return {"id": user_id, **user.dict()}

# Features: Type validation, auto OpenAPI docs, async support`}

{`from typing import List, Dict, Optional, Union, Callable

def process_users(
    users: List[Dict[str, str]],
    transform: Callable[[str], str],
    limit: Optional[int] = None
) -> List[str]:
    """Process user names with optional limit."""
    names = [transform(u["name"]) for u in users]
    return names[:limit] if limit else names

# Python 3.10+ simplified syntax
def process(items: list[dict[str, str]]) -> list[str]:
    ...`}

{`import pytest
from unittest.mock import Mock, patch

# Basic test
def test_addition():
    assert 1 + 1 == 2

# Fixtures for setup/teardown
@pytest.fixture
def database():
    db = create_test_db()
    yield db
    db.cleanup()

def test_user_creation(database):
    user = database.create_user("test@example.com")
    assert user.email == "test@example.com"

# Parametrized tests
@pytest.mark.parametrize("input,expected", [
    ("hello", "HELLO"),
    ("World", "WORLD"),
    ("", ""),
])
def test_uppercase(input, expected):
    assert input.upper() == expected

# Mocking external services
@patch("myapp.services.send_email")
def test_registration(mock_send):
    mock_send.return_value = True
    result = register_user("test@example.com")
    mock_send.assert_called_once()`}

{`import redis
import time
from functools import wraps

class RateLimiter:
    def __init__(self, redis_client, limit=100, window=60):
        self.redis = redis_client
        self.limit = limit
        self.window = window

    def is_allowed(self, key: str) -> tuple[bool, int]:
        """Sliding window rate limiter."""
        now = time.time()
        window_start = now - self.window

        pipe = self.redis.pipeline()
        pipe.zremrangebyscore(key, 0, window_start)
        pipe.zadd(key, {str(now): now})
        pipe.zcard(key)
        pipe.expire(key, self.window)
        _, _, count, _ = pipe.execute()

        return count <= self.limit, self.limit - count

def rate_limit(limiter: RateLimiter, key_func):
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            key = f"ratelimit:{key_func(*args, **kwargs)}"
            allowed, remaining = limiter.is_allowed(key)
            if not allowed:
                raise RateLimitExceeded(remaining)
            return await func(*args, **kwargs)
        return wrapper
    return decorator`}

{`# cProfile for CPU profiling
python -m cProfile -s cumtime myapp.py

# line_profiler for line-by-line
@profile
def slow_function():
    ...

# memory_profiler for memory
@profile
def memory_heavy():
    ...`}