Python 2026 Foundation Course

A modern, production-focused Python learning path designed to take you from zero to building real-world applications.

🎯 Course Philosophy

This course teaches Python the way professional developers use it:

• Terminal-first: No Jupyter notebooks — learn command-line development from day one
• Type-safe: Type hints throughout, validated with mypy
• Production-ready: Modern tools (uv, ruff, FastAPI, Docker, SQLAlchemy 2.0)
• Progressive: Each layer builds naturally on the previous
• Practical: Every concept leads to real applications

---

📚 Three-Layer Learning Path

Layer 1: Foundation 🧱

Master core Python and advanced language features

a_core/ — The essential building blocks

• Variables, types, and type hints
• Data structures (lists, dicts, sets, tuples)
• Control flow (if/for/while, match statements)
• Functions and parameters
• Classes and OOP fundamentals

b_advanced/ — Modern Python features

• List/dict/set comprehensions
• Decorators and wrappers
• Generics and advanced typing (TypeVar, Protocol)
• Enums and pattern matching

📖 Time: ~12-15 hours 📍 Start here: 0_origins/README.md → 1_foundation/a_core/

---

Layer 2: Building Programs 🔨

Bridge the gap from syntax to software

• 01_file_io — pathlib, reading/writing, context managers
• 03_testing_basics — pytest, fixtures, parametrize
• 04_code_quality — ruff linting, mypy type-checking, git workflows
• 05_cli_tools — argparse/typer, script organization
• 06_mini_project — Integrated project with tests and quality checks
• 07_pydantic_models — Data validation and configuration (Pydantic v2)

📖 Time: ~12-16 hours 🎯 Goal: Write clean, tested, maintainable Python programs

---

Layer 3: Architectures 🏗️

Build production-grade systems

a_automations/ — Practical automation patterns

• 01_file_management — Scouting, sorting, and cleaning the filesystem
• 02_data_processing — Validated ETL pipelines (CSV, JSON, Pydantic)
• 03_system_tasks — Professional logging, scheduling, and health checks
• 04_capstone — Integrated, modular automation service

b_file_tools/ — Production file management utilities

• File Organizer — Automatically organize files by type with duplicate detection
• File Cleaner — Advanced file cleanup with workflow automation
• Ready-to-use tools for daily file management

b_production_api/ — Full-stack web development

• 01_setup_docker — Docker basics, docker-compose, environments
• 02_fastapi_core — Routers, dependencies, Pydantic validation
• 03_database — SQLAlchemy 2.0 async, sessions, Alembic migrations
• 04_advanced_patterns — Middleware, auth, dependency injection
• 05_testing_deployment — API tests, GitHub Actions CI/CD
• 06_background_jobs — Celery workers, Redis broker, scheduled tasks
• capstone_api/ — Complete production API with all patterns

📖 Time: ~20-25 hours 🎯 Goal: Deploy production-ready Python applications

---

🚀 Getting Started

Prerequisites

• Python 3.12+ installed
• Basic terminal/command-line familiarity
• A code editor (VS Code, PyCharm, or similar)

Setup

# 1. Clone/navigate to repository
cd python-zero-to-hero

# 2. Install uv (modern package manager)
# macOS/Linux:
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows (PowerShell):
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

# 3. Install dependencies
uv sync

# 4. Verify setup
uv run python --version  # Should show Python 3.12+
uv run ruff --version
uv run mypy --version
uv run pytest --version

Start Learning

# Read the setup guide first
cat main/0_origins/README.md

# Then start with Foundation Core
cd main/1_foundation/a_core
cat README.md

# Run your first module
python 01_variables_types.py

---

📖 How to Use This Course

1. Read the Code

Every .py file is heavily commented with explanations, examples, and best practices.

2. Run Examples

Execute files directly:

python 01_variables_types.py

Or experiment in the REPL:

python  # Start interactive shell
>>> # Try examples from the file
>>> # Modify and experiment!

3. Complete Exercises

Each module has "Try it yourself" exercises. Solutions require thinking, not copying!

