React
React Native
Node.js
Python
Rust
PostgreSQL
Solana
Claude
AI Agents
Go
Containers

Python SME Cookbook

Sections

Core Python Language

The Python Execution Model Python Basics Variables, Types & Dynamic Typing Numbers, Booleans & Arithmetic Strings & f-strings Control Flow Comprehensions & Generator Expressions Functions, Args & Scope Modules, Imports & Packages Files & I/O Virtual Environments Quickstart Python Fundamentals Best Practices

The Container Model Behind Python's Data Structures Data Structures Basics Lists & Tuples Dictionaries Sets & Frozensets collections Module heapq & Priority Queues arrays, bytes & memoryview Choosing the Right Data Structure Immutability & Hashability Collections Best Practices

The Python Object Model OOP Basics Dunder / Magic Methods dataclasses Properties & Descriptors Inheritance & MRO Abstract Base Classes Protocols & Structural Typing Class vs Instance vs Static Methods Enums Metaclasses & `__init_subclass__`Object-Oriented Python Best Practices

Closures, Protocols & Lazy Evaluation Iterators & the Iterator Protocol Generators & yield yield from & Sub-generators itertools functools Closures & Scope Capture Writing Decorators Class & Method Decorators Context Managers Iterators & Decorators Best Practices

The Type Checking Mental Model Type Hints Basics Built-in & Collection Generics Optional, Union & the `|` Operator Generics & TypeVar Protocols & Structural Typing TypedDict & NamedTuple Literal, Final & Annotated Overloads & Callable Types mypy & pyright Setup Gradual Typing Strategy Type Hints Best Practices

Duck Typing and the Data Model Pythonic Patterns Basics EAFP vs LBYL Context Managers as a Pattern The Strategy & Dispatch Patterns Factory & Builder Patterns Observer & Pub/Sub Dependency Injection in Python Null Object & Sentinels Common Anti-Patterns Pythonic Patterns Best Practices

Errors vs Logging: The Two-Channel Mental Model Exceptions Basics Raising & Chaining Custom Exception Hierarchies Exception Groups & except*Retries & Backoff The logging Module Structured & Contextual Logging Warnings & Deprecations Errors & Logging Best Practices

Shared State and Isolation Boundaries Concurrency Basics The GIL & Free-Threaded Python threading multiprocessing concurrent.futures Queues & Producer/Consumer Subinterpreters Choosing a Concurrency Model Concurrency Best Practices

The Event Loop Mental Model Asyncio Basics Tasks & Gather Structured Concurrency Async HTTP with httpx/aiohttp Async Context Managers & Iterators Sync/Async Bridging Async Databases Debugging Async Code Async Best Practices

The Standard Library Mental Model Standard Library Overview pathlib & os datetime, zoneinfo & time json & Serialization re - Regular Expressions subprocess collections, itertools & functools Recap dataclasses, enum & contextlib argparse & configparser hashlib, secrets & uuid Standard Library Best Practices

Tooling, Environments & Quality

The Python Environment & Resolution Model Environments & Packaging Basics uv - The Fast Toolchain Poetry & PDM pyproject.toml Explained Dependency Resolution & Lockfiles Managing Python Versions Editable Installs & Local Packages Private Indexes & Mirrors Environments Best Practices

The Static Analysis Pipeline Model Ruff Setup Black / Ruff Format Essential Lint Rules isort & Import Organization mypy & pyright in CI pre-commit Hooks Editor Integration Linting in CI/CD Linting & Formatting Best Practices

The Anatomy of a pytest Suite pytest Setup Assertions & Test Structure Fixtures Parametrization Mocking & Patching Testing Async Code Coverage & Reporting Property-Based Testing Testing Web APIs tox / nox Testing Best Practices

The BDD Living Documentation Model BDD Decision Checklist Gherkin Syntax behave / pytest-bdd Setup Step Definitions Gherkin to Code Gherkin to CI Pipeline BDD Best Practices

How Python Spends Time and Memory Performance Basics timeit & Microbenchmarks cProfile & Profilers Memory Profiling Vectorization with NumPy Cython & mypyc PyPy & Alternative Runtimes Caching & Memoization Async & Concurrency for Throughput Performance Audit Checklist Performance Best Practices

The Python Packaging Model: From Source Tree to Installed Package Packaging Basics Build Backends Versioning & Changelogs Publishing to PyPI Entry Points & Console Scripts Native Extensions & Wheels Distributing Applications Packaging Best Practices

The CLI Contract: What Makes a Command-Line Tool a Good Citizen CLI Basics argparse Click Typer Rich Output Config & Environment Interactive Prompts Packaging & Distributing CLIs CLI Best Practices

How to Use a Python Rules List 50 Python Rules Every Specialist Should Follow 40 API Design Rules (FastAPI/Django/Flask)30 Async Rules 30 Data/ML Code Rules 30 Security Rules for Python PEP 8 & Style Reference Problem / Solution Reference Python Architecture Decisions

Architecture & Debugging

