> ## Documentation Index
> Fetch the complete documentation index at: https://fastapi2day.codewithsiva.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Python for AI & FastAPI: Complete Course Route Map

> Navigate the complete Python for AI & FastAPI course syllabus — every module, topic, and sub-topic with direct links to all learning materials.

Welcome to the **Python for AI & FastAPI** course route map. Use this page as your interactive table of contents and navigation guide. Every module, topic, and sub-topic below links directly to its learning material. Whether you are following the course from start to finish or jumping to a specific concept, this is your starting point.

***

## Course structure overview

```mermaid theme={null}
graph TD
    A["1. Getting Started"] --> B["2. Python Basics"]
    B --> C["3. Advanced Python"]
    C --> D["4. Developing Projects"]
    C --> E["5. Data Analysis"]
    D --> F["6. FastAPI"]
    E --> F
```

***

## Module 1: Getting Started

Setting up your development environment, learning the editor, and understanding how Python projects are structured and managed.

### 1.1 Python Setup

* **[What is Python?](/getting-started/what-is-python)** — Dynamic typing, the interpreter, and why Python dominates AI
* **[Installing Python](/getting-started/installing-python)** — Overview with links to platform guides
* **[Windows Installation](/getting-started/installing-python-windows)** — Step-by-step guide for Windows
* **[macOS Installation](/getting-started/installing-python-macos)** — Step-by-step guide for macOS
* **[Linux Installation](/getting-started/installing-python-linux)** — Step-by-step guide for Linux (Ubuntu, Fedora, Arch)

### 1.2 VS Code and the Python Editor

* **[VS Code Introduction](/getting-started/vscode-introduction)** — Why VS Code is the standard IDE for Python and AI development
* **[VS Code Setup](/getting-started/vscode-setup)** — Installing VS Code, Python, Pylance, and Jupyter extensions
* **[VS Code Workspace](/getting-started/vscode-workspace)** — Creating project folders, workspaces, and understanding the interface
* **[First Python File](/getting-started/first-python-file)** — Writing and running your first `.py` script
* **[Jupyter Notebooks](/getting-started/ipynb-notebooks)** — Creating and running `.ipynb` files in VS Code and Colab
* **[Ruff Linter](/getting-started/ruff)** — Automatic code formatting and linting on save

### 1.3 Python Environments and Packages

* **[Virtual Environments](/getting-started/virtual-environments)** — Why isolation matters and how to create a `.venv` per project
* **[pip & Packages](/getting-started/packages-and-pip)** — Installing packages from PyPI, managing `requirements.txt`
* **[Interactive Python REPL](/getting-started/interactive-python)** — Using the REPL and VS Code's interactive window with `Shift + Enter`

### 1.4 Modern Tooling with uv

* **[uv Overview](/uv/index)** — What uv is and why it replaces the traditional pip + venv toolchain
* **[Why uv?](/uv/uv-intro)** — Speed comparison, feature breakdown, and installation
* **[Virtual Envs with uv](/uv/virtual-env)** — Creating projects and managing packages with uv
* **[Complete Project Setup](/uv/complete-setup)** — End-to-end guide: uv + VS Code + Git + GitHub

### 1.5 Course Materials

* **[Course Resources](/getting-started/course-resources)** — Practice notebooks, exercise files, and real-world datasets

***

## Module 2: Python Basics

Core Python syntax, data types, control flow, data structures, and the foundational building blocks of every Python program.

### 2.1 Core Syntax & Data Structures

* **[Python Basics](/basic-python/python-basics)** — Variables, operators, conditionals, loops, and control flow
* **[Data Structures](/basic-python/data-structures)** — Lists, tuples, dictionaries, and sets
* **[Packing & Unpacking](/basic-python/packing-unpacking)** — `*args`, `**kwargs`, and sequence unpacking

### 2.2 Functions and Modules

