Leitura em partes para arquivos grandes

Um gargalo comum em pipelines de dados de produção é um arquivo CSV maior que a RAM disponível. Se um arquivo tem 20 GB e a máquina possui 16 GB de RAM, pd.read_csv('file.csv') falhará com um MemoryError. A solução é a leitura em partes: carregar o arquivo em partes de tamanho fixo, processar cada parte e acumular os resultados. Isso permite analisar arquivos de tamanho arbitrário sem carregá-los inteiramente na memória.

Passe chunksize=n para pd.read_csv() a fim de obter um iterador TextFileReader em vez de um DataFrame. Cada iteração fornece as próximas n linhas como um DataFrame. Dessa forma, apenas n linhas ficam na memória de cada vez. Um bom valor inicial para chunksize é 100.000 linhas — pequeno o suficiente para caber na RAM, mas grande o suficiente para manter controlável o custo das operações de entrada e saída. Ajuste esse valor de acordo com a RAM disponível e a quantidade de colunas.

Use um laço for sobre o iterador de partes para processar cada parte. Para operações simples, como contar linhas, somar uma coluna ou filtrar, processe cada parte de forma independente e acumule os resultados em uma lista ou em um total corrente. Sempre use o iterador dentro de uma instrução with ou garanta que ele seja recriado em cada execução do pipeline — os iteradores são consumidos uma única vez e não podem ser reiniciados.

Aplique os filtros de linhas dentro do laço para descartar os dados indesejados antes que eles se acumulem. Isso mantém baixo o uso de memória, retendo apenas as linhas que correspondem aos seus critérios. Por exemplo, para extrair todas as linhas da região 'North' de um arquivo de 10 GB, filtre cada parte antes de adicioná-la à sua lista de resultados. O pd.concat final processará apenas o subconjunto filtrado, que é muito menor.

As agregações de GroupBy entre partes são mais complexas que somas simples, pois os grupos podem se estender por várias partes. O padrão é: calcular as somas e contagens por grupo em cada parte, concatenar esses resultados parciais e executar um groupby final sobre os resultados parciais acumulados. Nunca chame groupby().mean() em cada parte e depois faça a média das médias — isso produz resultados incorretos quando os tamanhos dos grupos diferem entre as partes.

Reduza a memória durante o carregamento em partes especificando antecipadamente os dtypes das colunas em read_csv. Isso impede que o Pandas aloque tipos grandes para cada parte e depois os descarte. Passe um dicionário como dtype={'region': 'category', 'sales': 'int32'} para read_csv(). Combinada com a leitura em partes, essa técnica pode reduzir o pico de memória para menos de 10% do carregamento ingênuo do arquivo inteiro.

Quando a saída do processamento de cada parte também precisa ser gravada em um arquivo, grave cada parte processada à medida que ela fica pronta, em vez de acumular tudo na memória. Use mode='a' (adicionar) e header=False (após a primeira parte) com to_csv(). Isso mantém o uso de memória tanto da entrada quanto da saída limitado ao tamanho da parte, tornando o pipeline capaz de processar arquivos de tamanho arbitrário em uma máquina com memória limitada.

Dask fornece uma API semelhante à do Pandas que executa operações de forma tardia e paralela entre partes automaticamente. Em vez de escrever um laço manual para processar partes, você escreve dask_df = dd.read_csv('file.csv') e, em seguida, usa as mesmas operações do Pandas — groupby, filtro e mesclagem. Chame .compute() ao final para iniciar a execução. O Dask é a solução mais prática quando o seu pipeline envolve operações complexas em várias etapas, difíceis de implementar manualmente com leitura em partes.

O tamanho ideal da parte equilibra dois fatores opostos: partes pequenas demais, como 1.000 linhas, causam um custo elevado por parte, devido à configuração da entrada e saída do arquivo e à criação do DataFrame, e tornam o laço mais demorado. Partes grandes demais, como 10 milhões de linhas, frustram o objetivo ao carregar dados demais na RAM de uma só vez. Um ponto de partida prático é usar partes de 50–200 MB na memória. Para um DataFrame com 10 colunas de média de 8 bytes cada, 100.000 linhas correspondem a aproximadamente 8 MB por parte — um padrão seguro que deixa bastante margem disponível.

Se você controla o formato do arquivo, prefira Parquet ao CSV para conjuntos de dados grandes. O Parquet é um formato binário colunar que carrega apenas as colunas solicitadas, comprime muito melhor que o CSV, preserva os tipos de dados, sem necessidade de inferi-los novamente no carregamento, e é lido de 5 a 20 vezes mais rápido que um CSV equivalente. Converta um CSV grande para Parquet uma vez com pd.read_csv('file.csv', chunksize=500000) + to_parquet e, depois, use pd.read_parquet(columns=['col1','col2']) em todas as leituras seguintes.

Um padrão completo para processar arquivos grandes: 1) especifique os tipos de dados no momento da leitura; 2) filtre as linhas o mais cedo possível dentro do laço; 3) calcule agregações parciais por parte, como soma + contagem, nunca a média diretamente; 4) após o laço, combine os resultados parciais e calcule as estatísticas finais; 5) grave a saída incrementalmente se os resultados forem grandes. Esse padrão processa arquivos de qualquer tamanho em qualquer máquina, desde que o chunksize seja ajustado adequadamente.

Nesta lição, você aprendeu que chunksize em read_csv retorna um iterador que fornece um DataFrame por parte, permitindo processar incrementalmente arquivos maiores que a RAM; agregações parciais, como soma + contagem, são acumuladas corretamente entre as partes, enquanto a média não pode ser calculada diretamente como uma média das médias; e o formato Parquet é a melhor alternativa de longo prazo ao CSV para conjuntos de dados grandes, graças à compressão, à velocidade e à preservação dos tipos de dados. Com isso, o curso Dicas de desempenho do Pandas está concluído — você está pronto para os cursos avançados B2!