Lidar com arquivos gigantes no Python nunca foi tão fácil

Você recebe a missão de processar uma base SQL interminável.
Então você abre tudo de uma vez com o Pandas.
O Python trava.
O PC pede socorro.

Sua vontade é:

Se você trabalha com dados, provavelmente já se estressou muito ao tentar manipular um arquivo gigante.

A boa notícia é que existem diversas formas de contornar essa situação, e hoje vou te mostrar 10 técnicas que vão mudar a forma como você trabalha com gigabytes de dados no Python. E a melhor parte: sem precisar de uma supermáquina.

Pronto? Então vamos lá!

💻 As 10 estratégias para lidar com arquivos gigantes no Python

1️⃣ Leitura linha por linha com iteradores

Se você precisa processar um arquivo gigantesco sem sobrecarregar a memória, leia-o linha por linha:

with open('arquivo_grande.txt', 'r') as arquivo:
    for linha in arquivo: processa(linha)   # Substitua pelo seu processamento

with open('arquivo_grande.txt', 'r') as arquivo:
    for linha in arquivo: processa(linha)   # Substitua pelo seu processamento

Por que funciona? O arquivo é tratado como um iterador, carregando apenas pequenas partes na memória por vez.

Ideal para: arquivos baseados em texto, como logs ou CSVs.

Saiba mais em: Como iterar sobre linhas em um DataFrame do Pandas

2️⃣ Leitura em blocos (chunks)

Precisa de mais flexibilidade? Leia o arquivo em blocos de tamanho fixo, controlando exatamente quanto processar de cada vez:

def ler_em_blocos(caminho_arquivo, tamanho_bloco=1024):
    with open(caminho_arquivo, 'r') as arquivo:
        while True:
          bloco = arquivo.read(tamanho_bloco)
            if not bloco:
              break
      processa(bloco) # Substitua pelo seu processamento

def ler_em_blocos(caminho_arquivo, tamanho_bloco=1024):
    with open(caminho_arquivo, 'r') as arquivo:
        while True:
          bloco = arquivo.read(tamanho_bloco)
            if not bloco:
              break
      processa(bloco) # Substitua pelo seu processamento

Quando usar? Quando a leitura linha por linha não é suficiente ou quando o arquivo é grande demais para ser carregado completamente na memória. Ajuste o tamanho do bloco para equilibrar memória e desempenho.

3️⃣ Leitura com buffer otimizado

Aumente a eficiência com leitura em buffer, reduzindo o número de operações de I/O no disco:

with open('arquivo_grande.txt', 'rb', buffering=10 * 1024 * 1024) as arquivo: # Buffer de 10 MB
      for linha in arquivo:
            processa(linha)

with open('arquivo_grande.txt', 'rb', buffering=10 * 1024 * 1024) as arquivo: # Buffer de 10 MB
      for linha in arquivo:
            processa(linha)

Vantagem: reduz o tempo de leitura para arquivos muito grandes.

4️⃣ Arquivos mapeados em memória (mmap)

Com memory mapping, você pode tratar um arquivo como um array de bytes na memória, ideal para acesso aleatório:

from mmap import mmap

with open('arquivo_grande.txt', 'r') as arquivo:
    with mmap(arquivo.fileno(), length=0, access=mmap.ACCESS_READ) as mm:
      for linha in mm:
            processa(linha.decode('utf-8'))

from mmap import mmap

with open('arquivo_grande.txt', 'r') as arquivo:
    with mmap(arquivo.fileno(), length=0, access=mmap.ACCESS_READ) as mm:
      for linha in mm:
            processa(linha.decode('utf-8'))

Quando usar? Para acessar partes específicas de arquivos gigantes de forma eficiente.

5️⃣ Use geradores para processamento sob demanda

Com geradores, você processa os dados “preguiçosamente”, economizando memória:

def gera_linhas(caminho_arquivo):
      with open(caminho_arquivo, 'r') as arquivo:
          for linha in arquivo:
               yield linha