4. Test Your Code

Starting in Building Programs, you'll write tests:

pytest tests/

5. Validate Quality

Use the tools taught in the course:

ruff check .        # Linting
mypy .              # Type checking

---

🗺️ Learning Path Flowchart

START
  ↓
┌─────────────────────────────────────┐
│  0_origins/                         │
│  • Terminal & REPL guide            │
│  • Environment setup                │
└─────────────────────────────────────┘
  ↓
┌─────────────────────────────────────┐
│  LAYER 1: FOUNDATION                │
├─────────────────────────────────────┤
│  a_core/                            │
│  • Variables → Types → Structures   │
│  • Control Flow → Functions         │
│  • Classes & OOP                    │
│                                     │
│  b_advanced/                        │
│  • Comprehensions → Decorators      │
│  • Generics → Enums                │
└─────────────────────────────────────┘
  ↓
┌─────────────────────────────────────┐
│  LAYER 2: BUILDING PROGRAMS         │
├─────────────────────────────────────┤
│  01_file_io → 03_testing            │
│  04_quality → 05_cli_tools          │
│  06_mini_project → 07_pydantic      │
│                                     │
│  🎯 You can now write professional  │
│     Python programs!                │
└─────────────────────────────────────┘

  ↓
┌─────────────────────────────────────┐
│  LAYER 3: ARCHITECTURES             │
├─────────────────────────────────────┤
│  a_automations/                     │
│  • File mgmt → Data ETL             │
│  • System tasks → Scheduling        │
│                                     │
│  b_file_tools/                      │
│  • File organizer & cleaner          │
│  • Production utilities             │
│                                     │
│  b_production_api/                  │
│  • Docker → FastAPI → Database      │
│  • Auth → CI/CD → Celery            │
│  • Capstone Project                 │
│                                     │
│  🎯 You can build production apps!  │
└─────────────────────────────────────┘
  ↓
🎓 PYTHON MASTERY ACHIEVED!

---

🎯 What You'll Build

Building Programs Layer

• Mini Project: Task manager CLI with file persistence and error handling

Architectures - Automations

• File Organizer: Automatically sort downloads by type
• Data Validator: ETL pipeline for CSV processing
• System Monitor: Log analyzer with scheduling

Architectures - Production API

• Capstone Project: Complete REST API with:
  • FastAPI backend with async endpoints
  • PostgreSQL database with SQLAlchemy 2.0
  • Celery background tasks for email/reports
  • Docker containerization
  • GitHub Actions CI/CD pipeline
  • Full test coverage
  • Authentication and authorization

---

🛠️ Tech Stack

Category	Tools
Language	Python 3.12+
Package Manager	uv
Code Quality	ruff (linting), mypy (type checking)
Testing	pytest
Web Framework	FastAPI
Database	PostgreSQL, SQLAlchemy 2.0 (async)
Data Validation	Pydantic v2
Containerization	Docker, docker-compose
Task Queue	Celery + Redis
CI/CD	GitHub Actions
Other	httpx, rich, Alembic (migrations)

---

📊 Time Estimates

Section	Duration	Cumulative
Setup	0.5 hour	0.5 hours
Foundation Core	6-8 hours	7-8.5 hours
Foundation Advanced	6-7 hours	13-15.5 hours
Building Programs	10-12 hours	23-27.5 hours
Automations	8-10 hours	31-37.5 hours
Production API	12-15 hours	43-52.5 hours
Total Course	~45-55 hours

Self-paced: Complete at your own speed. Times assume practice and experimentation.

---

🎓 Learning Outcomes

By the end of this course, you will:

✅ Master Python fundamentals — Variables through advanced OOP ✅ Write production-quality code — Type hints, testing, linting ✅ Build CLI applications — argparse, file I/O, error handling ✅ Create automation scripts — File management, ETL, scheduling ✅ Develop REST APIs — FastAPI with async patterns ✅ Work with databases — SQLAlchemy 2.0, migrations, relationships ✅ Use containerization — Docker for development and deployment ✅ Implement CI/CD — GitHub Actions for automated testing ✅ Handle background jobs — Celery and Redis for async tasks ✅ Apply SOLID principles — Write maintainable, scalable code

