Prática: processar um arquivo grande

Ler o arquivo sem engolir tudo

Este é o cenário que motiva tudo o que você viu no módulo. Imagine um arquivo de log com milhões de linhas, grande demais para caber confortavelmente na memória. Você quer contar quantas linhas contêm a palavra ERRO. A abordagem ingênua seria ler o arquivo inteiro para uma lista com readlines() e depois filtrar. Em um arquivo enorme, isso pode esgotar a memória antes mesmo de começar a contar. A abordagem com geradores lê e processa uma linha por vez, gastando a memória de uma linha só, não importa se o arquivo tem mil ou dez milhões de linhas.

O detalhe que torna isso natural no Python é que o próprio objeto arquivo já é um iterador de linhas. Quando você escreve for linha in arquivo, o Python entrega uma linha de cada vez, lendo do disco sob demanda, exatamente como um gerador. Vamos aproveitar isso e envolver a leitura em um gerador nosso, que também remove o espaço em branco das pontas de cada linha. Assim separamos a responsabilidade de ler da responsabilidade de contar, no espírito de pipeline da aula anterior.

# Primeiro, criamos um arquivo de exemplo para a pratica.
with open("log.txt", "w", encoding="utf-8") as f:
    f.write("INFO servidor iniciado\n")
    f.write("ERRO falha ao conectar\n")
    f.write("INFO requisicao recebida\n")
    f.write("ERRO tempo esgotado\n")
    f.write("INFO tudo certo\n")

def ler_linhas(caminho):
    with open(caminho, encoding="utf-8") as arquivo:
        for linha in arquivo:      # uma linha por vez, sob demanda
            yield linha.strip()    # remove espaco e quebra de linha

for linha in ler_linhas("log.txt"):
    print(linha)

# INFO servidor iniciado
# ERRO falha ao conectar
# INFO requisicao recebida
# ERRO tempo esgotado
# INFO tudo certo

O gerador ler_linhas entrega uma linha limpa por vez, sem carregar o arquivo inteiro.

Filtrar as linhas e contar ocorrências

Com o gerador de leitura pronto, encadeamos um filtro que deixa passar só as linhas com a palavra ERRO, no mesmo estilo de pipeline da aula anterior. O filtro é outro gerador: recebe o fluxo de linhas e devolve apenas as que interessam. Por fim, contamos. Como só precisamos do total, não guardamos as linhas: percorremos o fluxo somando um a cada ocorrência. A função sum combinada com uma generator expression faz isso em uma linha, tratando cada True como 1, mas aqui usamos um laço explícito para deixar a contagem visível.

def apenas_com(linhas, termo):
    for linha in linhas:
        if termo in linha:
            yield linha

# Pipeline: ler o arquivo, filtrar as linhas de ERRO.
linhas = ler_linhas("log.txt")
erros = apenas_com(linhas, "ERRO")

total = 0
for _ in erros:
    total = total + 1

print("Linhas com ERRO:", total)   # Linhas com ERRO: 2

Encadeia leitura e filtro, depois conta as ocorrências percorrendo o fluxo uma única vez.

O mesmo resultado sai de forma ainda mais enxuta passando uma generator expression direto para sum, como na aula de generator expressions. A linha total = sum(1 for linha in ler_linhas("log.txt") if "ERRO" in linha) faz leitura, filtro e contagem de uma vez, sem nenhuma lista intermediária e com memória de uma linha por vez. Escolha a forma pela clareza: o pipeline com etapas nomeadas é mais fácil de ampliar; a expressão única é mais direta para uma contagem simples. As duas compartilham a mesma virtude central, que é nunca carregar o arquivo inteiro na memória.

O que você construiu

Você fechou o módulo com o exemplo que resume o valor dos geradores. Um gerador leu um arquivo linha a linha, sem carregá-lo inteiro; outro gerador filtrou o fluxo; e um contador percorreu tudo uma vez, gastando memória constante. Trocando o pequeno log de exemplo por um arquivo de milhões de linhas, o código não muda em nada e continua leve, porque a memória usada é a de uma linha por vez. Esse é o padrão que profissionais aplicam para processar logs, planilhas gigantes e exportações de bancos de dados sem estourar a máquina.