FastAPI vs Django: Comparativo Completo | Python Brasil

from fastapi import FastAPI, HTTPException, Query
from pydantic import BaseModel, Field
from datetime import datetime

app = FastAPI(title="API de Produtos", version="1.0")

class ProdutoCreate(BaseModel):
    nome: str = Field(..., min_length=3, max_length=200)
    preco: float = Field(..., gt=0, description="Preço em reais")
    estoque: int = Field(default=0, ge=0)
    categorias: list[str] = Field(default_factory=list)

class ProdutoResponse(ProdutoCreate):
    id: int
    criado_em: datetime

    class Config:
        from_attributes = True

# Banco de dados simulado
produtos_db: dict[int, dict] = {}
next_id = 1

@app.post("/produtos", response_model=ProdutoResponse, status_code=201)
async def criar_produto(produto: ProdutoCreate):
    global next_id
    dados = produto.model_dump()
    dados["id"] = next_id
    dados["criado_em"] = datetime.now()
    produtos_db[next_id] = dados
    next_id += 1
    return dados

@app.get("/produtos", response_model=list[ProdutoResponse])
async def listar_produtos(
    skip: int = Query(0, ge=0),
    limit: int = Query(10, ge=1, le=100),
    categoria: str | None = None,
):
    resultados = list(produtos_db.values())
    if categoria:
        resultados = [p for p in resultados if categoria in p["categorias"]]
    return resultados[skip : skip + limit]

@app.get("/produtos/{produto_id}", response_model=ProdutoResponse)
async def buscar_produto(produto_id: int):
    if produto_id not in produtos_db:
        raise HTTPException(status_code=404, detail="Produto não encontrado")
    return produtos_db[produto_id]

# models.py
from django.db import models

class Produto(models.Model):
    nome = models.CharField(max_length=200)
    preco = models.DecimalField(max_digits=10, decimal_places=2)
    estoque = models.PositiveIntegerField(default=0)
    categorias = models.JSONField(default=list)
    criado_em = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.nome

# serializers.py
from rest_framework import serializers
from .models import Produto

class ProdutoSerializer(serializers.ModelSerializer):
    class Meta:
        model = Produto
        fields = "__all__"

    def validate_preco(self, value):
        if value <= 0:
            raise serializers.ValidationError("Preço deve ser positivo")
        return value

    def validate_nome(self, value):
        if len(value) < 3:
            raise serializers.ValidationError("Nome deve ter pelo menos 3 caracteres")
        return value

# viewsets.py
from rest_framework import viewsets, filters
from django_filters.rest_framework import DjangoFilterBackend
from .models import Produto
from .serializers import ProdutoSerializer

class ProdutoViewSet(viewsets.ModelViewSet):
    queryset = Produto.objects.all()
    serializer_class = ProdutoSerializer
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_fields = ["categorias"]
    search_fields = ["nome"]
    ordering = ["-criado_em"]

# FastAPI — async nativo com alto throughput
import httpx
from fastapi import FastAPI

app = FastAPI()

@app.get("/dados-externos")
async def buscar_dados():
    async with httpx.AsyncClient() as client:
        # Requisições paralelas — sem bloquear
        respostas = await asyncio.gather(
            client.get("https://api.servico1.com/dados"),
            client.get("https://api.servico2.com/dados"),
            client.get("https://api.servico3.com/dados"),
        )
    return {
        "servico1": respostas[0].json(),
        "servico2": respostas[1].json(),
        "servico3": respostas[2].json(),
    }

# Django — async views com limitações
from django.http import JsonResponse
from asgiref.sync import sync_to_async

async def buscar_dados(request):
    # ORM precisa de sync_to_async wrapper
    produtos = await sync_to_async(list)(
        Produto.objects.filter(ativo=True)[:10]
    )
    return JsonResponse({"produtos": [p.nome for p in produtos]})

from pydantic import BaseModel, Field, field_validator
import re

class UsuarioCreate(BaseModel):
    nome: str = Field(..., min_length=2, max_length=100)
    email: str = Field(..., pattern=r"^[\w\.-]+@[\w\.-]+\.\w+$")
    cpf: str = Field(..., min_length=11, max_length=14)
    salario: float = Field(..., gt=0)

    @field_validator("cpf")
    @classmethod
    def validar_cpf(cls, v):
        cpf = re.sub(r"[^\d]", "", v)
        if len(cpf) != 11:
            raise ValueError("CPF deve ter 11 dígitos")
        return cpf