* **[Functions](/basic-python/functions)** — Defining functions, parameters, return values, and scope
* **[Modules & Packages](/basic-python/modules-packages)** — Custom module files and `__init__.py`

### 2.3 OOP and Error Handling

* **[Classes & OOP](/basic-python/oop-classes)** — Classes, instances, `self`, inheritance, and encapsulation
* **[Exception Handling](/basic-python/exception-handling)** — `try`/`except`/`finally` and custom exceptions

***

## Module 3: Advanced Python

Language internals, functional programming patterns, type validation with Pydantic, and working with external libraries.

### 3.1 Advanced Concepts

* **[Python Internals](/advanced-python/internals)** — CPython memory management and reference counting
* **[Comprehensions](/advanced-python/comprehensions)** — List, dictionary, set comprehensions, and generators
* **[Advanced Functions](/advanced-python/functions)** — Closures, first-class functions, and decorators
* **[Functional Programming](/advanced-python/functional-programming)** — `map()`, `filter()`, and `reduce()`
* **[Advanced OOP](/advanced-python/advanced-oop)** — Abstract Base Classes, metaclasses, and dunder methods
* **[Context Managers](/advanced-python/context-mgmt)** — The `with` statement and custom context managers
* **[Working with Data](/advanced-python/working-with-data)** — Files, JSON, and CSV in Python
* **[dotenv](/advanced-python/dotenv)** — Managing secrets with `.env` files
* **[Async Programming](/advanced-python/async-programming)** — `async`/`await`, coroutines, and `asyncio`
* **[Dependency Injection](/advanced-python/di)** — Decoupling code with DI patterns
* **[Type Hints](/advanced-python/type-hints)** — Annotating Python code for safety and tooling
* **[Dataclasses](/advanced-python/data-class)** — Clean data models using `@dataclass`

### 3.2 Pydantic and Data Validation

* **[Introduction to Pydantic](/pydantic/introduction)** — Runtime validation using type hints
* **[Your First Model](/pydantic/your-first-model)** — Creating BaseModel subclasses
* **[Validation & Fields](/pydantic/validation-and-fields)** — Field constraints and custom validators
* **[Nested Models](/pydantic/nested-models)** — Composing Pydantic models together
* **[Pydantic Settings](/pydantic/pydantic-settings)** — Type-safe configuration from environment variables

***

## Module 4: Developing Projects

Structuring production-grade Python applications, managing imports, and building complete real-world programs.

### 4.1 Developer Tools

* **[Tools Overview](/tools/index)** — Git, environment variables, and code quality tools
* **[Version Control](/tools/git/version-control)** — Core Git concepts and the basic commit workflow
* **[GitHub Setup](/tools/git/github-setup)** — Creating an account and authenticating
* **[Clone & Create](/tools/git/clone-create)** — Cloning repos and publishing new projects
* **[Git in VS Code](/tools/git/vscode-git)** — Managing Git through the Source Control panel

### 4.2 Environment & Secrets

* **[Environment Variables](/tools/environment/variables)** — `os.environ` patterns and use cases
* **[.env Files](/tools/environment/dotenv)** — `python-dotenv` setup and `.env.example` conventions

### 4.3 Project Structure

* **[Project Structure](/practical-python/project-structure)** — Standard folder layouts and file organisation
* **[Python Paths](/practical-python/python-paths)** — `sys.path`, imports, and the `-m` flag
* **[Organising Code](/practical-python/organizing-code)** — Refactoring scripts into reusable modules
* **[Project Handling](/practical-python/project-handling)** — Modules, packages, and virtual environments

### 4.4 Weather Data Project

* **[Project Overview](/weather-project/index)** — Introduction to the hands-on project
* **[uv Introduction](/weather-project/uv-intro)** — Setting up the project environment with uv
* **[Virtual Env Setup](/weather-project/virtual-env)** — Creating and activating environments
* **[Complete Setup](/weather-project/complete-setup)** — Full end-to-end project configuration
* **[Data Analysis Project](/weather-project/weather-data-analysis-project)** — Fetch, process, and visualise weather data