The Architecture Mental Model for Python Services Project Architecture Decision Checklist src Layout & Package Structure Clean / Hexagonal Architecture Domain Modeling Dependency Injection & Wiring Configuration & Settings Refactoring Decisions Codebase Audit Checklist Migrating a Legacy Python 2/Django/Flask App Architecture Best Practices

The Debugging Mental Model for Python Services Mutable Default Argument Bugs Circular Import Scenarios asyncio Deadlocks & Blocking-the-Loop Memory Leak Scenarios Encoding & Unicode Bugs Floating-Point & Numeric Bugs Dependency & Environment Conflicts Data Pipeline Defects Debugging Tools Debugging Refactor Snippets

Web, APIs & Data Layer

The FastAPI Request Lifecycle Model FastAPI Basics Request & Response Models Dependency Injection Async Routes & Databases Authentication & Authorization Background Tasks & Workers WebSockets & Streaming Middleware & Error Handling Testing FastAPI Deploying FastAPI FastAPI Best Practices

The Django MTV Request Cycle & ORM Laziness Django Basics Models & the ORM Migrations Django REST Framework Templates & Forms Authentication & Permissions Async Views & Channels The Admin Caching & Performance Scaling & Deployment Django Best Practices

The Flask WSGI & Context Model Flask Basics Application Factories & Blueprints Extensions Request Lifecycle & Context Templating with Jinja2 Building REST APIs Testing Flask Deploying Flask Flask vs FastAPI vs Django Flask Best Practices

The Pydantic Boundary Model Pydantic Basics Field Types & Constraints Validators Serialization Settings Management Nested & Recursive Models Performance & pydantic-core Dataclasses vs Pydantic vs attrs Validation Best Practices

The Python Database Layering Model Databases Basics SQLAlchemy Core SQLAlchemy ORM 2.0 SQLModel Migrations with Alembic Async Database Access Query Patterns & N+1 NoSQL & Caching Connection Management Databases Best Practices

The Python API Trust Boundary API Design Basics GraphQL in Python OAuth2 & JWT Password & Credential Handling Secrets Management Input Validation & Injection cryptography Essentials Rate Limiting & Abuse Prevention Dependency & Supply-Chain Security API & Security Best Practices

Data & Scientific Computing

The NumPy and pandas Mental Model Data Analysis Basics NumPy Arrays NumPy Indexing & Reshaping pandas Series & DataFrames Cleaning & Transforming Data GroupBy & Aggregation Joins & Merges Time Series Polars Performance & Memory Data Analysis Best Practices

Grammar of Graphics vs. Imperative Plotting Visualization Basics matplotlib seaborn Plotly Altair Dashboards (Streamlit / Dash / Gradio)Plotting Large Data Visualization Best Practices

The Batch, Streaming, and Orchestration Mental Model Data Engineering Basics Airflow Prefect & Dagster dbt with Python PySpark Streaming (Kafka / Faust)Data Validation & Quality File Formats Workflow Reliability Data Engineering Best Practices

AI & Machine Learning

The Classical ML Mental Model Machine Learning Basics Datasets & Splits Feature Engineering Pipelines Supervised Learning Model Evaluation Hyperparameter Tuning Unsupervised Learning Imbalanced Data Gradient Boosting Machine Learning Best Practices

The Deep Learning Mental Model PyTorch Basics Autograd Building Models with nn.Module Datasets & DataLoaders Training Loops GPUs & Mixed Precision Transfer Learning & Fine-Tuning PyTorch Lightning Saving, Loading & Export Distributed Training Deep Learning Best Practices

The LLM Interface Model LLMs Basics Anthropic Claude SDK OpenAI & Other SDKs Hugging Face transformers Prompt Engineering Structured Output Embeddings & Similarity Streaming & Async LLM Calls Tokens, Cost & Rate Limits Local & Open Models LLMs Best Practices

The RAG Pipeline and Agent Loop Mental Model RAG Basics Chunking & Ingestion Vector Databases Retrieval & Re-ranking LangChain LlamaIndex LangGraph & Agent Loops Tool Use & Function Calling Model Context Protocol (MCP)Evaluation & Guardrails AI Agents Best Practices

The Notebook-to-Production Lifecycle MLOps Basics Experiment Tracking Model Registries & Versioning Data & Model Versioning (DVC)Serving with FastAPI Dedicated Serving (BentoML / Triton / TorchServe)Batch & Streaming Inference Monitoring and Drift GPU Infrastructure & Cost MLOps Best Practices

Infrastructure & Ops

The Declarative Infrastructure Mental Model Infrastructure Automation Basics Ansible Pulumi (Python IaC)Terraform with Python Configuration Management Provisioning Cloud Resources Testing Infrastructure Code Infrastructure Automation Best Practices

The boto3 Architecture Mental Model boto3 Basics S3 Lambda DynamoDB SQS & SNS Secrets Manager & SSM google-cloud & azure-sdk Credential & Session Patterns Retry, Pagination & Throttling Cloud SDK Best Practices

