CS Fundamentals Trainer · Guias

Python para dados e web: contêineres, pandas, WSGI e ASGI

Qual contêiner embutido serve ao trabalho e o que ele custa, como o pandas consegue sua velocidade e onde surpreende, e como uma requisição web chega ao seu código por WSGI ou ASGI. Com resultados medidos: buscas em dict, deque contra lista, registros contra colunas, pandas vetorizado contra em laço, e 20 requisições concorrentes em servidores síncronos, com threads e assíncronos.

24 min de leitura

Grande parte do trabalho real em Python cai em um de dois lugares: processar dados (listas de registros, tabelas, arquivos) ou atender requisições (uma API ou um site). Os dois têm o mesmo formato de problema: escolher estruturas e ferramentas cujos custos combinem com o tamanho do trabalho, e saber qual camada está de fato fazendo o serviço. Este guia cobre os contêineres embutidos e o que eles custam, como o pandas consegue sua velocidade (e onde ele surpreende) e como uma requisição chega ao seu código Python por WSGI ou ASGI, com os números de scripts rodados no CPython 3.13 (no apêndice). Ele se apoia em como o Python funciona e em desempenho e concorrência em Python.

Versões usadas: pandas 3.0.5, NumPy 2.5.3, Flask 3.1.3, Pydantic 2.13.5, Starlette 1.7.0 e uvicorn 0.54.0, todas como instaladas no ambiente. Django e FastAPI não estavam instalados, então o que digo sobre eles vem da documentação e não de uma execução. A máquina tinha dois núcleos de CPU e os tempos variam; o que importa é o formato dos resultados.

1. Os contêineres embutidos e seus custos

ContêinerBom paraCustos
listitens ordenados, acrescentar no fim, índicex in l varre (O(n)); inserir ou remover no início é O(n)
tupleregistros fixos, chaves de dicionárioimutável; um pouco menor que uma lista
dictbusca por chave, registros, contagembusca por hash; preserva a ordem de inserção; pesado em memória
setpertinência, remoção de duplicatas, álgebra de conjuntosbusca por hash; sem ordem; pesado em memória
collections.dequefilas (rápido nas duas pontas)indexação lenta no meio
heapqo menor item primeiro, top-kO(log n) para inserir e remover

Dicionários

Um dicionário é uma tabela hash: transforma uma chave em um índice de posição, então o custo de uma busca não depende do número de entradas. Medi a busca da última chave em dicionários de 1.000, 100.000 e 1.000.000 de entradas: 55 ns, 45 ns e 47 ns, constante, dentro do ruído. Desde o Python 3.7 um dicionário também mantém a ordem de inserção como parte da linguagem: depois de inserir b, a, c e apagar e acrescentar a de novo, as chaves foram ['b', 'c', 'a'].

O preço é a memória. Um dicionário se redimensiona em degraus; o próprio contêiner passou de 224 bytes para 352 na 6ª entrada, para 632 na 11ª e para 1.168 na 22ª. Em escala, um dicionário de um milhão de chaves inteiras ocupou cerca de 42 MB para a tabela, um set com as mesmas chaves cerca de 34 MB e uma lista de um milhão de itens cerca de 8 MB (todos sem contar os próprios objetos inteiros). Quando você tem um milhão de itens e só precisa iterar, uma lista ou um gerador é muito mais barato que um dicionário ou um set.

Duas regras que causam bugs reais: as chaves precisam ser hasheáveis e seu hash não pode mudar (então listas não podem ser chaves; veja como o Python funciona), e você não pode mudar o tamanho de um dicionário enquanto itera sobre ele: acrescentar chaves dentro de for k in d levantou RuntimeError: dictionary changed size during iteration. Itere sobre list(d) (uma cópia instantânea) quando precisar modificá-lo.

Listas como filas

Uma lista é um array dinâmico: acrescentar é barato, mas remover do início desloca todos os outros itens. Removi 20.000 itens do início de uma lista de 100.000 itens: 329 ms. O mesmo com um collections.deque usando popleft(): 0,7 ms, cerca de 470 vezes mais rápido. Use um deque para filas e busca em largura, e queue.Queue entre threads.

Registros contra colunas

O formato dos dados muda a memória. Guardei 200.000 registros de três campos de duas maneiras:

LayoutMemória
uma lista de 200.000 dicionários ({"id":…, "name":…, "score":…})cerca de 50 MB
um dicionário de três listas (colunas)cerca de 16 MB

