Building RESTful APIs with FastAPI is super easy and incredibly powerful. If you’ve ever dabbled in Python and wanted to create efficient APIs, FastAPI is your go-to framework. It handles basic HTTP methods like GET, POST, and DELETE with such elegance that you’ll wonder why you didn’t switch sooner. Plus, with its modern Python 3.7+ based asynchronous capabilities, creating robust and scalable APIs has never been simpler.

Getting your environment set up is the first step. You need Python 3.7 or later, FastAPI, and Uvicorn – which is an ASGI server that runs your FastAPI application. You can get these with a simple pip install:

pip install fastapi uvicorn

Next, you’ll create a FastAPI application instance. This is essentially the heart of your API where you define all your routes.

from fastapi import FastAPI

app = FastAPI()

Handling GET requests is usually where most people start. GET requests retrieve data from your API. For example, you might want an endpoint to fetch all users:

from typing import List
from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str

# Sample in-memory data store
users = [
    User(id=1, name="John Doe", email="[email protected]"),
    User(id=2, name="Jane Doe", email="[email protected]"),
]

@app.get("/users/")
def read_users():
    return users

Here, a User model is defined using Pydantic, and a list of sample users is created. The @app.get("/users/") decorator creates an endpoint that returns all users when accessed. It’s as straightforward as it sounds.

For POST requests, which are used to create new data, here’s how you might add an endpoint to create a new user:

@app.post("/users/", response_model=User)
def create_user(user: User):
    users.append(user)
    return user

This code block uses the @app.post("/users/") decorator to define an endpoint that accepts a User object in the request body and adds it to the list of users. Neat and simple, right?

When it comes to DELETE requests, which are used to delete existing data, adding an endpoint to delete a user by their ID looks like this:

@app.delete("/users/{user_id}")
def delete_user(user_id: int):
    for user in users:
        if user.id == user_id:
            users.remove(user)
            return {"message": "User deleted successfully"}
    raise HTTPException(status_code=404, detail="User not found")

This endpoint takes a user_id as a path parameter, finds the corresponding user in the list, and removes it. If the user isn’t found, a 404 error is raised. It’s a foolproof way to manage your data.

Error handling is another crucial aspect of building APIs. FastAPI makes it incredibly straightforward to handle errors using the HTTPException class:

from fastapi import HTTPException

@app.delete("/users/{user_id}")
def delete_user(user_id: int):
    for user in users:
        if user.id == user_id:
            users.remove(user)
            return {"message": "User deleted successfully"}
    raise HTTPException(status_code=404, detail="User not found")

In real-world applications, data is typically stored in databases rather than in-memory. FastAPI can be combined with SQLModel or SQLAlchemy to interact with databases. Here’s an example using SQLModel to delete data from a database:

from fastapi import FastAPI, HTTPException
from sqlmodel import Field, Session, SQLModel, create_engine, select

# Define your database model
class HeroBase(SQLModel):
    name: str
    secret_name: str

class Hero(HeroBase, table=True):
    id: int = Field(primary_key=True)

# Create the database engine
engine = create_engine("sqlite:///heroes.db")

# Create the database tables
SQLModel.metadata.create_all(engine)

app = FastAPI()

@app.delete("/heroes/{hero_id}")
def delete_hero(hero_id: int):
    with Session(engine) as session:
        hero = session.get(Hero, hero_id)
        if not hero:
            raise HTTPException(status_code=404, detail="Hero not found")
        session.delete(hero)
        session.commit()
        return {"ok": True}

This illustrates how to define a Hero model, create the database tables, and delete a hero by their ID using the DELETE method.

Before deploying, you’ll want to test the API endpoints. Tools like Postman or curl can help you with this. Here’s how to use curl for testing:

# Get all users
curl http://localhost:8000/users/

# Create a new user
curl -X POST -H "Content-Type: application/json" -d '{"id": 3, "name": "Alice Smith", "email": "[email protected]"}' http://localhost:8000/users/

# Delete a user
curl -X DELETE http://localhost:8000/users/1

Running your FastAPI application is pretty simple with Uvicorn. Just use the following command:

uvicorn main:app --reload

This starts the server and automatically reloads whenever you make changes to your code. Pretty nifty!

In summary, building RESTful APIs with FastAPI is a seamless process that leverages modern Python features and asynchronous capabilities. By following these steps, you can create robust APIs that handle GET, POST, and DELETE requests efficiently. Whether you’re working with in-memory data or databases, FastAPI provides all the tools you need to build scalable and maintainable APIs.

There you have it – a straightforward, casual guide to creating RESTful APIs with FastAPI. With this under your belt, you’re ready to build some awesome, responsive, and scalable APIs. Happy coding!