Skip to main content

FastAPI Hello World

Introduction to FastAPI​

FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.7+ based on standard Python type hints. It is designed to be easy to use and to provide high performance, thanks to its asynchronous capabilities. FastAPI is built on top of Starlette for web handling and Pydantic for data validation and serialization.

FastAPI is gaining popularity due to its simplicity, performance, and compatibility with other Python libraries and frameworks.

History​

FastAPI was created by Sebastián Ramírez and released in 2018. Its development was inspired by Flask and Starlette frameworks, combining the best features from both frameworks to create a modern and efficient web framework.

Features of FastAPI​

FastAPI comes with several powerful features that make it a popular choice for building web APIs:

  1. Fast: FastAPI is one of the fastest Python frameworks available, thanks to its asynchronous capabilities and the use of Starlette as its underlying web handling framework.

  2. Easy to use: FastAPI is designed to be easy to use, with a simple and intuitive API that allows developers to quickly build APIs with less code and effort.

  3. Type checking: FastAPI leverages Python type hints to perform automatic data validation, serialization, and documentation generation. This helps catch bugs early and speeds up development.

  4. Interactive documentation: FastAPI automatically generates interactive API documentation based on the provided type hints. This documentation is accessible through a web browser and allows developers to test API endpoints directly from the documentation.

  5. Automatic serialization: FastAPI automatically converts Python objects to JSON (and vice versa) based on the type hints provided. This simplifies data serialization and deserialization.

  6. Authentication and authorization: FastAPI provides built-in support for authentication and authorization, making it easy to secure API endpoints.

  7. WebSocket support: FastAPI supports WebSocket connections out of the box, allowing real-time bidirectional communication between clients and the server.

  8. Compatibility: FastAPI is fully compatible with the latest Python features and libraries, including asyncio, type hints, and async/await syntax. It also integrates well with other popular Python frameworks, such as SQLAlchemy and Pydantic.

You can find more details about FastAPI and its features on the official website: https://fastapi.tiangolo.com/

Hello World Example​

Now, let's dive into a simple "Hello World" example using FastAPI.

First, make sure you have FastAPI installed. You can install it using pip:

$ pip install fastapi

Create a new Python file called main.py and import the necessary modules:

from fastapi import FastAPI

Next, create an instance of the FastAPI class:

app = FastAPI()

Now, let's define a simple "Hello World" endpoint:

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

In the above code, we use the @app.get("/) decorator to define an HTTP GET endpoint at the root URL ("/"). The read_root function is executed when this endpoint is accessed and it returns a JSON response with the message "Hello World".

Finally, we need to start the FastAPI application:

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Save the file and run it using the following command:

$ python main.py

You should see the FastAPI application starting up. Open your web browser and navigate to http://localhost:8000. You should see the "Hello World" message displayed.

Congratulations! You have successfully created a basic "Hello World" API using FastAPI.

Comparison with Alternatives​

FastAPI is a modern web framework that offers several advantages over its alternatives. Let's compare FastAPI with Flask and Django, two popular Python web frameworks:

  • Flask: Flask is a lightweight web framework that is easy to learn and use. However, compared to FastAPI, Flask lacks built-in support for asynchronous programming and type checking. FastAPI's automatic data validation and serialization based on type hints can help catch bugs early and improve code reliability. FastAPI also provides better performance due to its asynchronous capabilities.

  • Django: Django is a comprehensive web framework that provides a wide range of features out of the box, including an ORM, authentication, and admin interface. However, Django can be complex to set up and may not be suitable for small projects or APIs that require high performance. FastAPI, on the other hand, is designed to be lightweight, easy to use, and highly performant. It focuses specifically on building APIs and integrates well with other Python libraries and frameworks.

In summary, FastAPI offers a modern and efficient approach to building web APIs with Python, combining the best features from Flask and Starlette. It provides high performance, easy-to-use APIs, automatic data validation, and interactive documentation. FastAPI is an excellent choice for developers looking to build fast and reliable web APIs.

I hope this tutorial helps you get started with FastAPI!