Cada dicionário de registro paga pela própria tabela. Guardar os dados por coluna é menor e mais rápido de varrer, que é exatamente o layout que o pandas e o NumPy usam (próximas seções). Para muitos registros pequenos em Python puro, use tuplas, NamedTuple ou uma dataclass(slots=True) (veja classes e tipagem).

Outras ferramentas úteis: collections.Counter para contar (Counter(["a", "b", "a"]).most_common(1) deu [('a', 2)]), defaultdict para evitar verificações de existência, sorted(key=...) (estável: chaves iguais mantêm a ordem original) e bisect para listas ordenadas.

2. Dados com pandas

O pandas guarda uma tabela como colunas de arrays do NumPy. Operações sobre uma coluna inteira rodam em código compilado sobre memória contígua, e é daí que vem a velocidade. O custo é que o código escrito como laços comuns de Python a perde.

Vetorize

Calculei amount * 1.2 para 20.000 linhas de quatro maneiras:

MétodoTempo
iterrows() (um laço Python que monta uma Series para cada linha)410 ms
itertuples() (um laço Python sobre tuplas)14 ms
Series.apply(lambda v: v * 1.2) (chama uma função Python por valor)2,7 ms
df["amount"] * 1.2 (vetorizado)0,06 ms

É um fator de cerca de 6.800 entre o mais lento e o mais rápido. A versão vetorizada sobre as 200.000 linhas levou 0,31 ms. Regras: nunca percorra linhas para calcular uma coluna; use aritmética de colunas, np.where, os acessores .str e .dt, groupby e merge; e quando você realmente precisa de Python por linha, prefira itertuples a iterrows. Um groupby("country")["amount"].sum() sobre 200.000 linhas levou cerca de 15 ms, e agrupou 40.000 linhas por país em cinco totais.

Dtypes e memória

Toda coluna tem um dtype, e a escolha importa:

Cópias, visões e valores ausentes

A confusão clássica do pandas é saber se mudar uma tabela derivada muda a original. No pandas 3, o comportamento é copy-on-write: qualquer tabela ou coluna derivada de outra se comporta como uma cópia independente quando você a modifica. Filtrei uma tabela (b = a[a["x"] > 1]) e escrevi em b; a continuou [1, 2, 3]. O mesmo valeu quando mudei uma Series tirada da original, e um .copy() explícito obviamente a deixou intacta. Em versões mais antigas do pandas, algumas dessas operações modificavam a original ou levantavam SettingWithCopyWarning; confira a sua versão e escreva código que não dependa da diferença (atribua resultados com df = df.assign(...) ou df.loc[mask, "col"] = value na tabela que é sua).

Dados ausentes têm regras próprias:

Quando o pandas é lento, quase sempre é porque o trabalho acontece por linha em Python, ou porque o tipo de dado ou o formato do arquivo forçou uma cópia. Faça o profile primeiro (guia de desempenho).

3. Como uma requisição web chega ao seu código

Uma aplicação web é uma função Python (ou algumas) que um servidor chama com uma descrição da requisição. O Python padronizou a interface duas vezes.

WSGI: uma chamada por requisição, síncrona

O WSGI (PEP 3333) diz que uma aplicação é um callable que recebe environ (um dicionário que descreve a requisição) e start_response, e retorna o corpo como um iterável de bytes. Minha aplicação inteira era:

def wsgi_app(environ, start_response):
    body = f"wsgi {environ['REQUEST_METHOD']} {environ['PATH_INFO']}".encode()
    start_response("200 OK", [("Content-Type", "text/plain"),
                              ("Content-Length", str(len(body)))])
    return [body]

Frameworks como Flask e Django são aplicações WSGI por baixo (o Django também pode rodar como ASGI). Chamei o wsgi_app de uma aplicação Flask à mão, com um environ feito à mão para POST /orders, e obtive 201 CREATED e o corpo JSON: o framework é uma camada conveniente sobre exatamente essa chamada. Servidores WSGI (gunicorn, uWSGI, waitress) rodam muitas cópias dela em processos e threads.

ASGI: assíncrono, e mais que HTTP

O ASGI é o sucessor assíncrono: uma aplicação é async def app(scope, receive, send); ela pode dar await entre receber e enviar, e a mesma interface trata WebSockets e conexões de longa duração. Starlette e FastAPI (construído sobre Starlette e Pydantic) são frameworks ASGI; uvicorn e hypercorn são servidores ASGI.

