Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Python · Question Set
System Design & Best Practices interview questions for placements and exams.
Questions
14
Included in this set
Subject
Python
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Python.
Env vars let you change configuration per environment without code edits. They are easy to inject in containers and CI/CD. Read them once at startup and validate. Do not hard-code secrets or hostnames in code.
import os
DB_URL = os.environ['DATABASE_URL']
DEBUG = os.getenv('DEBUG','0')=='1'For complete preparation, combine this set with full subject-wise practice for Python. You can also explore other subjects and sets from the links below.
A virtual environment gives your project its own interpreter and site-packages. This avoids version conflicts with global packages and keeps builds reproducible. It also makes deployments predictable: you freeze exact versions and recreate the same environment everywhere.
python -m venv .venv source .venv/bin/activate # Windows: .venv\Scripts\activate pip install -r requirements.txt
Absolute imports are explicit and unambiguous. They make refactors safer and work cleanly with tools and type checkers. Use relative imports for private, intra-package internals when you want to signal non-public APIs.
from myapp.core.service import run # Prefer absolute over: from .core import service
pyproject.toml centralizes project metadata, dependencies, and the build backend. It is the standard way to define how a package is built and installed. requirements.txt still helps pin runtime deps for apps, but pyproject describes the package itself.
[project] name = 'myapp' version = '0.1.0' [build-system] requires = ['setuptools','wheel'] build-backend = 'setuptools.build_meta'
201 indicates a new resource was created. Include a Location header pointing to the new resource. Use 200 for a successful read or update where nothing new was created.
# pseudo FastAPI
return JSONResponse(obj, status_code=201, headers={'Location': url})PUT replaces the resource state, so repeating the same PUT has the same final effect. POST is not idempotent because each call may create or change additional state. PATCH is partial update and may or may not be idempotent based on semantics.
# Request
PUT /users/42 {"name":"A"}
# Repeat same request → same final stateUnit tests should be fast and deterministic. Replace outbound calls with fakes or fixtures so tests do not depend on the network. Keep a separate suite for integration tests against real services.
def test_client(monkeypatch):
monkeypatch.setattr('client.http_get', lambda url: {'ok':True})
assert my_call()==TrueUse a src layout with a top-level package for code, and tests as a sibling. Group code by feature or layer: api, core, adapters, and shared utils. Keep entry points thin and route all logic through the core domain layer. This layout isolates concerns, avoids import path hacks, and lets you publish the package if needed. It also makes testing easy because each module has a clear dependency direction toward the core.
project/
pyproject.toml
src/myapp/{api,core,adapters,utils}
tests/{unit,integration}Define custom exception types for domain errors and translate them at the API edge to proper HTTP codes. Log once with enough context but without secrets. Avoid logging the same error repeatedly in lower layers. At the service layer, raise precise exceptions and keep stack traces. At the data layer, wrap low-level errors with cause to preserve context. This gives clean responses to clients and debuggable traces for engineers.
class NotFoundError(Exception): ...
# API edge
try:
svc.get_user(id)
except NotFoundError:
return 404, {'error':'not found'}Pass interfaces or callables into constructors or function parameters. Build the object graph at startup in a small composition root. Use factories for resources like clients or repositories. This keeps modules decoupled and testable. In tests, swap real dependencies for fakes by passing different constructors or using monkeypatch.
class Service:
def __init__(self, repo): self.repo=repo
def build():
repo = SqlRepo(url)
return Service(repo)Never commit secrets to source control. Load them from environment variables, secret managers, or an encrypted vault. Limit scope using least privilege and rotate keys regularly. In code, read once at startup, validate presence, and avoid printing values. In logs and errors, mask tokens to prevent leaks.
import os API_KEY = os.environ['PAYMENT_KEY'] # pulled from a secret store in production
Choose asyncio for high-concurrency I O: many sockets, HTTP calls, or database drivers with async support. It scales with a single event loop and has low context-switch overhead. Do not call blocking code inside async paths; offload it to a worker pool. Always await tasks or gather them; leaked tasks hide errors. For CPU-bound work, use processes or native extensions instead of the event loop.
import asyncio
async def main():
await asyncio.gather(fetch(a), fetch(b))
asyncio.run(main())Hints help editors, linters, and CI catch mismatches before runtime. They also act as living documentation that improves readability. Use a checker like mypy or pyright. Hints do not enforce types at runtime unless you add validators.
from typing import List
def total(xs: List[int]) -> int:
return sum(xs)Use level to control noise. DEBUG for detailed diagnostics, INFO for state changes, WARNING for odd states, ERROR for failures, CRITICAL for system-wide outages. Pick one logger per module and avoid print in production so messages can be routed to files or systems.
import logging
logging.basicConfig(level=logging.INFO)
log = logging.getLogger(__name__)
log.info('service started')