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êiner | Bom para | Custos |
|---|---|---|
list | itens ordenados, acrescentar no fim, índice | x in l varre (O(n)); inserir ou remover no início é O(n) |
tuple | registros fixos, chaves de dicionário | imutável; um pouco menor que uma lista |
dict | busca por chave, registros, contagem | busca por hash; preserva a ordem de inserção; pesado em memória |
set | pertinência, remoção de duplicatas, álgebra de conjuntos | busca por hash; sem ordem; pesado em memória |
collections.deque | filas (rápido nas duas pontas) | indexação lenta no meio |
heapq | o menor item primeiro, top-k | O(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:
| Layout | Memó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étodo | Tempo |
|---|---|
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:
- Strings repetidas (códigos de país, status) como o dtype
category: minha colunacountryde 200.000 linhas usou 10,2 MB como strings e 0,2 MB como categoria (códigos inteiros mais uma pequena tabela de consulta). - Inteiros dimensionados para os dados: uma coluna
userde números até 999 ocupou 1,6 MB comoint64e 0,4 MB comoint16. Verifique a faixa primeiro; inteiros de largura fixa estouram em silêncio (veja o guia de desempenho). - Carregue só as colunas de que precisa (
usecols=) e leia arquivos grandes em blocos:read_csv(..., chunksize=25_000)somou exatamente o mesmo total que ler de uma vez o arquivo inteiro de 100.000 linhas, com uma fração da memória a cada momento. - Se mesmo assim não cabe na memória, use um formato de arquivo colunar (Parquet), um banco de dados ou uma ferramenta feita para dados maiores que a memória (Polars, DuckDB, Dask). Uma agregação em SQL dentro do banco de dados costuma ser a resposta certa (índices de banco de dados).
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:
NaN == NaNéFalse; teste comisna(). Agregações comomeanignoramNaNpor padrão ([1.0, NaN, 3.0]deu 2,0).- Uma coluna de inteiros com um valor ausente vira float:
pd.Series([1, 2, None]).dtypefoifloat64. O dtype anulávelInt64mantém inteiros. - O ponto flutuante é inexato:
0.1 + 0.2 == 0.3éFalse, também em uma soma do pandas. Guarde dinheiro como centavos inteiros ouDecimal.
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:
| Servidor | 1 requisição | 20 de uma vez |
|---|---|---|
WSGI, uma requisição por vez (wsgiref) | 103 ms | 2,34 s |
| WSGI, uma thread por requisição | 103 ms | 0,11 s |
ASGI, handler assíncrono (uvicorn) | 103 ms | 0,12 s |
ASGI, handler que chama um time.sleep bloqueante | 102 ms | 2,02 s |
- Um servidor síncrono de uma thread só atende as requisições em fila: 20 × 0,1 s mais sobrecarga. Servidores WSGI de verdade acrescentam processos de trabalho e threads para evitar isso, e o número de workers é o seu limite de concorrência.
- Um handler assíncrono sobrepôs as 20 esperas em uma thread.
- A última linha é a armadilha dos guias de desempenho e de async: uma única chamada bloqueante dentro de um handler assíncrono para o laço de eventos inteiro, transformando o servidor assíncrono de volta em um sequencial. Dentro de código assíncrono, use bibliotecas assíncronas (drivers de banco de dados, clientes HTTP) ou empurre as chamadas bloqueantes para uma thread com
asyncio.to_thread.
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
| Flask | Django | FastAPI / Starlette | |
|---|---|---|---|
| Interface | WSGI | WSGI e ASGI | ASGI |
| Estilo | micro: roteamento e templates, você escolhe o resto | tudo incluído: ORM, migrações, admin, autenticação | endpoints tipados, validação automática de requisições e documentação OpenAPI (FastAPI) |
| Escolha quando | serviços pequenos, controle total, aprendizado | sites com muito conteúdo, interfaces administrativas, equipes que querem convenções | APIs 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
- Usar uma lista para testes de pertinência ou como fila (329 ms contra 0,7 ms para remover do início).
- Modificar um dicionário enquanto se itera sobre ele.
- Uma lista de dicionários para milhões de registros (50 MB contra 16 MB por coluna).
- Percorrer as linhas de um DataFrame (
iterrows: 410 ms contra 0,06 ms vetorizado), eapplypara coisas que têm forma vetorial. - Strings onde cabem categorias (10,2 MB contra 0,2 MB), e
int64para números pequenos. - Depender do comportamento de cópia específico de uma versão do pandas em vez de escrever código explícito.
- Dinheiro em float e
==em floats. - Chamadas bloqueantes dentro de handlers
async def(2,02 s contra 0,11 s). - Estado em globais de módulo com mais de um worker.
- Nenhuma validação na fronteira, ou confiar cegamente em tipos convertidos.
- Trabalho pesado no caminho da requisição, e uma conexão de banco de dados por requisição sem pool.
- Rodar o servidor de desenvolvimento em produção.
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
- Complexidades dos contêineres (list, dict, set, deque, heapq) e custos de memória; registros contra colunas.
- pandas: armazenamento colunar, vetorização, dtypes (
category, inteiros pequenos), blocos, semântica de cópia, comportamento com valores ausentes. - WSGI contra ASGI e o que bloqueia o quê; processos de trabalho como unidade de concorrência; nunca bloquear o laço de eventos.
- Validação na fronteira (Pydantic), códigos de status, estado por processo, pools de conexões, filas para trabalho lento.
- Implantação atrás de um proxy reverso, dependências fixadas, ids de requisição e métricas.
Resumo rápido
- Uma busca em dict ficou em cerca de 45–55 ns de 1.000 a 1.000.000 de chaves, mas custa memória (cerca de 42 MB para um milhão de chaves); um
dequeremoveu do início cerca de 470 vezes mais rápido que uma lista (0,7 ms contra 329 ms). - Os dados por coluna ocuparam 16 MB onde uma lista de dicts ocupou 50 MB.
- No pandas, vetorizar
amount * 1.2levou 0,06 ms para 20.000 linhas contra 410 ms doiterrows; o dtypecategoryreduziu uma coluna de strings de 10,2 MB para 0,2 MB. - O pandas 3 usa copy-on-write: mudar uma cópia filtrada deixou a original
[1, 2, 3]. Inteiros ausentes transformam uma coluna em float, a menos que você useInt64. - WSGI é uma chamada síncrona por requisição; ASGI é assíncrono. Vinte requisições que esperam 0,1 s levaram 2,34 s em um servidor de uma por vez, 0,11–0,12 s com threads ou async, e 2,02 s quando um handler assíncrono bloqueou.
- Valide a entrada com um esquema (422 para campos inválidos), mantenha o estado fora de globais de módulo (dois workers contaram cerca de metade cada um), use pool de conexões, enfileire trabalho lento e rode atrás de um proxy reverso.
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
- Documentação do Python, Data Structures,
collections,heapqe Time complexity of built-in operations. - Documentação do pandas, Copy-on-Write, Scaling to large datasets, Categorical data e Working with missing data.
- Python Enhancement Proposals, PEP 3333: Python Web Server Gateway Interface v1.0.1; a especificação ASGI.
- Documentação do Flask, do Django (implantação, suporte a ASGI), do Starlette, do FastAPI e do uvicorn (workers).
- Documentação do Pydantic, Models, Validators e Strict mode.
- Documentação do Gunicorn, Design (tipos de worker e quantos rodar).
Pratique este tema: Python