O que isso significa para a concorrência

Servi um endpoint que espera 0,1 s (como uma chamada lenta ao banco de dados) por quatro servidores e enviei 20 requisições de uma vez a partir de 20 threads cliente:

Servidor1 requisição20 de uma vez
WSGI, uma requisição por vez (wsgiref)103 ms2,34 s
WSGI, uma thread por requisição103 ms0,11 s
ASGI, handler assíncrono (uvicorn)103 ms0,12 s
ASGI, handler que chama um time.sleep bloqueante102 ms2,02 s

Nenhum dos estilos deixa os handlers pesados de CPU mais rápidos. Tire o cálculo pesado do caminho da requisição (uma fila de tarefas e um processo de trabalho, veja filas de mensagens) ou rode mais processos de trabalho.

Frameworks comparados

FlaskDjangoFastAPI / Starlette
InterfaceWSGIWSGI e ASGIASGI
Estilomicro: roteamento e templates, você escolhe o restotudo incluído: ORM, migrações, admin, autenticaçãoendpoints tipados, validação automática de requisições e documentação OpenAPI (FastAPI)
Escolha quandoserviços pequenos, controle total, aprendizadosites com muito conteúdo, interfaces administrativas, equipes que querem convençõesAPIs com muitas chamadas assíncronas, entrada e saída fortemente tipadas

(Django e FastAPI são descritos a partir da documentação; só Flask e Starlette rodaram aqui.) A escolha importa menos que os hábitos abaixo, que valem para todos eles.

4. Hábitos para handlers web

Valide a entrada na fronteira. Os dados da requisição não são confiáveis (veja segurança de aplicações web). O Pydantic (usado pelo FastAPI e utilizável em qualquer lugar) descreve o formato uma vez:

class NewOrder(BaseModel):
    email: str
    quantity: int = Field(gt=0, le=100)
    @field_validator("email") ...      # custom rule: must contain "@", lowercased

Com um handler Flask chamando NewOrder.model_validate(...), um corpo válido recebeu 201 e {'email': 'a@b.com', 'quantity': 3} (em minúsculas pela regra), e {"email": "nope", "quantity": 0} recebeu 422 com uma lista que nomeava os dois campos inválidos (Value error, must contain @ e Input should be greater than 0). Note que, por padrão, o Pydantic converte: a string "5" virou o inteiro 5; use o modo estrito onde isso não for aceitável. O roteamento do framework também valida: /orders/<int:order_id> retornou 404 para /orders/abc antes de o meu código rodar, um caminho ausente deu 404 e o método errado deu 405. Use os códigos de status do guia de API REST.

Não guarde estado de requisição em globais de módulo. Um contador global existe uma vez por processo. Rodei uma pequena aplicação sob o uvicorn com dois processos de trabalho e enviei 12 requisições concorrentes: cada processo contou a sua parte, então os contadores chegaram a cerca de 6 cada um, nunca a 12 (uma execução se dividiu em 7 e 5). Tudo o que é compartilhado entre workers (sessões, caches, contadores de limite de taxa, estado de tarefas) pertence a um banco de dados ou a um armazenamento compartilhado como o Redis, e o mesmo vale quando você escala para várias máquinas (balanceamento de carga).

Cuide das conexões. Cada processo de trabalho tem seu próprio pool de conexões com o banco, então o total de conexões = workers × tamanho do pool; um banco de dados aceita só um certo número. Use um pool, libere as conexões logo (with) e ponha timeouts em tudo o que espera (padrões de resiliência).

Mantenha os handlers curtos. Faça a parte rápida na requisição e enfileire o resto; retorne 202 para tarefas longas. Evite carregar uma tabela inteira no pandas dentro de uma requisição: agregue no banco de dados.

Formato da implantação. Rode o servidor da aplicação (gunicorn ou uvicorn) atrás de um proxy reverso como o nginx ou um balanceador de carga na nuvem, que cuida de TLS, clientes lentos, arquivos estáticos e buffering (TLS e HTTPS, DNS, HTTP/2, HTTP/3 e CDNs). Nunca exponha o servidor de desenvolvimento do framework à internet. Fixe as dependências (guia de empacotamento) e registre as requisições com um id para que uma falha possa ser rastreada (observabilidade).

5. Erros comuns

