Getting Started with FastAPI: A Beginner's Guide

Table of Contents

1. Installation
2. Creating a Simple FastAPI Application
3. Path Operations
4. Request and Response Handling
5. Data Validation with Pydantic
6. Dependency Injection
7. Middleware
8. Testing FastAPI Applications
9. Best Practices
10. Conclusion
11. References

1. Installation

To install FastAPI, you can use pip, the Python package manager. It’s recommended to create a virtual environment first to isolate your project dependencies.

# Create a virtual environment
python -m venv myenv

# Activate the virtual environment
# On Windows
myenv\Scripts\activate
# On Linux/Mac
source myenv/bin/activate

# Install FastAPI and Uvicorn (a server for running FastAPI applications)
pip install fastapi uvicorn

2. Creating a Simple FastAPI Application

Let’s start by creating a basic FastAPI application. Create a file named main.py with the following code:

from fastapi import FastAPI

# Create a FastAPI instance
app = FastAPI()

# Define a simple path operation
@app.get("/")
def read_root():
    return {"Hello": "World"}

To run the application, use the following command in your terminal:

uvicorn main:app --reload

Now, open your browser and go to http://127.0.0.1:8000. You should see a JSON response {"Hello": "World"}.

3. Path Operations

Path operations in FastAPI are the endpoints of your API. You can define different HTTP methods (GET, POST, PUT, DELETE, etc.) for each path.

from fastapi import FastAPI

app = FastAPI()

# GET request
@app.get("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

# POST request
@app.post("/items/")
def create_item(item: dict):
    return item

In the above example, the read_item function handles GET requests with a path parameter item_id, and the create_item function handles POST requests with a JSON body.

4. Request and Response Handling

FastAPI makes it easy to handle requests and responses. You can define request bodies, query parameters, headers, and status codes.

from fastapi import FastAPI, Query, Body

app = FastAPI()

# Query parameter
@app.get("/items/")
def read_items(q: str = Query(None, max_length=50)):
    if q:
        return {"query": q}
    return {"message": "No query provided"}

# Request body
@app.post("/items/")
def create_item(item: dict = Body(...)):
    return item

In the read_items function, we define a query parameter q with a maximum length of 50. In the create_item function, we expect a JSON body in the request.

5. Data Validation with Pydantic

FastAPI uses Pydantic for data validation. You can define data models using Pydantic classes to ensure that the data received in requests is valid.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# Define a Pydantic model
class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

# Use the model in a path operation
@app.post("/items/")
def create_item(item: Item):
    return item

In this example, the Item class is a Pydantic model. FastAPI will automatically validate the data received in the request against this model.

6. Dependency Injection

Dependency injection in FastAPI allows you to share code, reuse logic, and manage dependencies. You can define dependencies as functions and use them in path operations.

from fastapi import FastAPI, Depends

app = FastAPI()

# Define a dependency
def get_db():
    # Code to connect to the database
    db = ...
    try:
        yield db
    finally:
        # Code to close the database connection
        db.close()

# Use the dependency in a path operation
@app.get("/items/")
def read_items(db = Depends(get_db)):
    # Use the database connection
    return {"message": "Items retrieved from the database"}

In the read_items function, we inject the get_db dependency to get a database connection.

7. Middleware

Middleware in FastAPI allows you to perform actions on requests and responses globally. You can use middleware for tasks like logging, authentication, and error handling.

from fastapi import FastAPI, Request
import time

app = FastAPI()

# Define a middleware
@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

In this example, we define a middleware that adds a header X-Process-Time to the response, indicating the time taken to process the request.

8. Testing FastAPI Applications

You can use the TestClient from fastapi.testclient to test your FastAPI applications.

from fastapi import FastAPI
from fastapi.testclient import TestClient

app = FastAPI()

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

client = TestClient(app)

def test_read_root():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"Hello": "World"}

In this example, we create a test client and write a test function to check if the root path returns the expected JSON response.

9. Best Practices

• Use Pydantic models: Always use Pydantic models for data validation and serialization. This ensures that the data in your application is consistent and valid.
• Keep your code modular: Break your code into smaller functions and modules. This makes your code easier to understand, maintain, and test.
• Use dependency injection: Leverage dependency injection to manage dependencies and reuse code.
• Write tests: Write unit tests and integration tests for your FastAPI applications to ensure that they work as expected.
• Document your API: FastAPI automatically generates documentation for your API. Use the built-in documentation features to make your API easy to understand and use.

10. Conclusion

FastAPI is a powerful and easy-to-use web framework for building APIs with Python. In this blog post, we covered the fundamental concepts of FastAPI, including installation, path operations, request and response handling, data validation, dependency injection, middleware, testing, and best practices. With this knowledge, you should be able to start building your own FastAPI applications.

11. References

• FastAPI Documentation
• Pydantic Documentation