FastAPI Tutorial

FastAPI is a modern, high-performance Python web framework for building APIs. It's one of the fastest Python frameworks available, with automatic OpenAPI docs and full async support.

Why FastAPI?

Speed – on par with NodeJS and Go for async workloads.
Automatic docs – Swagger UI and ReDoc generated from your code.
Type safety – Pydantic validates all inputs and outputs.
Async first – built on Starlette; supports async/await natively.
Dependency injection – clean, testable, composable.

💡

FastAPI vs Django: Use FastAPI for pure API backends, microservices, ML model serving. Use Django when you need the full stack (admin, templates, auth system).

Python – FastAPI Simulation

# Simulating FastAPI-style routing and Pydantic validation
from dataclasses import dataclass, field
from typing import Optional, List
import json

# Simulate Pydantic model with dataclass
@dataclass
class User:
    name:  str
    email: str
    age:   int
    roles: List[str] = field(default_factory=lambda: ["user"])

    def dict(self):
        return {"name": self.name, "email": self.email,
                "age": self.age, "roles": self.roles}

# Simulate route decorator
routes = {}
def get(path):
    def decorator(fn):
        routes[("GET", path)] = fn
        return fn
    return decorator

def post(path):
    def decorator(fn):
        routes[("POST", path)] = fn
        return fn
    return decorator

users_db = []

@get("/users")
def list_users():
    return [u.dict() for u in users_db]

@post("/users")
def create_user(user: User):
    users_db.append(user)
    return {"message": "created", "user": user.dict()}

# Simulate requests
u1 = User("Alice", "alice@ex.com", 30, ["admin"])
u2 = User("Bob",   "bob@ex.com",   25)

print("POST /users:", json.dumps(routes[("POST","/users")](u1), indent=2))
routes[("POST","/users")](u2)
print("\nGET /users:", json.dumps(routes[("GET","/users")](), indent=2))

Try It – FastAPI Concepts

Code Editor

from dataclasses import dataclass, field
from typing import List
import json

@dataclass
class User:
    name:  str
    email: str
    age:   int
    roles: List[str] = field(default_factory=lambda: ["user"])
    
    def dict(self):
        return {"name": self.name, "email": self.email,
                "age": self.age, "roles": self.roles}

# Simulate endpoint validation
def validate_user(data: dict):
    errors = []
    if not data.get("name"): errors.append("name required")
    if "@" not in data.get("email", ""): errors.append("invalid email")
    if not isinstance(data.get("age"), int) or data["age"] < 0:
        errors.append("age must be positive int")
    return errors

# Test validation
valid   = {"name": "Alice", "email": "alice@ex.com", "age": 30}
invalid = {"name": "",      "email": "not-an-email",  "age": -5}

print("Valid payload errors:",   validate_user(valid))
print("Invalid payload errors:", validate_user(invalid))

# Create and list users
db = [User("Alice","alice@ex.com",30,["admin"]),
      User("Bob","bob@ex.com",25)]

print("\nAll users:")
for u in db:
    print(json.dumps(u.dict(), indent=2))

Output

Click ▶ Run…

Quick Quiz

What library does FastAPI use for data validation?

Async / Await in FastAPI

FastAPI is built for async programming. Understanding async/await is key to getting maximum performance.

Why Async?

When your endpoint does I/O (database query, HTTP call, file read), async lets Python serve other requests while waiting — rather than blocking the entire thread.

Python – Async Demo

import asyncio
import time

# Sync — blocks each time
def sync_fetch(url):
    time.sleep(0.1)  # simulate I/O
    return f"data from {url}"

# Async — yields control during I/O
async def async_fetch(url):
    await asyncio.sleep(0.1)   # non-blocking
    return f"data from {url}"

async def main():
    urls = [f"https://api.example.com/item/{i}" for i in range(5)]
    
    # Sequential (like sync)
    start = time.perf_counter()
    for url in urls:
        await async_fetch(url)
    print(f"Sequential: {time.perf_counter()-start:.2f}s")
    
    # Concurrent (true async benefit)
    start = time.perf_counter()
    results = await asyncio.gather(*[async_fetch(u) for u in urls])
    print(f"Concurrent: {time.perf_counter()-start:.2f}s")
    print(f"Got {len(results)} results")