---

🤝 Best Practices Taught

Code Quality

• Type hints for all functions and variables
• Comprehensive docstrings
• Linting with ruff (no violations)
• Static type checking with mypy --strict
• 80-90%+ test coverage

Architecture

• Dependency injection patterns
• Clean separation of concerns
• Repository pattern for data access
• Service layer for business logic
• Middleware for cross-cutting concerns

DevOps

• Git with trunk-based development
• Conventional commits
• Automated testing on PRs
• Docker multi-stage builds
• Environment-based configuration

---

📂 Repository Structure

python-zero-to-hero/
├── main/
│   ├── 0_origins/                  # ← Start here
│   ├── 1_foundation/
│   │   ├── a_core/                 # Variables → Classes
│   │   └── b_advanced/             # Comprehensions → Enums
│   ├── 2_building_programs/
│   │   ├── 01_file_io/
│   │   ├── 03_testing_basics/
│   │   ├── 04_code_quality/
│   │   ├── 05_cli_tools/
│   │   ├── 06_mini_project/
│   │   └── 07_pydantic_models/
│   └── 3_architectures/
│       ├── a_automations/
│       │   ├── 01_file_management/
│       │   ├── 02_data_processing/
│       │   ├── 03_system_tasks/
│       │   └── 04_capstone/

│       ├── b_file_tools/               # Production file management tools
│       └── b_production_api/
│           ├── 01_setup_docker/
│           ├── 02_fastapi_core/
│           ├── 03_database/
│           ├── 04_advanced_patterns/
│           ├── 05_testing_deployment/
│           ├── 06_background_jobs/
│           └── capstone_api/
├── misc/                           # Reference materials (preserved)
├── openspec/                       # Project specifications
├── pyproject.toml                  # Dependencies
└── README.md                       # Top-level guide

---

❓ FAQ

Do I need prior programming experience?

No! The course starts from absolute basics. If you know another language, you can skip Foundation Core.

Why no Jupyter notebooks?

Professional Python development happens in .py files and terminals. Learning this way prepares you for real jobs.

Can I skip sections?

Yes, but follow the progression. Each layer builds on the previous. Don't jump to Architectures without Foundation.

What if I get stuck?

1. Read error messages carefully
2. Use the REPL to debug step-by-step
3. Review previous modules
4. Search documentation
5. Ask for help with specific error messages

Why Python 3.12+?

We teach modern Python with the latest features. If you're on an earlier version, update for full compatibility.

Where are the solutions?

This course teaches problem-solving. Files have hints and comprehensive comments, but you must implement solutions yourself.

---

🔗 Additional Resources

• Python Docs: https://docs.python.org/3/
• uv Documentation: https://docs.astral.sh/uv/
• FastAPI Docs: https://fastapi.tiangolo.com/
• SQLAlchemy Docs: https://docs.sqlalchemy.org/
• Pydantic Docs: https://docs.pydantic.dev/
• pytest Docs: https://docs.pytest.org/

---

📝 Course Conventions

File Naming

• Modules: 01_topic_name.py (numbered for sequence)
• Tests: test_topic_name.py
• Config: config.py, settings.py

Code Style

• Type hints: Always. No exceptions.
• Naming: snake_case for functions/variables, PascalCase for classes
• Line length: 88 characters (ruff default)
• Docstrings: Triple quotes, describe purpose and parameters
• Imports: Grouped (stdlib, third-party, local) with blank lines

---

🎉 Ready to Start?

# 1. Read the setup guide
cat main/0_origins/README.md

# 2. Understand the REPL
python main/0_origins/02_interpreter.py

# 3. Begin Foundation Core
cd main/1_foundation/a_core
cat README.md
python 01_variables_types.py

Welcome to professional Python development! 🐍

---

Course Version: 2026.1 Updated: 2026-01 (Structure Updates)