6. Perguntas que os entrevistadores gostam de fazer

"Como um dicionário funciona, e qual é a complexidade da busca?"

Uma tabela hash: o hash da chave escolhe uma posição, então busca, inserção e remoção são O(1) em média e não ficam mais lentas com o tamanho. As chaves precisam ser hasheáveis; a ordem de inserção é preservada; o custo de memória é alto.

"Por que um laço sobre um DataFrame é lento?"

Cada iteração executa bytecode Python e cria um objeto Python por linha, ignorando as operações compiladas sobre colunas. Use operações vetorizadas (df["a"] * 1.2, groupby, merge), que rodam em C sobre arrays.

"Como você processaria um arquivo maior que a memória?"

Faça streaming ou divida em blocos (chunksize, geradores), carregue só as colunas necessárias, use dtypes compactos, empurre a agregação para um banco de dados ou use um motor colunar (Parquet com DuckDB ou Polars).

"Qual é a diferença entre WSGI e ASGI?"

O WSGI é uma interface síncrona de uma chamada por requisição; o ASGI é assíncrono, suporta await e também WebSockets e outros protocolos de longa duração. Flask e Django são WSGI (o Django também ASGI); Starlette e FastAPI são ASGI.

"Um handler está lento sob carga. O que você verifica?"

Faça o profile de onde o tempo vai; procure chamadas bloqueantes em código assíncrono, índices ausentes e consultas N+1, esgotamento do pool de conexões, poucos workers e trabalho limitado pela CPU que pertence a uma fila.

"Por que uma variável global em uma aplicação web pode dar resultados inconsistentes?"

Cada processo de trabalho tem sua própria cópia, então o estado diverge entre os processos (meus dois workers contaram cerca de metade das requisições cada um). Use armazenamento compartilhado.

"Flask, Django ou FastAPI?"

Flask para serviços pequenos com liberdade de escolha; Django para sites completos com ORM, admin e convenções; FastAPI para APIs assíncronas tipadas com validação e documentação automáticas. Os fundamentos (semântica HTTP, validação, pools, filas) são os mesmos.

7. Coisas a mencionar em uma entrevista

Resumo rápido

Apêndice: o código dos experimentos

Python 3.13 em uma máquina de dois núcleos, com pandas 3.0, NumPy 2.5, Flask 3.1, Pydantic 2.13, Starlette e uvicorn. Rode os arquivos a partir de uma pasta com python3 file.py; o teste de carga inicia e encerra seus próprios servidores nas portas locais 8101–8104 e a demonstração de estado usa a porta 8110. Os tempos variam conforme a máquina; os resultados do pandas, especialmente o comportamento de cópia, dependem da versão.

containers.py: crescimento e busca em dicionários, deque contra lista, e registros contra colunas:

import sys, timeit, random, collections
# dict growth and cost
d = {}
sizes = []
last = None
for i in range(40):
    d[i] = i
    s = sys.getsizeof(d)
    if s != last: sizes.append((len(d), s)); last = s
print("dict resizes (len, bytes):", sizes)
print("1M-entry dict:", f"{sys.getsizeof({i: i for i in range(1_000_000)})/1e6:.0f} MB", "| list of 1M:", f"{sys.getsizeof(list(range(1_000_000)))/1e6:.0f} MB", "| set of 1M:", f"{sys.getsizeof(set(range(1_000_000)))/1e6:.0f} MB (containers only, not the ints)")
# insertion order guaranteed
d = {}; d["b"] = 1; d["a"] = 2; d["c"] = 3; del d["a"]; d["a"] = 9
print("insertion order kept:", list(d))
# lookup cost grows slowly with size
for n in (1_000, 100_000, 1_000_000):
    dd = {i: i for i in range(n)}; k = n - 1
    print(f"dict lookup, {n:>9,} keys: {timeit.timeit(lambda: dd[k], number=2_000_000)/2e6*1e9:.0f} ns")
# modifying while iterating
d = {i: i for i in range(5)}
try:
    for k in d: d[k + 10] = 1
