Beginner’s Guide to FastAPI: A Crash Course in the Python Web Framework for 2021

FastAPI is a modern web framework for building APIs with Python. It is designed to be fast, easy to use, and highly performant. In this crash course, we will cover the basics of FastAPI and how to create a simple API using it.

To get started, you will need to have Python installed on your machine. You can install FastAPI using pip by running the following command:

pip install fastapi

You will also need to install an ASGI server like uvicorn to run your FastAPI application. You can install uvicorn using pip as well:

pip install uvicorn

Once you have FastAPI and uvicorn installed, you can create a new Python file for your FastAPI application. Let’s create a file called main.py and add the following code:

from fastapi import FastAPI

app = FastAPI()

@app.get('/')
def read_root():
    return {'message': 'Hello, World!'}

In this code snippet, we import the FastAPI class from the fastapi module and create a new FastAPI instance. We then define a GET route that returns a JSON response with a simple message.

To run your FastAPI application, you can use the uvicorn command-line tool. Simply run the following command in your terminal:

uvicorn main:app --reload

This command tells uvicorn to run the main module (our main.py file) and use the app instance created in that module as the FastAPI application. The --reload flag enables auto-reloading, so your server will restart whenever you make changes to your code.

Now that your FastAPI application is running, you can open your web browser and navigate to http://localhost:8000 to see your API in action. You should see the message "Hello, World!" displayed on the page.

In addition to simple GET routes like the one we created above, FastAPI also supports POST, PUT, DELETE, and other HTTP methods for creating more complex APIs. You can also define path parameters, request query parameters, request bodies, response models, and more in your FastAPI routes.

For example, let’s create a new POST route that accepts a JSON request body and returns the same data in the response. Update your main.py file with the following code:

from fastapi import FastAPI

app = FastAPI()

@app.get('/')
def read_root():
    return {'message': 'Hello, World!'}

@app.post('/')
def create_item(item: dict):
    return item

In this code snippet, we define a new POST route / that expects a JSON request body with an item field. The create_item function accepts a dictionary item as a parameter and simply returns it in the response.

To test this new route, you can use a tool like Postman or cURL to send a POST request to http://localhost:8000 with a JSON body containing an item field. You should see the same data returned in the response.

FastAPI also provides automatic request validation and serialization using Pydantic models. You can define Pydantic models for your request and response data, and FastAPI will handle validation and serialization for you.

Here is an example of how to use Pydantic models in a FastAPI route:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

@app.post('/items/')
def create_item(item: Item):
    return item

In this code snippet, we define a Pydantic model Item with fields for name, description, price, and tax. In the create_item route, we expect a JSON request body that matches the Item model, and FastAPI will automatically validate and serialize the data for us.

FastAPI also provides built-in support for dependency injection, security features like OAuth2 authentication, request and response validation, and more. It is a powerful and flexible web framework that is easy to learn and use.

I hope this crash course has given you a good introduction to FastAPI and how to create APIs with Python using this framework. Happy coding!