Why Start Using FastAPI for Python?

Python is the first choice of developers to develop lightweight web apps. It got brilliant documentation and a simple but fast interface. In this post, I will talk about API for Python, and we will see why to use it and the benefits of fast API Python.

FastAPI is a new web framework for Python. It's the latest version of previous frameworks and has many fixes and features.

Before getting ahead, you should know that Python is the best language for machine learning. If you are into it, it's time to go; hire Python developers.

Let's look at the top reasons to use FastAPI for Python.

Easy To Use and Perfect Interface

A framework, whether a web or any other, must be easy to use, and developers should feel free. Here comes the API for Python; it's like Flask and comes with a balance of usability and other things.

In FastAPI, defining the endpoint:

from fastapi import FastAPI
from pydantic import BaseModel


class User(BaseModel):
 email: str
 password: str


app = FastAPI()


@app.post("/login")
def login(user: User):
 # ...
 # do some magic
 # ...
 return {"msg": "login successful"}

It uses Pydantic, a Python library that looks simple but has lots going on in the background. FastAPI validates the input here, and if the request is incorrect, fast API python will return it with an error code. But it will not break to internal server error 500

Async

Async was a disadvantage in Python WSGI web frameworks that it was unable to handle async. Now, fast API Python is taking full advantage of it. Now it's accessible by just declaring endpoints as async.

@app.post("/")
async def endpoint():
 # ...
 # call async functions here with `await`
 # ...
 return {"msg": "FastAPI is awesome!"}

Dependency Injections

With fast API python, it's now easy to manage dependencies. Using an inbuilt injection system to handle dependencies in your endpoints is good.

from fastapi import FastAPI, Depends
from pydantic import BaseModel


class Comment(BaseModel):
 username: str
 content: str


app = FastAPI()


database = {
 "articles": {
 1: {
 "title": "Top 3 Reasons to Start Using FastAPI Now",
 "comments": []
 }
 }
}


def get_database():
 return database


@app.post("/articles/{article_id}/comments")
def post_comment(article_id: int, comment: Comment, database = Depends(get_database)):
 database["articles"][article_id]["comments"].append(comment)
 return {"msg": "comment posted!"}

At the runtime, when the endpoint is called, Fast API automatically evaluates the get_database function. Developers are free to use any return value as they wish.

Easy Integration with Databases

Whether you use SQL, MongoDB, or any other database, FastAPI will not force you to build your app with it. You already know how painful it is to use MongoDB with Django. Adding a database to it is simple.

from fastapi import FastAPI, Depends

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker


engine = create_engine("sqlite:///./database.db")
Session = sessionmaker(bind=engine)


def get_db():
 return Session()


app = FastAPI()


@app.get("/")
def an_endpoint_using_sql(db = Depends(get_db)):
 # ...
 # do some SQLAlchemy
 # ...
 return {"msg": "an exceptionally successful operation!"}

GraphQL Support

REST can be challenging when working with a complex data model, but GraphQL shines when your front end needs to update the schema for an endpoint. You don't have to install it; it is natively available.

Great Documentation

FastAPI is a great framework, but this or any other framework can not shine without good documentation. I know Flask and Django have good ones, but FastAPI is par.

Typed Python

FastAPI uses Python 3.6 type declarations that allow you to specify a variable. FastAPI makes good use of it and provides friendly editor support, and autocomplete works well.

Sample code using typed decelerations

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.get("/")
def read_root(item: Item):
    return item. Price

We went from name to name: str. The result is below.

Validation

Thanks to Pydantic for integrating validation into FastAPI. Python developers can also validate standard Python types with custom field validations.

JSON objects (dict)
JSON array (list)
URL
Email
UUID
String (str) with min and max lengths
Numbers (int, float) with min and max values
and more

Performance

FastAPI is fast, even faster than Flask. Why? It's because it is built over ASGI than WSGI.

Security and Authentication

This is an essential part of any API. We already include some repeated codes, so why don't we add them to the API? That saves time. FastAPI does it. The library supports the following:

OAuth2 (JWT tokens)
API keys in headers, query params, or cookies
HTTP basic

Final Words

FastAPI is a relatively new framework that follows Flask's basic approach while providing critical features that make it easier to work with and perform well. It is an excellent option for your next API project! Is your project complex? Why not hire Python developers? Comment Are you using FastAPI? If yes, how's your experience?

Mayank Ranjan's Blog