except RuntimeError as e: print("RuntimeError:", e)
# list as queue vs deque
n = 100_000
l = list(range(n)); dq = collections.deque(range(n))
t_l = timeit.timeit(lambda: [l.pop(0) for _ in range(20_000)], number=1)
t_d = timeit.timeit(lambda: [dq.popleft() for _ in range(20_000)], number=1)
print(f"20,000 pops from the front of a {n:,}-item list {t_l*1e3:.0f} ms | deque {t_d*1e3:.1f} ms")
# Counter / defaultdict / sorted with key
words = [random.choice("abcdefghij") * 3 for _ in range(10)]
print(collections.Counter(["a", "b", "a"]).most_common(1), "| sorted stable:", sorted([("b", 1), ("a", 1), ("c", 0)], key=lambda t: t[1]))
# dict vs list of dicts memory for records
rows = 200_000
import tracemalloc
tracemalloc.start(); rec = [{"id": i, "name": "x", "score": i * 0.5} for i in range(rows)]; a, _ = tracemalloc.get_traced_memory(); tracemalloc.stop()
tracemalloc.start(); cols = {"id": list(range(rows)), "name": ["x"] * rows, "score": [i * 0.5 for i in range(rows)]}; b, _ = tracemalloc.get_traced_memory(); tracemalloc.stop()
print(f"{rows:,} records: list of dicts {a/1e6:.0f} MB | dict of columns {b/1e6:.0f} MB")

pandas_demo.py: vetorização, dtypes e memória, groupby, copy-on-write, dados ausentes e leitura em blocos:

import time, timeit, warnings
import numpy as np, pandas as pd
print("pandas", pd.__version__, "numpy", np.__version__)
rng = np.random.default_rng(0)
n = 200_000
df = pd.DataFrame({"user": rng.integers(0, 1000, n), "country": rng.choice(["BR", "DE", "US", "FR", "JP"], n), "amount": rng.random(n) * 100})

# 1. three ways to compute a new column
def t(f, k=3): return min(timeit.repeat(f, number=1, repeat=k))
rows = df.head(20_000)
loop = t(lambda: [r.amount * 1.2 for r in rows.itertuples()])
iterrows = t(lambda: [r["amount"] * 1.2 for _, r in rows.iterrows()], 1)
apply_ = t(lambda: rows["amount"].apply(lambda v: v * 1.2))
vec = t(lambda: rows["amount"] * 1.2)
print(f"20,000 rows -> iterrows {iterrows*1e3:.0f} ms | itertuples {loop*1e3:.0f} ms | apply {apply_*1e3:.1f} ms | vectorised {vec*1e3:.2f} ms")
print(f"200,000 rows vectorised: {t(lambda: df['amount'] * 1.2)*1e3:.2f} ms")

# 2. dtypes and memory
print("memory MB, object/str country:", round(df.memory_usage(deep=True)["country"]/1e6, 2), end=" | ")
cat = df["country"].astype("category"); print("category:", round(cat.memory_usage(deep=True)/1e6, 2), "| dtype was:", df["country"].dtype)
small = df["user"].astype("int16"); print("user int64:", round(df["user"].memory_usage(deep=True)/1e6, 2), "MB -> int16:", round(small.memory_usage(deep=True)/1e6, 2), "MB")

# 3. groupby, and the sort/merge costs
g = t(lambda: df.groupby("country")["amount"].sum())
print(f"groupby sum over {n:,} rows: {g*1e3:.1f} ms")
print(df.groupby("country")["amount"].agg(["count", "sum"]).round(1).sort_index().to_string())

# 4. copy semantics (Copy-on-Write is the default in pandas 3)
a = pd.DataFrame({"x": [1, 2, 3]})
b = a[a["x"] > 1]
b.loc[:, "x"] = 99
print("original after changing a filtered copy:", a["x"].tolist())
c = a["x"]; c.iloc[0] = -1
print("original after changing a Series taken from it:", a["x"].tolist())
a2 = a.copy(); a2.loc[0, "x"] = 7; print("explicit copy leaves original:", a["x"].tolist())

# 5. NaN and missing data
s = pd.Series([1.0, np.nan, 3.0]); print("NaN == NaN:", np.nan == np.nan, "| mean skips NaN:", s.mean(), "| sum of ints with None -> dtype:", pd.Series([1, None, 3]).dtype)
print("int column with a missing value becomes:", pd.Series([1, 2, None]).dtype, "| nullable Int64:", pd.Series([1, 2, None], dtype="Int64").dtype)

# 6. float money
print("0.1+0.2 sum in pandas:", pd.Series([0.1, 0.2]).sum() == 0.3, "| round-trip cents as ints:", (pd.Series([10, 20]).sum() == 30))

