Made withFlaskTutorial

Python FastAPI Tutorial: Build a REST API in 15 Minutes

P

pixegami

Creator on the Flask channel

Watch on YouTube ↗

525K viewsSep 11, 202315:16 runtime

Learn how to build a high-performance REST API with Python and FastAPI in just 15 minutes. This tutorial guides you through installing FastAPI and Uvicorn, creating your first application, and defining routes with path and query parameters. You'll discover how to handle errors…

Chapters

#flask#tutorial#backend

Key Concepts in this FastAPI Tutorial

This document summarizes the core concepts for building a REST API with Python and FastAPI.

Getting Started

Installation: You need both fastapi for the framework and uvicorn to serve the application.
```
pip install fastapi "uvicorn[standard]"
```

Basic App: Create a FastAPI instance and use decorators to define routes.

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

Run the Server: Use Uvicorn from your terminal, pointing it to your Python file and app instance. The --reload flag enables auto-reloading on code changes.
```
uvicorn main:app --reload
```

Note
The in-memory items list used in this tutorial is for demonstration only. It will reset every time the server reloads. A real application would use a database.

API Routing & Parameters

FastAPI uses decorators (@app.get, @app.post, etc.) to associate functions with URL paths and HTTP methods.

Path Parameters: Defined directly in the URL path using curly braces (e.g., /items/{item_id}). The value is passed as an argument to the function.
```
@app.get("/items/{item_id}")
def read_item(item_id: int):
    # ...
```
Query Parameters: Key-value pairs appended to the URL (e.g., ?limit=10). They are defined as function arguments that are not part of the path.
```
@app.get("/items/")
def list_items(limit: int = 10):
    # ...
```

Error Handling

For meaningful client-side errors, raise an HTTPException.

Usage: Import HTTPException and raise it with a status_code and an optional detail message.

from fastapi import FastAPI, HTTPException

# ...
if item_id >= len(items):
    raise HTTPException(status_code=404, detail="Item not found")

Data Modeling with Pydantic

Use Pydantic's BaseModel to create data schemas for robust validation, serialization, and documentation.

Request Body: When a Pydantic model is used as a type hint for a function argument, FastAPI expects that data in the request's JSON body.
Response Model: Use the response_model argument in the decorator to define and enforce the structure of the API's response.

from pydantic import BaseModel
from typing import List

class Item(BaseModel):
    text: str # Required field
    is_done: bool = False # Optional with default

@app.post("/items/", response_model=Item)
def create_item(item: Item):
    # FastAPI automatically validates 'item' against the 'Item' model
    items.append(item)
    return item

@app.get("/items/", response_model=List[Item])
def list_items():
    return items

Important
Switching a route to use a Pydantic model for input changes the expectation from query parameters to a JSON request body. Your client requests (e.g., curl) must be updated accordingly.

Core FastAPI Features

Automatic Documentation: FastAPI auto-generates interactive API documentation.
- Swagger UI: Visit /docs to test endpoints directly from your browser.
- ReDoc: Visit /redoc for an alternative documentation view.
- OpenAPI Schema: The raw OpenAPI JSON schema is available at /openapi.json.
Performance: FastAPI is built on Starlette and Pydantic and supports asynchronous code (async/await) out of the box for high concurrency.