Python FastApi Syllabus

FastApi syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for FastApi in Python, not a summary of it.

1. 1

   Introduction to FastAPI

   2 topics

   • Overview
     • What is FastAPI?
     • Key Features
     • Advantages over other frameworks
   • Installation
     • Setting up a Virtual Environment
     • Installing FastAPI using pip
     • Installing an ASGI server (e.g., Uvicorn)
2. 2

   Basic Concepts

   4 topics

   • First Steps
     • Creating a Basic FastAPI Application
     • Running the FastAPI Application
     • Understanding the Auto-Generated Documentation
   • Path Parameters
     • Defining Path Parameters
     • Using Path Parameters in Endpoints
   • Query Parameters
     • Defining Query Parameters
     • Optional and Required Query Parameters
   • Request Body
     • Using Pydantic Models
     • Defining Request Bodies
     • Validating Request Data
3. 3

   Advanced Concepts

   4 topics

   • Dependency Injection
     • Defining Dependencies
     • Using Dependencies in Endpoints
     • Global Dependencies
   • Security
     • OAuth2 with Password (and hashing), Bearer with JWT tokens
     • Handling Security Scopes
     • Using API Keys
   • Background Tasks
     • Defining Background Tasks
     • Using Background Tasks in Endpoints
   • Middleware
     • Creating Middleware
     • Using Middleware in FastAPI
4. 4

   Database Integration

   2 topics

   • SQL (Relational Databases)
     • Using SQLAlchemy
     • Setting up Database Connections
     • Defining Models and Schemas
     • Performing CRUD Operations
   • NoSQL (Non-Relational Databases)
     • Using MongoDB with Motor
     • Setting up Database Connections
     • Defining Models and Schemas
     • Performing CRUD Operations
5. 5

   Testing

   2 topics

   • Writing Tests
     • Using pytest
     • Testing Endpoints
     • Using TestClient
   • Mocking Dependencies
     • Using Dependency Overrides
     • Mocking External Services
6. 6

   Deployment

   2 topics

   • Deployment Options
     • Deploying with Docker
     • Deploying to AWS
     • Deploying to Google Cloud
     • Deploying to Heroku
   • CI/CD
     • Setting up GitHub Actions
     • Automating Tests and Deployments

FastApi flashcards for Python

23 of 56 cards from the FastApi deck — real questions with worked answers.

1. What is FastAPI and what is its primary purpose?

   FastAPI is a modern, high-performance Python web framework for building APIs, based on standard Python type hints. It is designed for speed, automatic data validation, and automatic interactive documentation.

2. Which two libraries does FastAPI build upon, and what does each provide?

   Starlette provides the web/ASGI toolkit (routing, requests, responses), and Pydantic provides data validation and serialization via Python type hints.

3. Why is FastAPI considered 'fast'? Name the main performance factors.

   It is built on Starlette and async ASGI, runs on Uvicorn (uvloop), and avoids redundant validation. Its performance is on par with NodeJS and Go for many workloads.

4. What two documentation UIs does FastAPI generate automatically, and at which default URLs?

   Swagger UI at /docs and ReDoc at /redoc, both generated from the OpenAPI schema.

5. What open standard schema does FastAPI automatically produce for an application?

   An OpenAPI schema (served as JSON at /openapi.json), which also conforms to JSON Schema for the data models.

6. What command installs FastAPI together with its standard optional dependencies?

   pip install "fastapi[standard]" — this includes Uvicorn and extras like the standard CLI, validation, and email support.

7. What type of server is required to run a FastAPI application, and name the most common one?

   An ASGI server is required; Uvicorn is the most common (Hypercorn is an alternative).

8. What is the recommended development command to run a FastAPI app defined in main.py?

   fastapi dev main.py — it runs the app with auto-reload enabled for development.

9. What is the difference between `fastapi dev` and `fastapi run`?

   `fastapi dev` runs in development mode with auto-reload on code changes; `fastapi run` runs in production mode without reload.

10. Write the minimal FastAPI 'first steps' application with a root endpoint.

    from fastapi import FastAPI app = FastAPI() @app.get("/") def read_root(): return {"Hello": "World"}

11. In FastAPI, what is the object created by `app = FastAPI()` called and what does it do?

    It is the application instance — the main point of interaction that registers all routes and creates the API.

12. What is a 'path operation' in FastAPI terminology?

    The combination of a URL path and an HTTP operation (method) — e.g., GET on /items — handled by a path operation function via a decorator like @app.get().

13. How are path parameters declared in a FastAPI route, and how is type conversion handled?

    They are declared in the path string with braces, e.g. @app.get("/items/{item_id}"), and given a type-annotated function parameter. FastAPI parses, validates, and converts the value (e.g., int).

14. What HTTP status code does FastAPI return when a path/query parameter fails type validation?

    422 Unprocessable Entity, with a JSON body describing the validation error.

15. Why does the order of path operations matter when one path could match a fixed value and a parameter?

    FastAPI evaluates routes in declaration order, so a fixed path like /users/me must be declared before /users/{user_id}; otherwise 'me' would be captured as the parameter.

16. How do you restrict a path parameter to a fixed set of allowed values in FastAPI?

    Create an Enum class (typically subclassing str, Enum) and use it as the parameter's type annotation.

17. How does FastAPI distinguish path parameters from query parameters in a function signature?

    Parameters whose names appear in the path string are path parameters; all other function parameters are interpreted as query parameters.

18. How do you make a query parameter optional with a default value in FastAPI?

    Give the function parameter a default value, e.g. def read(q: str | None = None): — without a default it becomes required.

19. How does FastAPI parse a boolean query parameter like ?short=yes or ?short=1?

    It coerces common truthy/falsy forms (true, True, 1, yes, on) to bool True and (false, 0, no, off) to False automatically.

20. What class is used to add validation and metadata to query parameters in FastAPI?

    Query, from fastapi — e.g. q: str = Query(default=None, min_length=3, max_length=50).

21. How do you declare a request body in FastAPI, and what status code is returned on invalid body data?

    Declare a Pydantic BaseModel and use it as a function parameter type. Invalid data yields a 422 response with detailed errors.

22. How does FastAPI decide whether a parameter comes from the path, query, or request body?

    If the name is in the path it's a path param; if it's a singular type (int, str) it defaults to a query param; if it's a Pydantic model it's read from the request body.

23. Which Pydantic class do request-body models inherit from in FastAPI?

    pydantic.BaseModel.

See more FastApi flashcards →

Planning FastApi for Python

FastApi (Python) FAQ