# 7. reading a big CSV in chunks
import io
csv = "id,v\n" + "\n".join(f"{i},{i%7}" for i in range(100_000))
total = 0
for chunk in pd.read_csv(io.StringIO(csv), chunksize=25_000): total += chunk["v"].sum()
print("chunked sum equals whole:", total == pd.read_csv(io.StringIO(csv))["v"].sum())

apps.py: o mesmo endpoint lento como aplicações WSGI e ASGI:

"""The same endpoint (sleeps 0.1 s, like a slow database call) as WSGI and ASGI apps."""
import asyncio, time

def wsgi_app(environ, start_response):          # WSGI: a plain function called once per request
    time.sleep(0.1)
    body = f"wsgi {environ['REQUEST_METHOD']} {environ['PATH_INFO']}".encode()
    start_response("200 OK", [("Content-Type", "text/plain"), ("Content-Length", str(len(body)))])
    return [body]

async def asgi_async(scope, receive, send):      # ASGI: an async function with three arguments
    assert scope["type"] == "http"
    await asyncio.sleep(0.1)                     # waits without blocking the event loop
    await send({"type": "http.response.start", "status": 200, "headers": [(b"content-type", b"text/plain")]})
    await send({"type": "http.response.body", "body": f"asgi {scope['method']} {scope['path']}".encode()})

async def asgi_blocking(scope, receive, send):   # the classic mistake: a blocking call inside async code
    time.sleep(0.1)
    await send({"type": "http.response.start", "status": 200, "headers": [(b"content-type", b"text/plain")]})
    await send({"type": "http.response.body", "body": b"blocking"})

serve_wsgiref.py: a aplicação WSGI em um servidor de uma requisição por vez e em um com threads:

import sys
from socketserver import ThreadingMixIn
from wsgiref.simple_server import make_server, WSGIServer, WSGIRequestHandler
from apps import wsgi_app
class Quiet(WSGIRequestHandler):
    def log_message(self, *a): pass
class Threaded(ThreadingMixIn, WSGIServer): daemon_threads = True
port, threaded = int(sys.argv[1]), sys.argv[2] == "threaded"
make_server("127.0.0.1", port, wsgi_app, server_class=Threaded if threaded else WSGIServer, handler_class=Quiet).serve_forever()

loadtest.py: inicia os quatro servidores um a um e envia 20 requisições simultâneas a cada um:

import subprocess, sys, time, urllib.request, os
from concurrent.futures import ThreadPoolExecutor
def wait(port):
    for _ in range(100):
        try: urllib.request.urlopen(f"http://127.0.0.1:{port}/ping", timeout=1).read(); return
        except Exception: time.sleep(0.1)
    raise SystemExit(f"server on {port} did not start")
def burst(port, n=20):
    t = time.perf_counter()
    with ThreadPoolExecutor(n) as ex:
        res = list(ex.map(lambda i: urllib.request.urlopen(f"http://127.0.0.1:{port}/item/{i}", timeout=30).status, range(n)))
    return time.perf_counter() - t, set(res)
servers = [
    ("WSGI, one request at a time (wsgiref)", [sys.executable, "serve_wsgiref.py", "8101", "single"], 8101),
    ("WSGI, one thread per request", [sys.executable, "serve_wsgiref.py", "8102", "threaded"], 8102),
    ("ASGI async handler (uvicorn)", [sys.executable, "-m", "uvicorn", "apps:asgi_async", "--port", "8103", "--log-level", "error"], 8103),
    ("ASGI handler that blocks (uvicorn)", [sys.executable, "-m", "uvicorn", "apps:asgi_blocking", "--port", "8104", "--log-level", "error"], 8104),
]
for name, cmd, port in servers:
    p = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    try:
        wait(port); one, _ = burst(port, 1); el, st = burst(port, 20)
        print(f"{name:42s} 1 request {one*1e3:5.0f} ms | 20 at once {el:5.2f} s | statuses {sorted(st)}")
    finally:
        p.terminate(); p.wait()

framework_demo.py: Flask com validação Pydantic, erros de roteamento e uma chamada WSGI crua:

import json
from flask import Flask, request, jsonify, g
from pydantic import BaseModel, Field, ValidationError, field_validator

app = Flask(__name__)

class NewOrder(BaseModel):
    email: str
    quantity: int = Field(gt=0, le=100)
    @field_validator("email")
    @classmethod
    def has_at(cls, v):
        if "@" not in v: raise ValueError("must contain @")
        return v.lower()