for linha in gera_linhas('arquivo_grande.txt'):
      processa(linha)

def gera_linhas(caminho_arquivo):
      with open(caminho_arquivo, 'r') as arquivo:
          for linha in arquivo:
               yield linha

for linha in gera_linhas('arquivo_grande.txt'):
      processa(linha)

Por que usar? Processa grandes volumes sem carregar tudo na memória.

6️⃣ Processamento em lotes (batches)

Divida os dados em grupos para processamento organizado:

def ler_em_lotes(caminho_arquivo, tamanho_lote=5):
      with open(caminho_arquivo, 'r') as arquivo:
             lote = []
             for linha in arquivo:
                  lote.append(linha.strip())
                  if len(lote) == tamanho_lote:
                        yield lote
                        lote = []
            if lote:
                 yield lote

for lote in ler_em_lotes('dados.txt'):
     processa_lote(lote) # Substitua pela sua lógica

def ler_em_lotes(caminho_arquivo, tamanho_lote=5):
      with open(caminho_arquivo, 'r') as arquivo:
             lote = []
             for linha in arquivo:
                  lote.append(linha.strip())
                  if len(lote) == tamanho_lote:
                        yield lote
                        lote = []
            if lote:
                 yield lote

for lote in ler_em_lotes('dados.txt'):
     processa_lote(lote) # Substitua pela sua lógica

Ideal para: processar dados estruturados, como registros em CSV.

7️⃣ Processamento em stream

Para dados que chegam continuamente, como logs ou APIs, use o processamento em fluxo:

import requests

    def processa_stream(url):
       with requests.get(url, stream=True) as resposta:
           for linha in resposta.iter_lines():
               processa(linha)

import requests

    def processa_stream(url):
       with requests.get(url, stream=True) as resposta:
           for linha in resposta.iter_lines():
               processa(linha)

Aplicação: monitoramento em tempo real ou ingestão de dados via API.

8️⃣ Paralelismo com Dask

Quando os arquivos são gigantescos, use Dask para processá-los em paralelo:

import dask.dataframe as dd

df = dd.read_csv('grande_dataset.csv')
resultado = df[df['coluna'] > 100].compute()

import dask.dataframe as dd

df = dd.read_csv('grande_dataset.csv')
resultado = df[df['coluna'] > 100].compute()

Vantagem: gerencia dados que não cabem na memória, dividindo-os em partes menores.

9️⃣ Processamento distribuído com PySpark

Para volumes de dados que excedem a capacidade de uma máquina, distribua a carga com PySpark:

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("ProcessamentoDistribuido").getOrCreate()
df = spark.read.csv('grande_dataset.csv')
df.filter(df['coluna'] > 100).show()

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("ProcessamentoDistribuido").getOrCreate()
df = spark.read.csv('grande_dataset.csv')
df.filter(df['coluna'] > 100).show()

Quando usar? Para Big Data que requer cluster de máquinas.

🔟 Bibliotecas otimizadas para formatos específicos

Escolha bibliotecas especializadas para diferentes tipos de arquivo:

• JSON: use ijson para parsing incremental;
• XML: use lxml para alta performance;
• Parquet: use pyarrow ou fastparquet para dados tabulares compactos.

🎯 Transforme conhecimento em prática

Essas 10 estratégias são como ferramentas em uma caixa: cada uma tem um propósito específico e pode fazer toda a diferença no desempenho do seu código.

Se você gostou dessas dicas e quer se aprofundar, há mais um passo para dominar completamente o processamento de dados gigantes no Python.

📺 Assista agora: Estratégias que NÃO TE ENSINAM para trabalhar com dados GIGANTES no PYTHON

Neste vídeo, o professor Rodrigo Tadewald mostra na prática como aplicar técnicas avançadas para manipular grandes volumes de dados. Você vai aprender a:

• Otimizar o uso de memória com Pandas;
• Converter dados para o formato Parquet;
• Trabalhar com datasets de milhões de linhas.

Bons estudos e até próxima👋

Renata Lopes
Equipe Asimov Academy