CS Fundamentals Trainer · Guias

Desempenho e concorrência em Python

Fazer o profile primeiro, o que o interpretador custa por item, NumPy contra laços, a GIL medida com threads e processos, a sobrecarga de pools de processos, asyncio e chamadas bloqueantes, e como escolher.

17 min de leitura

"Python é lento" é verdade de um jeito específico e falso de vários outros, e a habilidade útil é saber separá-los. O código Python puro que faz um pouco de trabalho por item, em um laço, sobre milhões de itens, paga um custo a cada passo. O código Python que entrega o mesmo trabalho a uma função embutida, a uma biblioteca em C ou ao sistema operacional pode ser tão rápido quanto qualquer coisa. As threads do Python não conseguem executar dois trechos de código Python ao mesmo tempo na build padrão e, ainda assim, deixam muito mais rápidos os programas que dependem de E/S. Este guia mede cada um desses casos no CPython 3.13 para que você decida com números: onde o tempo vai, como encontrá-lo, como eliminá-lo e que tipo de concorrência serve a que tipo de problema. Ele se apoia em como o Python funciona; os scripts dos experimentos estão no apêndice.

Todos os tempos vêm de uma única máquina pequena com dois núcleos de CPU, então os ganhos de paralelismo abaixo chegam a cerca de 2, no máximo. Eles mostram o formato dos resultados, não números para citar.

1. Primeiro, descubra o que é lento

Chutar raramente funciona. Use as ferramentas nesta ordem:

  1. Meça o todo (tempo de relógio da carga de trabalho real). Se já está rápido o bastante, pare.
  2. Faça o profile para achar onde o tempo vai. O cProfile conta cada chamada de função e o tempo gasto nela; a biblioteca padrão imprime uma tabela com pstats.
  3. Cronometre pequenas alternativas para o ponto crítico com timeit, que repete um trecho muitas vezes e evita o ruído de uma única execução (tome o mínimo de várias repetições).
  4. Para memória, use tracemalloc (pico de alocação e quais linhas alocaram).

Fiz o profile de uma função que remove duplicatas testando if x not in out em uma lista, ao lado de outra que usa dict.fromkeys, sobre 30.000 itens com 3.000 valores distintos:

FunçãoTempo cumulativo
slow_unique (teste de pertinência em uma lista)0,221 s
fast_unique (list(dict.fromkeys(items)))0,001 s

O profile apontou uma função em todo o programa, e a correção foi uma estrutura de dados melhor, não um código mais esperto: o teste de pertinência em uma lista varre a lista, enquanto um dict ou set faz uma busca por hash (veja como o Python funciona). Esse é o formato usual de um ganho de velocidade em Python. Mudar o algoritmo ou a estrutura de dados dá fatores de centenas; reescrever laços dá dezenas de por cento.

2. O que o interpretador custa

O CPython executa seu código rodando bytecode em uma máquina virtual, uma instrução por vez, e verifica tipos pelo caminho. Somei os quadrados de um milhão de inteiros de quatro maneiras:

AbordagemTempo para 1.000.000 de itens
for x in data: t += x * x44,4 ms
sum([x * x for x in data]) (monta uma lista primeiro)54,1 ms
sum(x * x for x in data) (gerador)37,0 ms
NumPy: (arr * arr).sum()0,9 ms

Três lições:

Outros microcustos que medi, para calibrar a intuição:

MudançaResultado
Um milhão de chamadas de add(i, 1) contra a mesma soma escrita inline46 ms contra 26 ms: uma chamada de função Python custa cerca de 20 ns além do trabalho
math.sqrt(i) contra um apelido local sq = math.sqrt39 ms contra 36 ms: um ganho pequeno, cerca de 3 ns por chamada

Os dois são reais e pequenos. Colocar o código inline ou guardar buscas de atributos quase nunca é o primeiro passo certo; se uma função é chamada um milhão de vezes no laço crítico, a melhor pergunta é se o laço pode ser eliminado.

O NumPy é rápido, e diferente

As bibliotecas vetorizadas mudam as regras, então conheça as diferenças:

Pandas, SciPy, scikit-learn, PyTorch e bibliotecas parecidas funcionam do mesmo jeito: o Python descreve o que fazer e o código compilado faz em massa. Se você precisa escrever o laço, ferramentas como Cython, Numba, PyO3 ou uma extensão em C o compilam; e as versões recentes do CPython incluem um interpretador adaptativo que especializa o bytecode crítico (isso é parte do motivo de um laço simples ser mais rápido no 3.13 do que o folclore diz), mas nada disso substitui a escolha de um bom algoritmo.

