Generator expressions e a memória

Só trocar colchetes por parênteses

Você já conhece a list comprehension do Intermediário, aquela expressão entre colchetes que constrói uma lista. A generator expression é irmã dela, com uma única diferença de escrita: troca os colchetes por parênteses. O efeito, porém, muda tudo. A list comprehension calcula todos os valores de uma vez e os guarda em uma lista completa na memória. A generator expression não calcula nada de imediato; ela devolve um gerador que produzirá cada valor só quando pedido.

quadrados_lista = [n * n for n in range(5)]   # colchetes: lista pronta
print(quadrados_lista)   # [0, 1, 4, 9, 16]

quadrados_ger = (n * n for n in range(5))     # parenteses: gerador
print(quadrados_ger)     # <generator object ...>
print(list(quadrados_ger))  # [0, 1, 4, 9, 16] quando consumido

Mesma lógica; colchetes criam a lista, parênteses criam um gerador preguiçoso.

No exemplo, a list comprehension já é a lista com os cinco quadrados. A generator expression é um objeto gerador que ainda não calculou nada; ele produz os valores conforme você os consome, seja com list, seja em um for. Para cinco números a diferença é irrelevante. A questão aparece quando os dados são grandes, e é aí que a economia de memória do gerador faz diferença de verdade.

A economia de memória em números

Suponha que você queira somar os quadrados de dez milhões de números. Com a list comprehension, o Python cria uma lista com dez milhões de itens na memória só para depois somá-los, o que consome centenas de megabytes à toa. Com a generator expression, nenhum item é guardado: cada quadrado é produzido, somado e descartado, um de cada vez. O uso de memória fica praticamente constante, independentemente do tamanho da entrada. É a diferença entre caber e estourar a memória.

# Pesado: cria uma lista de 10 milhoes de itens so para somar
total = sum([n * n for n in range(10_000_000)])

# Leve: nao guarda nada; soma um quadrado por vez
total = sum(n * n for n in range(10_000_000))
# Quando a generator expression e o unico argumento,
# os parenteses extras nem sao necessarios.

Com sum, o gerador soma sem materializar a lista inteira: memória quase constante.

O gerador se esgota: consumo único

Há um preço na economia, e ignorá-lo causa bugs sutis. Um gerador pode ser percorrido uma só vez. Depois de consumido, ele fica vazio: um segundo for sobre o mesmo gerador não produz nada, sem erro nenhum, o que confunde. A lista, por guardar tudo, pode ser percorrida quantas vezes você quiser. Então a decisão é clara: se você precisa dos valores mais de uma vez, use uma lista; se vai percorrer só uma vez, especialmente com dados grandes, prefira o gerador.

ger = (n for n in range(3))
print(list(ger))   # [0, 1, 2]  primeiro percurso consome tudo
print(list(ger))   # []          o gerador ja esta esgotado

# Uma lista pode ser percorrida varias vezes:
lst = [n for n in range(3)]
print(list(lst))   # [0, 1, 2]
print(list(lst))   # [0, 1, 2]  continua disponivel

Percorrer o gerador uma segunda vez devolve vazio; a lista permanece reutilizável.