Python FastAPI

Learning Objectives

FastAPI builds on several concepts you have already learned: functions, type hints, dictionaries, JSON, HTTP, REST APIs, and asynchronous programming.

What Is FastAPI?

FastAPI is a modern Python web framework designed primarily for building APIs.

It combines Python type hints with automatic request validation and API documentation.

FastAPI is especially useful for backend services that communicate with websites, mobile applications, data applications, and other services.

Why FastAPI?

FastAPI has become popular because it provides a productive development experience while supporting modern Python features.

FastAPI also works closely with the Pydantic library for data validation and serialization.

Installing FastAPI

Install FastAPI together with an ASGI server such as Uvicorn:

python -m pip install fastapi uvicorn

You can verify the installation with:

python -m pip show fastapi
python -m pip show uvicorn

Your First FastAPI Application

Create a file named main.py.

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def home():
    return {
        "message": "Hello, PyLearn!"
    }

The application object is created with:

app = FastAPI()

The route:

@app.get("/")

tells FastAPI that the function should handle GET requests to the root URL.

Running the Server

Start the FastAPI application with Uvicorn:

uvicorn main:app --reload

The command means:

• main — the Python file main.py.
• app — the FastAPI application object.
• --reload — automatically reload during development when source files change.

You can normally access the application at:

http://127.0.0.1:8000

python -m uvicorn main:app --reload

Routes & Path Operations

FastAPI calls its endpoint declarations path operations.

@app.get("/products")
def get_products():
    return {
        "message": "Product list"
    }


@app.post("/products")
def create_product():
    return {
        "message": "Product created"
    }

Each decorator connects a URL and HTTP method to a function.

HTTP Methods

REST APIs commonly use different HTTP methods to represent different operations.

Example

@app.get("/products")
def get_products():
    return {"action": "get"}


@app.post("/products")
def create_product():
    return {"action": "create"}


@app.put("/products/1")
def replace_product():
    return {"action": "replace"}


@app.patch("/products/1")
def update_product():
    return {"action": "update"}


@app.delete("/products/1")
def delete_product():
    return {"action": "delete"}

Path Parameters

Path parameters allow a value from the URL to be passed directly into a Python function.

@app.get("/products/{product_id}")
def get_product(product_id: int):

    return {
        "product_id": product_id
    }

A request such as:

/products/25

passes 25 to the function.

Query Parameters

Query parameters appear after ? in a URL.

/products?category=phones&limit=10

FastAPI can recognize query parameters directly from function parameters.

@app.get("/products")
def get_products(
    category: str | None = None,
    limit: int = 10
):

    return {
        "category": category,
        "limit": limit
    }

The URL:

/products?category=phones&limit=5

produces values similar to:

{
    "category": "phones",
    "limit": 5
}

Request Body

POST and PUT requests commonly send structured JSON data in the request body.

For example:

{
    "name": "Laptop",
    "price": 1200,
    "quantity": 5
}

FastAPI can automatically parse and validate this data using a model.

This is one of the areas where FastAPI's integration with Pydantic becomes extremely useful.

Pydantic Models

A Pydantic model describes the structure of data that your API expects.

from pydantic import BaseModel


class Product(BaseModel):

    name: str
    price: float
    quantity: int

You can then use the model as a function parameter.

@app.post("/products")
def create_product(product: Product):

    return product

FastAPI understands that the endpoint expects a JSON object matching the Product model.

Automatic Validation

FastAPI and Pydantic can validate incoming data according to the types and rules defined by your models.

from pydantic import BaseModel, Field


class Product(BaseModel):

    name: str

    price: float = Field(
        gt=0
    )

    quantity: int = Field(
        ge=0
    )

Here:

• price must be greater than zero.
• quantity must be zero or greater.

Response Models

You can also define the structure of the data your API should return.

class ProductResponse(BaseModel):

    id: int
    name: str
    price: float


@app.get(
    "/products/{product_id}",
    response_model=ProductResponse
)
def get_product(product_id: int):

    return {
        "id": product_id,
        "name": "Laptop",
        "price": 1200
    }

Response models help keep your API output consistent and documented.

HTTP Status Codes

APIs should communicate the result of an operation using appropriate HTTP status codes.

from fastapi import FastAPI, status


@app.post(
    "/products",
    status_code=status.HTTP_201_CREATED
)
def create_product():

    return {
        "message": "Product created"
    }