3. A GIL

A build padrão do CPython tem um bloqueio global do interpretador (GIL): apenas uma thread executa bytecode Python em cada instante. Ele existe porque o gerenciamento de memória do interpretador (contagens de referências, veja como o Python funciona) não é seguro de rodar a partir de duas threads ao mesmo tempo. Uma thread libera o bloqueio enquanto espera por E/S, enquanto dorme e dentro de muitas bibliotecas em C que fazem trabalho nativo longo.

A consequência depende do que as threads estão fazendo. Rodei o mesmo trabalho em threads e em processos:

TesteTempo
Trabalho de CPU, quatro tarefas uma após a outra1,00 s
Trabalho de CPU, quatro tarefas em 4 threads1,06 s (nada mais rápido; um pouco mais lento)
Trabalho de CPU, quatro tarefas em 2 processos0,63 s (dois núcleos, mais a partida dos processos)
Trabalho de E/S (20 esperas de 0,2 s), uma após a outra4,00 s
Trabalho de E/S, 20 threads0,20 s

(sys._is_gil_enabled() imprimiu True nesta build padrão. O Python 3.13 acrescentou uma build opcional free-threaded sem a GIL, descrita na PEP 703; ela é experimental, muitos módulos de extensão ainda não estão prontos para ela e a velocidade com uma única thread é um pouco menor. Verifique o que sua implantação realmente usa antes de planejar em cima disso.)

Duas ressalvas sobre a GIL: ela não torna suas estruturas de dados seguras para threads (x += 1 em uma variável compartilhada são vários passos de bytecode e ainda pode perder atualizações; use um threading.Lock ou uma fila, veja o guia de concorrência), e código em C que segura o bloqueio por muito tempo pode bloquear outras threads.

4. Processos: paralelismo de verdade, com um custo

concurrent.futures.ProcessPoolExecutor (ou multiprocessing) inicia processos de trabalho e lhes envia tarefas. Tudo o que cruza a fronteira entre processos é serializado com pickle, copiado e desserializado, então a sobrecarga importa:

TesteResultado
2.000 tarefas minúsculas (x + 1) em um laço0,12 ms
As mesmas 2.000 tarefas por 2 processos de trabalho, uma tarefa por vez366 ms (três mil vezes mais lento)
O mesmo, mas com chunksize=500 (quatro lotes)1 ms
Enviar uma lista de 2 milhões de itens a um worker117 ms

Regras que decorrem disso:

5. asyncio: muitas esperas em uma thread

O asyncio roda muitas tarefas em uma thread, alternando entre elas sempre que uma tarefa chega a um await sobre algo que não está pronto. Ele foi feito para programas que passam o tempo esperando: chamadas de rede, sockets, filas.

Iniciei muitas corrotinas que esperam 0,2 s cada uma:

Esperas concorrentesTempo total
200,20 s
1.0000,21 s
10.0000,29 s

Dez mil esperas custaram quase o mesmo que uma, sem uma thread por tarefa. É por isso que o asyncio serve a servidores com muitas conexões quase sempre ociosas.

A regra que o mantém rápido é que uma corrotina não pode bloquear. Cinco tarefas que chamaram o time.sleep(0.2) comum em vez de await asyncio.sleep(0.2) levaram 1,00 s: a chamada bloqueante parou o laço de eventos inteiro, então as tarefas rodaram uma após a outra. Chamar uma biblioteca bloqueante (um cliente HTTP síncrono, um driver de banco de dados, um cálculo grande) dentro de uma corrotina faz o mesmo. Opções: usar uma biblioteca assíncrona, ou executar a chamada bloqueante em uma thread com asyncio.to_thread() (ou em um pool de processos para trabalho de CPU) e dar await no resultado.

6. Como escolher

Seu problemaRecorra a
Uma função lenta em um programa grandefaça o profile primeiro (cProfile), depois corrija o ponto crítico
Testes de pertinência, buscas ou ordenações repetidosa estrutura de dados certa (set, dict, bisect, heapq)
Laços numéricos sobre arrays grandesNumPy ou outra biblioteca vetorizada
Espera por muitas operações de rede ou discoasyncio (muitas conexões) ou threads (código simples ou bibliotecas bloqueantes)
Trabalho pesado de CPU que se divide em partes grandes e independentesprocessos (ProcessPoolExecutor), em lotes
Código pesado de CPU com um laço apertado e não vetorizávelcompile-o (Cython, Numba, uma extensão em C ou Rust) ou reescreva essa parte
Precisa compartilhar estado mutável entre workersuma fila, um banco de dados ou um lock; evite globais mutáveis compartilhados

