Skip to main content

FastAPI-Intro

FastAPI Intro​

What is FastAPI?​

Topic cover:

  • Definition and purpose.
  • Why FastAPI is popular (speed, async support, type hints).
  • Comparison with Flask and Django.

Here’s a detailed and structured content section for “What is FastAPI?”:

1. Definition and Purpose​

  • FastAPI is a modern, high-performance web framework for building APIs with Python.
  • Built on Starlette (for web handling) and Pydantic (for data validation).
  • Designed to create RESTful APIs quickly and efficiently while leveraging Python’s type hints.
  • Speed:
    • One of the fastest Python frameworks thanks to asynchronous support and optimized performance.
  • Async Support:
    • Built-in support for async/await, enabling high concurrency and better scalability.
  • Type Hints:
    • Uses Python type hints for automatic validation and documentation.
    • Improves developer productivity and reduces bugs.
  • Automatic Documentation:
    • Generates OpenAPI and Swagger UI automatically for interactive API docs.

3. Comparison with Flask and Django​

FeatureFastAPIFlaskDjango
PerformanceVery high (async support)ModerateModerate
Async SupportBuilt-inRequires extra setupLimited
Type HintsFull supportMinimalMinimal
Best ForAPIs, microservicesSimple web apps, APIsFull-stack web apps
DocsAuto-generated (Swagger, ReDoc)Manual setupManual setup

Key Features​

Topic cover:

  • Automatic OpenAPI and Swagger UI.
  • Data validation with Pydantic.
  • Async support for high performance.

1. Automatic OpenAPI and Swagger UI​

  • OpenAPI Specification:
    • FastAPI automatically generates an OpenAPI schema for your API.
    • This schema describes all endpoints, request/response models, and data types.
  • Interactive Documentation:
    • Built-in Swagger UI at /docs for testing endpoints interactively.
    • ReDoc at /redoc for a clean, developer-friendly documentation view.
  • Benefit:
    • No manual setup required; documentation updates automatically as you add routes.

2. Data Validation with Pydantic​

  • Pydantic Models:

    • FastAPI uses Pydantic for data validation and serialization.
    • Define request and response schemas using Python classes and type hints.

  • Example:

    from pydantic import BaseModel

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

  • Advantages:

    • Automatic type checking.
    • Clear error messages for invalid data.
    • Converts input data to correct types (e.g., strings to numbers).

3. Async Support for High Performance​

  • Asynchronous Programming:
    • FastAPI supports async and await natively.
    • Enables handling thousands of requests concurrently without blocking.
  • Why it matters:
    • Ideal for I/O-bound operations (e.g., database queries, API calls).
    • Improves scalability and response time.
  • Example: 
    @app.get("/items")
    async def get_items():
        return {"items": ["item1", "item2"]}

Installation​

Python version requirements. Install FastAPI and Uvicorn:

pip install fastapi uvicorn

Hello World Example​

  1. Minimal FastAPI app

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello, FastAPI!"}
  1. Run with Uvicorn:
uvicorn main:app --reload

Routing Basics​

  • Path parameters.
  • Query parameters.
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):

Interactive Docs​

Topic cover:

  • Swagger UI (/docs).
  • ReDoc (/redoc).

Here’s a structured content section for “Interactive Docs” in FastAPI:

Interactive Docs​

1. Swagger UI (/docs)​

  • What is Swagger UI?
    • An interactive documentation interface automatically generated by FastAPI.
    • Allows developers to test API endpoints directly from the browser.
  • Features:
    • Displays all routes, methods, and request/response models.
    • Provides input fields for query parameters, path parameters, and request bodies.
    • Executes requests and shows real-time responses.
  • Access:

2. ReDoc (/redoc)​

  • What is ReDoc?
    • Another documentation interface generated by FastAPI using the OpenAPI schema.
    • Offers a clean, developer-friendly view of your API.
  • Features:
    • Organized and readable documentation.
    • Great for reference and API consumers.
  • Access:

Why These Matter​

  • No manual setup required.
  • Helps developers and testers understand and interact with APIs quickly.
  • Improves collaboration between backend and frontend teams.