@app.post("/orders")
def create_order():
    try:
        order = NewOrder.model_validate(request.get_json(force=True, silent=True) or {})
    except ValidationError as e:
        return jsonify(errors=[{"field": ".".join(map(str, x["loc"])), "msg": x["msg"]} for x in e.errors()]), 422
    return jsonify(order.model_dump()), 201

@app.get("/orders/<int:order_id>")                 # the converter rejects non-integers before your code runs
def get_order(order_id): return jsonify(id=order_id)

@app.before_request
def mark(): g.seen = True

c = app.test_client()
print("valid  :", c.post("/orders", json={"email": "A@B.com", "quantity": 3}).status_code, c.post("/orders", json={"email": "A@B.com", "quantity": 3}).get_json())
r = c.post("/orders", json={"email": "nope", "quantity": 0}); print("invalid:", r.status_code, r.get_json())
r = c.post("/orders", json={"email": "a@b.c", "quantity": "5"}); print("'5' as str is coerced by default:", r.status_code, r.get_json()["quantity"], type(r.get_json()["quantity"]).__name__)
print("route typing:", c.get("/orders/7").get_json(), c.get("/orders/abc").status_code, "| unknown path:", c.get("/nope").status_code, "| wrong method:", c.put("/orders").status_code)

# what the framework hides: a WSGI call by hand
from io import BytesIO
body = json.dumps({"email": "x@y.z", "quantity": 1}).encode()
environ = {"REQUEST_METHOD": "POST", "PATH_INFO": "/orders", "wsgi.input": BytesIO(body), "CONTENT_LENGTH": str(len(body)), "CONTENT_TYPE": "application/json", "SERVER_NAME": "x", "SERVER_PORT": "80", "wsgi.url_scheme": "http", "wsgi.errors": BytesIO(), "wsgi.version": (1, 0), "wsgi.multithread": False, "wsgi.multiprocess": False, "wsgi.run_once": False, "SERVER_PROTOCOL": "HTTP/1.1"}
seen = {}
def start_response(status, headers): seen["status"] = status
out = b"".join(app.wsgi_app(environ, start_response))
print("raw WSGI call ->", seen["status"], out.decode().strip())

state_app.py e state_demo.py: estado de nível de módulo sob dois processos de trabalho:

from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route
import asyncio, os
counter = 0                                    # module-level state: one copy PER PROCESS
async def hit(request):
    global counter
    counter += 1
    await asyncio.sleep(0.05)              # keeps requests in flight so both workers get some
    return JSONResponse({"pid_tag": os.getpid() % 1000, "counter": counter})
async def ping(request): return JSONResponse({})
app = Starlette(routes=[Route("/hit", hit), Route("/ping", ping)])
"""Run from this folder: starts state_app.py with 2 uvicorn worker processes and shows that module-level state is per process."""
import subprocess, sys, time, urllib.request, json, collections
p = subprocess.Popen([sys.executable, "-m", "uvicorn", "state_app:app", "--port", "8110", "--workers", "2", "--log-level", "error"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
try:
    for _ in range(100):
        try: urllib.request.urlopen("http://127.0.0.1:8110/ping").read(); break
        except Exception: time.sleep(0.1)
    from concurrent.futures import ThreadPoolExecutor
    with ThreadPoolExecutor(12) as ex:
        res = list(ex.map(lambda _: json.load(urllib.request.urlopen("http://127.0.0.1:8110/hit")), range(12)))
    by = collections.defaultdict(list)
    for r in res: by[r["pid_tag"]].append(r["counter"])
    print("2 workers, 12 requests; counter values seen per worker process:", dict(by))
finally:
    p.terminate(); p.wait()

Fontes

  1. Documentação do Python, Data Structures, collections, heapq e Time complexity of built-in operations.
  2. Documentação do pandas, Copy-on-Write, Scaling to large datasets, Categorical data e Working with missing data.
  3. Python Enhancement Proposals, PEP 3333: Python Web Server Gateway Interface v1.0.1; a especificação ASGI.
  4. Documentação do Flask, do Django (implantação, suporte a ASGI), do Starlette, do FastAPI e do uvicorn (workers).
  5. Documentação do Pydantic, Models, Validators e Strict mode.
  6. Documentação do Gunicorn, Design (tipos de worker e quantos rodar).

Pratique este tema: Python

Mais guias