7. Erros comuns

8. Perguntas que os entrevistadores gostam de fazer

"O que é a GIL e por que ela existe?"

Um bloqueio que deixa apenas uma thread executar bytecode Python por vez no CPython padrão, o que mantém a contagem de referências e as partes internas do interpretador seguras sem bloqueios de granularidade fina. Ela limita as threads limitadas pela CPU, mas é liberada durante a E/S, então as threads ainda ajudam programas limitados por E/S.

"Threads, processos ou asyncio?"

Limitado por E/S com muitas conexões: asyncio. Limitado por E/S com bibliotecas bloqueantes ou código mais simples: threads. Limitado pela CPU: processos ou código nativo. Cargas mistas combinam as opções, por exemplo um servidor assíncrono que manda o trabalho pesado a um pool de processos.

"Como você aceleraria um programa Python lento?"

Medir e depois fazer o profile; corrigir primeiro o algoritmo ou a estrutura de dados; levar os laços para funções embutidas ou bibliotecas vetorizadas; usar a concorrência que combina com o gargalo; compilar só o que continuar crítico.

"Por que o multiprocessing pode ser mais lento que um laço simples?"

Iniciar workers e serializar argumentos e resultados custa muito mais que uma tarefa minúscula. Agrupe o trabalho, mantenha as cargas pequenas e use processos apenas para tarefas grandes o bastante.

"O asyncio deixa o código mais rápido?"

Ele torna a espera concorrente, não o cálculo mais rápido. Usa uma thread, então uma chamada pesada de CPU ou bloqueante trava tudo.

"x += 1 é seguro para threads com a GIL?"

Não. Ele compila para vários passos de bytecode (carregar, somar, armazenar), e uma troca de thread entre eles pode perder uma atualização. Use um lock, uma estrutura atômica como queue.Queue, ou evite estado compartilhado.

9. Coisas a mencionar em uma entrevista

Resumo rápido

Apêndice: o código dos experimentos

Python 3.13 (CPython), biblioteca padrão mais NumPy para o speed.py. Rode com python3 file.py. A máquina tinha dois núcleos de CPU; com mais núcleos os resultados com processos melhoram e os de threads para trabalho de CPU não. Os tempos variam de execução para execução e entre máquinas.

gil.py: trabalho limitado pela CPU e por E/S em threads e processos:

import time, threading, sys
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

def cpu(n):
    s = 0
    for i in range(n):
        s += i * i
    return s

def io(_):
    time.sleep(0.2)

def timed(label, fn):
    t = time.perf_counter(); fn(); print(f"{label}: {time.perf_counter() - t:.2f} s")

if __name__ == "__main__":
    print("python", sys.version.split()[0], "GIL enabled:", sys._is_gil_enabled())
    N, JOBS = 5_000_000, 4
    timed(f"CPU x{JOBS}, one thread (sequential)", lambda: [cpu(N) for _ in range(JOBS)])
    def threads():
        with ThreadPoolExecutor(JOBS) as ex: list(ex.map(cpu, [N] * JOBS))
    timed(f"CPU x{JOBS}, {JOBS} threads", threads)
    def procs():
        with ProcessPoolExecutor(2) as ex: list(ex.map(cpu, [N] * JOBS))
    timed(f"CPU x{JOBS}, 2 processes", procs)
    timed("I/O x20 (sleep 0.2 s), sequential", lambda: [io(0) for _ in range(20)])
    def io_threads():
        with ThreadPoolExecutor(20) as ex: list(ex.map(io, range(20)))
    timed("I/O x20, 20 threads", io_threads)

asyncio_io.py: muitas esperas concorrentes, e o que uma chamada bloqueante faz com o laço de eventos:

import asyncio, time
async def fetch(i):
    await asyncio.sleep(0.2)
    return i
async def main(n):
    t = time.perf_counter()
    await asyncio.gather(*(fetch(i) for i in range(n)))
    return time.perf_counter() - t
for n in (20, 1000, 10000):
    print(f"{n} concurrent waits of 0.2 s: {asyncio.run(main(n)):.2f} s")
async def blocking():
    t = time.perf_counter()
    async def bad(): time.sleep(0.2)          # blocks the whole event loop
    await asyncio.gather(*(bad() for _ in range(5)))
    return time.perf_counter() - t
