itertools: iteradores poderosos

Gerar e combinar sequências

O itertools é um módulo da biblioteca padrão cheio de ferramentas para trabalhar com iteradores de forma eficiente. Algumas produzem sequências. O count gera números indefinidamente, começando de onde você mandar e no passo que quiser, um contador infinito. O cycle percorre um iterável repetidas vezes, voltando ao começo para sempre, útil para revezar opções. Como são infinitos, você sempre os combina com algo que os limite, como um islice ou uma condição de parada, para não rodar sem fim.

from itertools import count, cycle, islice

# count: contador infinito a partir de 10, de 2 em 2
contador = count(10, 2)
print(list(islice(contador, 5)))  # [10, 12, 14, 16, 18]

# cycle: revezar cores sem fim, limitado por islice
cores = cycle(["vermelho", "verde", "azul"])
print(list(islice(cores, 7)))
# ['vermelho', 'verde', 'azul', 'vermelho', 'verde', 'azul', 'vermelho']

count e cycle são infinitos; islice limita a quantidade e evita rodar sem fim.

Outra ferramenta muito usada é o chain, que junta vários iteráveis num só fluxo, como se concatenasse, mas sem construir uma lista grande na memória. Percorrer duas ou três listas em sequência com chain é mais eficiente do que somá-las numa terceira, porque nada novo é criado: o chain apenas passa de um iterável ao próximo à medida que você consome. Isso resume o espírito do itertools: fazer muito com pouca memória, tratando os dados como um fluxo preguiçoso.

islice: fatiar com preguiça

Você já conhece o fatiamento com colchetes em listas, mas ele exige uma sequência inteira na memória e não funciona em iteradores infinitos. O islice faz o fatiamento de qualquer iterável de forma preguiçosa: ele consome só o que precisa para entregar o pedaço pedido e para. É o que permite pegar os primeiros cinco itens de um count infinito, como nos exemplos, ou pular um trecho e pegar outro. Com fontes grandes ou infinitas, o islice é a maneira segura de fatiar sem estourar a memória.

from itertools import islice, chain

# chain: percorrer varias listas como um fluxo unico
semana = ["seg", "ter", "qua"]
fim = ["qui", "sex"]
for dia in chain(semana, fim):
    print(dia, end=" ")  # seg ter qua qui sex
print()

# islice com inicio e fim: pega do indice 2 ao 5
numeros = range(100)
print(list(islice(numeros, 2, 6)))  # [2, 3, 4, 5]

chain une iteráveis num fluxo; islice fatia por posição sem materializar tudo.

groupby: agrupar itens consecutivos

O groupby agrupa itens consecutivos que compartilham uma chave. Você passa o iterável e uma função que extrai a chave de cada item, e ele devolve grupos de vizinhos iguais. Há um detalhe crucial: o groupby só junta itens adjacentes, então ele não reúne ocorrências espalhadas. Se você quer agrupar todos os itens de cada categoria, precisa ordenar os dados por essa chave antes, para que os iguais fiquem lado a lado. Esquecer disso é o erro mais comum com groupby.

from itertools import groupby

pessoas = [
    {"nome": "Ana", "cidade": "SP"},
    {"nome": "Beto", "cidade": "SP"},
    {"nome": "Caio", "cidade": "RJ"},
    {"nome": "Duda", "cidade": "RJ"},
]

# Ja estao ordenados por cidade; agrupa por cidade:
por_cidade = groupby(pessoas, key=lambda p: p["cidade"])
for cidade, grupo in por_cidade:
    nomes = [p["nome"] for p in grupo]
    print(cidade, nomes)
# SP ['Ana', 'Beto'] / RJ ['Caio', 'Duda']

groupby junta vizinhos com a mesma chave; os dados precisam estar ordenados por ela.

Com count, cycle, chain, islice e groupby você já tem uma boa base do itertools, e o módulo traz muitas outras, para combinações, produtos e acumulações. O fio comum é a eficiência: iteradores preguiçosos que processam dados como fluxo, sem materializar tudo. Isso encerra o módulo de programação funcional. Você aprendeu a preferir funções puras e imutabilidade, a transformar e selecionar com map e filter, a acumular e especializar com reduce e partial, a memoizar com lru_cache e a manipular fluxos com o itertools. É um estilo que, bem usado, deixa o código mais claro e eficiente.