No history yet

Introduction to FastAPI

Meet FastAPI

When you build a web application, you often need a way for different parts of your system to talk to each other. This is where an API, or Application Programming Interface, comes in. It's a set of rules that lets different software components communicate.

Python has many tools for building APIs, but one of the most popular today is FastAPI. It’s a modern web framework that lives up to its name. It’s fast, both in terms of how quickly it runs and how quickly you can build with it.

FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.

What makes it special? Three things stand out:

  1. High Performance: It's one of the fastest Python frameworks available, on par with NodeJS and Go. This is because it’s built on top of other high-performance tools called Starlette (for the web parts) and Pydantic (for data validation).

  2. Easy to Use: You write standard Python. If you know Python type hints, you already know how to use the core of FastAPI. This makes your code more readable and less prone to errors.

  3. Automatic Docs: FastAPI automatically generates interactive API documentation for you. This is a huge time-saver. You can see all your API endpoints, test them out, and share the documentation with others, all without writing a single extra line of code.

Getting Started

First, you need to install FastAPI and a server to run it. We'll use Uvicorn, which is a lightning-fast ASGI (Asynchronous Server Gateway Interface) server.

Think of it this way: FastAPI is the framework for building your house, and Uvicorn is the foundation and utility hookups that make it a place you can actually live in. You need both.

pip install fastapi uvicorn

With those installed, you can create your first FastAPI application. Create a file named main.py and add the following code.

from fastapi import FastAPI

# Create an instance of the FastAPI class
app = FastAPI()

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

Let's break that down:

  • from fastapi import FastAPI: This line imports the main FastAPI class.
  • app = FastAPI(): This creates an instance of FastAPI, which will be the main point of interaction for creating your API.
  • @app.get("/"): This is a path operation decorator. It tells FastAPI that the function right below it is in charge of handling requests that go to the URL path / using a GET HTTP method.

Running Your App

To run this application, go to your terminal in the same directory as your main.py file and run Uvicorn:

uvicorn main:app --reload

Here’s what that command means:

  • main: The file main.py.
  • app: The object app you created inside main.py with app = FastAPI().
  • --reload: This makes the server restart automatically after you change your code. It's great for development.

Once it's running, open your web browser and go to http://127.0.0.1:8000. You should see the JSON response: {"Hello":"World"}.

Now for the magic. Go to http://127.0.0.1:8000/docs in your browser.

You'll see an interactive API documentation page. FastAPI generated this for you from your code. It shows your endpoint, lets you try it out, and shows you the response. As you build more complex APIs, this documentation becomes an incredibly valuable tool.

Quiz Questions 1/5

What are the two underlying libraries that give FastAPI its high-performance capabilities?

Quiz Questions 2/5

In a FastAPI application, what is the primary role of Uvicorn?

That's all it takes to get a basic web API up and running with FastAPI. You've installed the necessary packages, written a few lines of Python, and served it locally. In the next steps, we'll explore how to handle different types of requests and work with data.