JSON Responses

Returning a Python dictionary from a FastAPI endpoint normally produces a JSON response.

@app.get("/api/products")
def products():

    return {
        "products": [
            {
                "id": 1,
                "name": "Laptop",
                "price": 1200
            },
            {
                "id": 2,
                "name": "Phone",
                "price": 800
            }
        ]
    }

The client receives structured JSON that can easily be consumed by JavaScript, mobile applications, or other backend services.

Headers

HTTP headers carry additional information about requests and responses.

from fastapi import FastAPI, Header

app = FastAPI()


@app.get("/profile")
def profile(
    user_agent: str | None = Header(default=None)
):

    return {
        "user_agent": user_agent
    }

FastAPI can map HTTP headers into Python function parameters.

Error Handling

FastAPI provides HTTPException for returning HTTP errors from your application.

from fastapi import FastAPI, HTTPException

app = FastAPI()


@app.get("/products/{product_id}")
def get_product(product_id: int):

    if product_id != 1:

        raise HTTPException(
            status_code=404,
            detail="Product not found"
        )

    return {
        "id": 1,
        "name": "Laptop"
    }

The client receives an appropriate HTTP error response instead of an unexplained application failure.

Dependency Injection

FastAPI includes a dependency injection system that allows reusable logic to be shared across endpoints.

from fastapi import Depends, FastAPI

app = FastAPI()


def get_database():
    return "Database Connection"


@app.get("/products")
def products(
    database=Depends(get_database)
):

    return {
        "database": database
    }

Dependencies can be used for things such as authentication, database connections, reusable parameters, and shared application logic.

Automatic API Documentation

One of FastAPI's most useful features is automatic interactive API documentation.

After starting your application, FastAPI normally provides interactive documentation at:

/docs

For example:

http://127.0.0.1:8000/docs

FastAPI also provides an alternative documentation interface at:

/redoc

Async Endpoints

FastAPI supports Python's asynchronous programming model.

from fastapi import FastAPI

app = FastAPI()


@app.get("/products")
async def products():

    return {
        "message": "Async endpoint"
    }

An asynchronous function uses async def.

When an operation supports asynchronous waiting, you can use await.

import asyncio


@app.get("/wait")
async def wait_example():

    await asyncio.sleep(1)

    return {
        "message": "Finished waiting"
    }

Professional FastAPI Project Structure

A larger API should be organized into modules instead of putting every endpoint inside one file.

my_api/
│
├── app/
│   ├── main.py
│   │
│   ├── routers/
│   │   ├── products.py
│   │   └── users.py
│   │
│   ├── models/
│   │   └── product.py
│   │
│   ├── services/
│   │   └── product_service.py
│   │
│   └── database.py
│
├── tests/
│
├── requirements.txt
│
└── .env

This structure separates routing, models, business logic, database access, and testing.

Practical Example — Ecommerce Product API

Let's combine routes, path parameters, Pydantic models, validation, and status codes into a small ecommerce API.

main.py

from fastapi import (
    FastAPI,
    HTTPException,
    status
)

from pydantic import BaseModel, Field


app = FastAPI()


class Product(BaseModel):

    name: str

    price: float = Field(
        gt=0
    )

    quantity: int = Field(
        ge=0
    )


products = []


@app.get("/products")
def get_products():

    return products


@app.post(
    "/products",
    status_code=status.HTTP_201_CREATED
)
def create_product(product: Product):

    products.append(product)

    return product


@app.get("/products/{product_id}")
def get_product(product_id: int):

    if product_id >= len(products):

        raise HTTPException(
            status_code=404,
            detail="Product not found"
        )

    return products[product_id]

Example JSON Request

{
    "name": "Laptop",
    "price": 1200,
    "quantity": 10
}

FastAPI validates the incoming structure before passing the data into your endpoint.

Common FastAPI Mistakes

Practice Exercises

Mini Challenge — Ecommerce Product API

Build a small but professional REST API for an ecommerce product catalog.

Suggested Product Model

from pydantic import BaseModel, Field


class Product(BaseModel):

    id: int

    name: str

    category: str

    price: float = Field(
        gt=0
    )

    quantity: int = Field(
        ge=0
    )

Knowledge Check

Test your understanding of FastAPI.

Lesson Summary

FastAPI provides a modern approach to building Python APIs. It combines Python type hints, validation, automatic documentation, and asynchronous capabilities.