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

Python Installation and venv

Install Python cleanly, create an isolated venv per repo, and keep dependencies reproducible across machines and CI.
On this page

Goal

Make every project reproducible: isolated interpreter, pinned dependencies, and predictable runtime behavior in local dev and CI.

Minimal Setup

# Create venv
python -m venv .venv

# Activate (Windows PowerShell)
.venv\Scripts\Activate.ps1

# Activate (macOS/Linux)
source .venv/bin/activate

# Verify interpreter
python -c "import sys; print(sys.executable)"

Dependency Baseline

# Upgrade packaging tools
python -m pip install --upgrade pip setuptools wheel

# Install pinned deps
python -m pip install requests==2.32.3

# Freeze for reproducibility
python -m pip freeze > requirements.txt

Operational Checklist

  • Use one venv per repo and keep .venv/ in .gitignore.
  • Pin dependencies (or lock) so behavior is consistent in CI and prod.
  • Document the required Python version (README or tooling config).

Failure Modes

  • Global installs: packages end up in system Python and leak between projects.
  • Mixed interpreters: venv created with one Python but executed with another.
  • Unpinned deps: same code behaves differently across machines.
Running Python Scripts (CLI, Modules, -m) →