print(f"5 tasks calling time.sleep(0.2): {asyncio.run(blocking()):.2f} s")

speed.py: laços contra compreensões, geradores e NumPy; custos de chamadas e buscas; uma execução do cProfile:

import timeit, cProfile, pstats, io, sys
import numpy as np
N = 1_000_000
data = list(range(N))
arr = np.arange(N, dtype=np.int64)

def loop():
    t = 0
    for x in data: t += x * x
    return t
def comp(): return sum([x * x for x in data])
def gen(): return sum(x * x for x in data)
def numpy_(): return int((arr * arr).sum())
for name, f in (("for loop", loop), ("sum(list comprehension)", comp), ("sum(generator)", gen), ("numpy arr*arr .sum()", numpy_)):
    t = min(timeit.repeat(f, number=3, repeat=3)) / 3
    print(f"{name:26s} {t*1e3:8.1f} ms")
assert loop() == comp() == gen() == numpy_()
print("int64 overflow check, numpy sum:", numpy_())

# numpy gotcha: fixed-width ints wrap around
print("np.int64 max + 1:", np.array([2**63 - 1], dtype=np.int64) + 1, "| python int:", 2**63)

# function call overhead and attribute lookups
def add(a, b): return a + b
def calls():
    for i in range(1_000_000): add(i, 1)
def inline():
    for i in range(1_000_000): i + 1
print(f"1M calls {min(timeit.repeat(calls, number=1, repeat=3))*1e3:.0f} ms vs inline {min(timeit.repeat(inline, number=1, repeat=3))*1e3:.0f} ms")
import math
def attr():
    for i in range(1_000_000): math.sqrt(i)
sq = math.sqrt
def local():
    for i in range(1_000_000): sq(i)
print(f"math.sqrt {min(timeit.repeat(attr, number=1, repeat=3))*1e3:.0f} ms vs local alias {min(timeit.repeat(local, number=1, repeat=3))*1e3:.0f} ms")

# cProfile: find the hot spot
def slow_unique(items):
    out = []
    for x in items:
        if x not in out: out.append(x)
    return out
def fast_unique(items): return list(dict.fromkeys(items))
def work():
    items = [i % 3000 for i in range(30000)]
    a = slow_unique(items); b = fast_unique(items)
    assert a == b
pr = cProfile.Profile(); pr.enable(); work(); pr.disable()
s = io.StringIO(); pstats.Stats(pr, stream=s).sort_stats("cumulative").print_stats(4)
print("\n".join(l for l in s.getvalue().splitlines() if "slow_unique" in l or "fast_unique" in l or "work" in l or "ncalls" in l))

pool_overhead.py: o custo de tarefas minúsculas e de argumentos grandes em um pool de processos:

import time
from concurrent.futures import ProcessPoolExecutor
def tiny(x): return x + 1
def big(lst): return len(lst)
if __name__ == "__main__":
    items = list(range(2000))
    t = time.perf_counter(); [tiny(x) for x in items]; seq = time.perf_counter() - t
    with ProcessPoolExecutor(2) as ex:
        list(ex.map(tiny, range(4)))      # warm up the workers
        t = time.perf_counter(); list(ex.map(tiny, items)); par = time.perf_counter() - t
        t = time.perf_counter(); list(ex.map(tiny, items, chunksize=500)); chunked = time.perf_counter() - t
        payload = list(range(2_000_000))
        t = time.perf_counter(); ex.submit(big, payload).result(); ship = time.perf_counter() - t
    print(f"2000 tiny tasks: sequential {seq*1e3:.2f} ms | 2 processes {par*1e3:.0f} ms | chunksize=500 {chunked*1e3:.0f} ms")
    print(f"sending a 2-million-item list to a worker: {ship*1e3:.0f} ms")

Fontes

  1. Documentação do Python, concurrent.futures, multiprocessing, threading e asyncio.
  2. Documentação do Python, The Python Profilers (cProfile) e timeit.
  3. Documentação do Python, Glossary: global interpreter lock, e Python support for free threading.
  4. Python Enhancement Proposals, PEP 703: Making the Global Interpreter Lock optional in CPython.
  5. Documentação do NumPy, Data types (inteiros de largura fixa e estouro).
  6. David Beazley, Understanding the Python GIL (slides de palestra, 2010), para o contexto de como o bloqueio funciona.

Pratique este tema: Python

Mais guias