FastAPI Tutorial: Build a REST API with Python

FastAPI Tutorial: Build a REST API with Python

FastAPI is a high-performance Python framework designed for building APIs quickly and efficiently. With built-in support for asynchronous operations, automatic type validation, interactive documentation, and more, FastAPI simplifies the process of developing robust REST APIs.

This tutorial will guide you through creating a simple REST API using FastAPI, covering setup, core features, and practical examples.

Introduction to FastAPI

FastAPI offers several advantages for API development:

• High performance: Async by default, enabling efficient handling of concurrent requests.
• Ease of use: Simple syntax for defining routes, endpoints, and exception handling.
• Interactive docs: Automatically generated Swagger UI and ReDoc for API testing and visualization.
• Type validation: Leverages Python type hints for request and response validation.

Whether you are transitioning from Flask or exploring API development in Python for the first time, FastAPI provides all the tools you need to get started.

Installing FastAPI and Uvicorn

To begin, you need to install FastAPI and Uvicorn, an ASGI server for running FastAPI applications.

Steps:

1. Install FastAPI and Uvicorn:

pip install fastapi uvicorn
# FastAPI framework and ASGI server for your app

2. Create a project directory:

mkdir fastapi_project
cd fastapi_project

3. Open the directory in your code editor and create a file called main.py.

Creating the Basic FastAPI App

Let's set up a basic FastAPI app that returns a "Hello World" message at the root endpoint.

from fastapi import FastAPI

app = FastAPI()

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

uvicorn main:app --reload
# Launches the FastAPI app with auto-reloading enabled

Adding Routes and Endpoints

Next, add more routes to create and retrieve data.

Create or update main.py with the following content:

from fastapi import FastAPI, HTTPException

app = FastAPI()

items = []

@app.post("/items/")
async def create_item(item: str):
    items.append(item)
    return {"items": items}

@app.get("/items/{index}")
async def read_item(index: int):
    if index < 0 or index >= len(items):
        raise HTTPException(status_code=404, detail="Item not found")
    return {"item": items[index]}

4. Test these routes using an API client or endpoint testing tools.

Handling Errors and HTTP Exceptions

FastAPI provides tools like HTTPException to handle error scenarios effectively.

from fastapi import HTTPException

@app.get("/items/{index}")
async def read_item(index: int):
    if index >= len(items) or index < 0:
        raise HTTPException(
            status_code=404, 
            detail="Item not found"
        )
    return {"item": items[index]}

Returns a proper 404 response when accessing out-of-range indices.

Using Pydantic for Request and Response Validation

Pydantic enables structured and validated data for requests and responses.

Update your main.py as follows:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

items = []

class Item(BaseModel):
    name: str
    price: float
    is_available: bool = True

@app.post("/add-item/")
async def add_item(item: Item):
    items.append(item)
    return {"item": item}

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

4. Test request validation with mismatched or incorrect data formats.

Interactive API Documentation with FastAPI

FastAPI automatically generates interactive documentation for your endpoints.

Comparing FastAPI with Flask and Django

Conclusion

FastAPI combines the best of simplicity and performance. With type validation, asynchronous processing, and interactive documentation, it enables rapid API development for scalable applications. Consider exploring additional features like database integration, authentication mechanisms, or deployment strategies to expand your FastAPI skills.

Official reference: FastAPI documentation.