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

Project Structure Conventions (src/, tests/)

Use a predictable project layout to make imports reliable, tests discoverable, and production packaging straightforward.
On this page

Why Structure Matters

A consistent layout reduces import issues, improves test discovery, and makes packaging/deployment more predictable.

Common Layout

repo/
  src/
    myapp/
      __init__.py
      service.py
  tests/
    test_service.py
  pyproject.toml
  README.md

Operational Checklist

  • Keep app code under src/ to avoid accidental imports from the repo root.
  • Keep tests in a dedicated tests/ directory with clear naming.
  • Separate "app" modules from "infra" modules (I/O, clients, adapters).

Failure Modes

  • Import confusion: code works locally but fails in CI/prod due to path differences.
  • Test invisibility: inconsistent naming breaks discovery and coverage metrics.