Core Code
Core Code Modern Dev Handbook
PYTHON Contents
Python Fundamentals
Python Installation and venv Running Python Scripts (CLI, Modules, -m) Variables and Naming Conventions Strings and f-strings (Real-World Formatting) Numbers, Decimals, and Precision Lists vs Tuples vs Sets (When to Use Which) Dictionaries (Patterns and Gotchas) Conditionals and Truthiness Loops and Iteration Basics Functions Basics (Parameters, Defaults, Return) Modules Basics (Imports, Packages) Scope and Import Mechanics
Data Handling Basics
Paths and Files (pathlib, OS-safe) Reading and Writing Text Safely (Encoding) JSON Basics (Parse, Dump, Validation Mindset) CSV Basics (Reader/Writer, Dialects) datetime Basics (Timezones, Pitfalls) collections Module (deque, Counter, defaultdict) Iterators and Generators Intro Context Managers Intro (with-statement)
OOP Basics
Classes and Objects (Mental Model) __init__ and Instance State Class vs Instance (Attributes, Lookup) Inheritance Basics (Use Carefully) Composition Basics (Prefer Over Inheritance) Properties (@property) and Encapsulation Staticmethod vs Classmethod Special Methods (Dunder) Intro Dataclasses Intro (Less Boilerplate) Enums Intro (Safety and Readability)
Data Model & Advanced Patterns
Dunder Methods Deep Dive __eq__, __hash__, and Immutability Ordering and functools.total_ordering Descriptors Basics (How @property Works) Iterators and Generators (Advanced Patterns) Decorators Basics (Function Wrapping) Decorators Advanced (Args, Classes, Metadata) contextlib (contextmanager, ExitStack) __slots__ and Memory Footprint copy vs deepcopy (Safe Copies)
Typing & Code Quality
Type Hints Overview Typing Generics (TypeVar, Generic) Protocols and Structural Typing Literal, Union, Optional (Designing APIs) Typing with Dataclasses mypy Basics (Practical Workflow) Linting with Ruff (Fast and Modern) Formatting with Black (Consistency) Docstrings and Documentation Style Project Structure Conventions (src/, tests/)
Async & Concurrency
The GIL Explained (What It Means in Practice) Threading Basics (IO Concurrency) Multiprocessing Basics (CPU Parallelism) concurrent.futures (ThreadPool/ProcessPool) asyncio Intro (When to Use It) Event Loop and Tasks (Core Concepts) async/await Patterns (Fan-out, Gather, Limits) Cancellation and Timeouts (Correct Cleanup) asyncio Queues (Worker Pools) IO-bound vs CPU-bound (Choosing the Right Tool)
Reliability & Error Handling
Exceptions Best Practices (No Silent Failures) Custom Exceptions (Domain Errors) Error Boundaries and Containment Patterns Retries and Backoff (When Retries Are Harmful) Timeouts and Deadlines (Prevent Hanging) Idempotency Patterns (Safe Retries) Validation Patterns (What to Validate Where) Structured Logging (Fields, Correlation IDs)
Testing
pytest Intro (Assertions, Discovery) pytest Fixtures (Setup Without Pain) pytest Parametrize (Coverage with Less Code) Mocking Basics (unittest.mock) Mocking HTTP and Time (Deterministic Tests) Testing Async Code (pytest-asyncio) Coverage and Quality Gates (CI Mindset) Contract Tests Basics (Stable Interfaces)
Packaging & Delivery
Using venv in Production (Layouts and Pitfalls) Dependency Management with Poetry Build and Wheels (sdist, wheel) Versioning and SemVer (Release Discipline) Building a CLI with argparse Config Management (Env, Files, Defaults) Secrets Management Basics (No Secrets in Git)
Observability & Performance
Metrics Basics (What to Measure) Tracing Basics (Request Flow) Health Checks (Readiness/Liveness Basics) Profiling with cProfile (Find Hotspots) Performance Hotspots (I/O, Parsing, Loops) Memory Leaks Detection (tracemalloc, objgraph) Python Production Checklist

pytest Intro (Assertions, Discovery)

Start with pytest to write fast, readable tests that catch regressions early and support confident refactoring.
On this page

Why pytest

pytest keeps tests concise and readable. In production teams, readable tests reduce review time and improve confidence during refactors.

Minimal Test

def add(a: int, b: int) -> int:
    return a + b

def test_add():
    assert add(2, 3) == 5

Run Tests

pytest -q

Operational Checklist

  • Tests are deterministic (no time, network, randomness without control).
  • Failures produce actionable messages (assertions are specific).
  • Critical logic has unit tests; boundaries have integration tests.

Failure Modes

  • Flaky tests: failures come and go, teams stop trusting CI.
  • Over-mocking: tests validate mocks, not real behavior.
pytest Fixtures (Setup Without Pain) →