***

## Module 5: Data Analysis & Databases

The mathematical and data manipulation foundations for machine learning and AI.

### 5.1 SQL & Databases

* **[SQL Introduction](/sql/intro)** — Databases, DBMS, and relational concepts
* **[DDL & DML](/sql/sqlite-ddl-dml)** — Creating tables and modifying data
* **[SQLite Setup](/sql/sqlite-dbsetup)** — Setting up your practice database
* **[Querying with SELECT](/sql/dql)** — Filtering, sorting, and aggregating data
* **[SQL Joins](/sql/joins)** — Combining data from multiple tables
* **[Advanced SQL](/sql/adv-sql)** — Normalisation, ACID, and window functions

### 5.2 NumPy

* **[NumPy Arrays](/data-analysis/numpy)** — NDArrays, slicing, indexing, and broadcasting

### 5.3 Pandas

* **[Pandas DataFrames](/data-analysis/pandas)** — Data wrangling, missing values, and aggregation

### 5.4 Data Visualisation

* **[Matplotlib](/data-analysis/matplotlib)** — Line plots, scatter plots, bar charts, and subplots
* **[Seaborn](/data-analysis/seaborn)** — Statistical plots, heatmaps, and distribution charts
* **[Visualisation Guide](/data-analysis/visualization-guide)** — End-to-end dataset plotting pipelines

***

## Module 6: FastAPI

Building production-ready REST APIs with Python.

### 6.1 Foundations

* **[FastAPI Overview](/fastapi-foundations/index)** — What you'll build and course module overview
* **[How the Web Works](/fastapi-foundations/how-web-works)** — HTTP, client-server, and REST concepts
* **[Intro to FastAPI](/fastapi-foundations/intro-to-fastapi)** — Installation, features, and your first app
* **[FastAPI Fundamentals](/fastapi-foundations/fundamentals)** — Routing, path params, query params, request bodies
* **[Request Handling](/fastapi-foundations/request-handling)** — Path/query/body/header inputs with `Annotated`
* **[Response Handling](/fastapi-foundations/response-handling)** — Response models, status codes, and `HTTPException`
* **[Data Validation Models](/fastapi-foundations/data-validation-models)** — Request, internal, and response model patterns
* **[CRUD Operations](/fastapi-foundations/local-crud)** — Full in-memory CRUD API implementation
* **[API Documentation](/fastapi-foundations/api-documentation)** — Swagger UI, ReDoc, and app metadata

### 6.2 Advanced FastAPI

* **[APIRouter](/fastapi-foundations/apirouter)** — Modular routing for larger applications
* **[Exception Handling](/fastapi-foundations/exception-handling)** — Custom error handlers and HTTP exceptions
* **[Dependency Injection](/fastapi-foundations/dependency-injection)** — `Depends()`, `yield` sessions, and shared logic
* **[Modularisation](/fastapi-foundations/modularisation)** — Refactoring into routers, services, and schemas
* **[SQL & ORM](/fastapi-foundations/sql-orm)** — SQLModel, sessions, and persistent CRUD
* **[JWT Authentication](/fastapi-foundations/jwt-auth)** — Token-based auth, protected routes, and RBAC

***

## Module 7: Frontend with Streamlit

Building interactive data applications and dashboards in pure Python — no JavaScript required.

* **[Introduction to Streamlit](/streamlit/intro)** — App architecture and getting started
* **[Displaying Content](/streamlit/displaying-content)** — Text, markdown, dataframes, and charts
* **[Widgets](/streamlit/widgets)** — Buttons, inputs, sliders, and file uploaders
* **[Data Handling](/streamlit/data-handling)** — Reading CSV and JSON, uploading files
* **[Building a Full App](/streamlit/streamlit-app)** — Complete student dashboard project