The Process Contract: How Automation Scripts Talk to Their Environment Scripting Basics File & Directory Automation subprocess & Shell Interop Scheduling & Cron SSH & Remote Execution Working with APIs & Webhooks Parsing Logs & Text Robust Scripts System Scripting Best Practices

The Deployment Artifact Model: Build Once, Configure at Runtime Deployment Basics Dockerizing Python Gunicorn & Uvicorn AWS Lambda & Serverless Kubernetes for Python Apps CI/CD Pipelines Configuration & Secrets in Prod Zero-Downtime Deploys Deployment Best Practices

The Observability Correlation Model Observability Basics Structured Logging Metrics Distributed Tracing Error Tracking Health & Readiness Performance Monitoring (APM)Observability Best Practices

Ecosystem & Team

The Python Dependency Model httpx & requests Rich & Textual pydantic-settings tenacity pendulum / arrow Pillow openpyxl / python-docx / reportlab beautifulsoup4 & lxml celery SQLModel / SQLAlchemy Essential Libraries Best Practices

The Agent Skill Model for Python Teams FastAPI Expert Skill Data Pipeline Skill PyTorch / Deep Learning Skill LLM App / RAG Skill Packaging & Publishing Skill pytest / Testing Skill Type-Hinting Skill Infra Automation Skill Python Best-Practices Skill

The Git Object Model Essential Git Commands Branching & Merging Merge Conflict Resolution Checklist Git Worktrees GitHub CLI Git for Data/Notebooks Git Configuration Git Best Practices

Linux CLI Fluency for Python Engineers Sysadmin Essentials Search & Regex Python-in-the-Shell Pipes & Text Processing Process & Resource Management SSH & Remote Work Shell Productivity Linux CLI Best Practices

The Python Team Capability Model Onboarding Devs Checklist Environment Setup Checklist Codebase Orientation Conventions & Style Guide Code Review Guidelines Team Best Practices

Tech-Lead Craft

Production Incident Response as a Discipline Production Debugging Incident Response Playbooks Blameless Post-Mortems & RCA Common Production Failure Modes Rollback & Recovery Runbooks Turning Incidents into Guardrails On-Call Health

What Enterprise Delivery Actually Optimizes For Release Management Feature Flags & Progressive Delivery Rollback Strategies DORA Metrics A/B Testing & Experimentation Environments & Config Promotion Delivery Best Practices

The Tech Lead Mental Model Technical Decision-Making Architecture Decision Records (ADRs)Running Design Reviews Code Review Culture Mentoring & Leveling Delegation & Spreading Context Handling Technical Disagreements Leadership Best Practices

The Product-Engineering Partnership Requirements to Technical Specs Prioritizing Platform & Tech Debt Estimation & Risk Roadmap Contributions Stakeholder Communication Making the Process Work (Scrum/Kanban/SAFe)Product Collaboration Best Practices

How to Read a Case Study Reference: A FastAPI SaaS Backend Reference: A Production ML Pipeline Reference: A Data Platform / ETL System Before/After: Refactoring a Legacy Django Monolith Before/After: Sync to Async Migration Scalability Benchmarks Lessons-Learned Catalog

Engineering Governance at Scale Coding Standards & Style Guides Documentation Conventions Contribution Guidelines Dependency & Supply-Chain Governance Deprecation & Upgrade Policy Spikes, PoCs & Adopting New Tools Career Growth: Senior to Lead to Staff/Principal Governance Best Practices

/

/

© 2026 @csjcode|SystemsArchitect.io: Cloud Systems Tools|Terms

An independent, unofficial educational resource. Not affiliated with, endorsed, or sponsored by the brand/trademark maintainers/owners.

Search Documentation

Search across all documentation pages

Python SME/Concurrency

Concurrency

10 pages in this section.

1

Shared State and Isolation Boundaries

Why Python has so many concurrency tools instead of one - threads, processes, subinterpreters, and free-threaded builds are different points on a single spectrum of how much memory gets shared and what enforces safety over it - the mental model behind every other page in this section.

Explainer Python Concurrency Gil

2

Concurrency Basics

Concurrency vs. parallelism and picking the right tool.

Python Concurrency Basics Parallelism

3

The GIL & Free-Threaded Python

Python Concurrency Gil Free Threaded

4

Threads, locks, events, and thread-safety.

Python Concurrency Threading Locks

5

multiprocessing

Processes, shared memory, and CPU-bound work.

Python Concurrency Multiprocessing Processes

6

concurrent.futures

`ThreadPoolExecutor`/`ProcessPoolExecutor` and `map`/`submit`.

Python Concurrency Futures Executors

7

Queues & Producer/Consumer

`queue.Queue`, pipelines, and coordination.

Python Concurrency Queues Producer Consumer

8

Subinterpreters

Python Concurrency Subinterpreters Isolation

9

Choosing a Concurrency Model

A decision checklist: I/O-bound vs CPU-bound vs mixed.

Python Concurrency Decisions Checklist

10

Concurrency Best Practices

Avoiding races, deadlocks, and shared mutable state.

Python Concurrency Best Practices List