asyncio.run(main())

Try It – Async/Await

Code Editor

Output

Click ▶ Run…

FastAPI Coding Labs

10 labs covering CRUD, validation, JWT auth, background tasks, and more.

Lab 1 – CRUD API Simulation

FastAPI CRUD Lab

Code Editor

import json
from dataclasses import dataclass, asdict
from typing import Optional

@dataclass
class Item:
    id:          int
    name:        str
    price:       float
    description: Optional[str] = None

# In-memory DB
db: dict[int, Item] = {}
_next_id = 1

def create_item(name, price, description=None):
    global _next_id
    item = Item(_next_id, name, price, description)
    db[_next_id] = item
    _next_id += 1
    return item

def get_item(item_id):
    return db.get(item_id)

def list_items(skip=0, limit=10):
    return list(db.values())[skip:skip+limit]

def update_item(item_id, **kwargs):
    if item_id not in db: return None
    for k, v in kwargs.items():
        if hasattr(db[item_id], k): setattr(db[item_id], k, v)
    return db[item_id]

def delete_item(item_id):
    return db.pop(item_id, None)

# Test all CRUD operations
print("=== CREATE ===")
i1 = create_item("Laptop", 999.99, "High-performance laptop")
i2 = create_item("Mouse",  29.99)
i3 = create_item("Keyboard", 79.99, "Mechanical keyboard")
for i in list_items(): print(f"  {asdict(i)}")

print("\n=== READ id=1 ===")
print(f"  {asdict(get_item(1))}")

print("\n=== UPDATE id=2 ===")
updated = update_item(2, price=24.99, description="Wireless mouse")
print(f"  {asdict(updated)}")

print("\n=== DELETE id=3 ===")
delete_item(3)
print(f"  Remaining items: {len(list_items())}")

Output

Click ▶ Run…

Lab 2 – JWT Token Simulation

JWT Auth Lab

Code Editor

import base64, json, hmac, hashlib, time

SECRET = "skillfort-secret-key"

def b64url_encode(data):
    if isinstance(data, dict): data = json.dumps(data, separators=(',', ':'))
    return base64.urlsafe_b64encode(data.encode()).rstrip(b'=').decode()

def create_token(payload: dict, expires_in=3600):
    header  = b64url_encode({"alg": "HS256", "typ": "JWT"})
    payload = payload.copy()
    payload["exp"] = int(time.time()) + expires_in
    payload_b64 = b64url_encode(payload)
    signature = hmac.new(
        SECRET.encode(),
        f"{header}.{payload_b64}".encode(),
        hashlib.sha256
    ).hexdigest()
    return f"{header}.{payload_b64}.{signature}"

def verify_token(token):
    try:
        header, payload_b64, sig = token.split(".")
        # Pad base64
        padding = 4 - len(payload_b64) % 4
        payload_b64_padded = payload_b64 + "=" * padding
        payload = json.loads(base64.urlsafe_b64decode(payload_b64_padded))
        if payload.get("exp", 0) < time.time():
            return None, "Token expired"
        expected_sig = hmac.new(
            SECRET.encode(),
            f"{header}.{payload_b64}".encode(),
            hashlib.sha256
        ).hexdigest()
        if sig != expected_sig:
            return None, "Invalid signature"
        return payload, None
    except Exception as e:
        return None, str(e)

# Test
token = create_token({"sub": "alice", "role": "admin"})
print(f"Token: {token[:60]}...")

payload, err = verify_token(token)
print(f"Valid token payload: {payload}")

fake_token = token[:-5] + "XXXXX"
payload2, err2 = verify_token(fake_token)
print(f"Tampered token: payload={payload2}, error={err2}")

Output

Click ▶ Run…

←

Django Tutorial

Next Course

Flask Tutorial

→