Parquet: armazenamento colunar rápido
Grave um DataFrame do Pandas em Parquet com to_parquet(), leia-o de volta mais rapidamente que um CSV e use a seleção de colunas para carregar apenas os campos necessários.
Parquet: armazenamento colunar rápido é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
O que é Parquet?
Apache Parquet é um formato de arquivo binário orientado a colunas, projetado para cargas de trabalho analíticas. Diferentemente do CSV, que armazena os dados linha por linha como texto, o Parquet armazena cada coluna em um bloco contíguo, compacta-a de forma eficiente e codifica metadados. Isso o torna consideravelmente mais rápido para consultas que leem apenas algumas colunas de uma tabela larga. Parquet é o formato padrão de fato em lagos de dados (AWS S3, Google Cloud Storage) e tem suporte nativo no Pandas, Dask, Spark e BigQuery.
Escrevendo Parquet com to_parquet()
Converter um DataFrame do Pandas para Parquet exige uma única chamada de método: df.to_parquet('output.parquet'). O mecanismo padrão é pyarrow (instale-o com pip install pyarrow). Parquet preserva exatamente os tipos de dados das colunas — não há mais colunas de datas sendo lidas novamente como strings. Ele também oferece suporte à compactação por padrão usando o parâmetro compression; 'snappy' oferece leitura e gravação rápidas com compactação moderada, enquanto 'gzip' proporciona maior compactação ao custo de velocidade.
import pandas as pd
import numpy as np
# Create a sample DataFrame
np.random.seed(0)
df = pd.DataFrame({
'date': pd.date_range('2024-01-01', periods=100000, freq='T'),
'value': np.random.randn(100000),
'category': np.random.choice(['A', 'B', 'C'], 100000)
})
# Write to Parquet
df.to_parquet('data.parquet', index=False, compression='snappy')
print('Written to data.parquet')Lendo Parquet com read_parquet()
pd.read_parquet('output.parquet') lê o arquivo novamente em um DataFrame. Em comparação com a leitura do CSV equivalente, a leitura de Parquet costuma ser 5 a 10 vezes mais rápida para tabelas largas com muitas colunas. Os tipos de dados são preservados exatamente — as datas permanecem como datetime64, as categorias permanecem como category e os inteiros permanecem como int32 ou int64, conforme armazenados. Não é necessário inferir os tipos, pois os metadados estão incorporados ao arquivo.
import pandas as pd
import time
# Read Parquet
start = time.time()
df = pd.read_parquet('data.parquet')
print(f'Read Parquet: {time.time()-start:.3f}s')
print(df.dtypes)
print(df.shape)Poda de colunas: lendo apenas as colunas necessárias
A maior vantagem do armazenamento orientado a colunas é a poda de colunas: você pode ler apenas colunas específicas sem percorrer o restante do arquivo. Passe uma lista de nomes de colunas ao parâmetro columns. Se uma tabela com 100 colunas tiver 100 MB por coluna e você precisar de apenas 3 colunas, o Parquet lerá 3 MB em vez de 10 GB. O CSV precisa percorrer todos os caracteres para extrair qualquer coluna. Isso torna o Parquet ideal para tabelas largas em pipelines analíticos.
import pandas as pd
# Only load the 2 columns needed for this analysis
df = pd.read_parquet('large_table.parquet',
columns=['date', 'revenue'])
print(df.columns.tolist())
print(df.shape)
print(df.memory_usage(deep=True).sum() / 1e6, 'MB loaded')Filtragem de grupos de linhas (pushdown de predicados)
O Parquet armazena estatísticas (mínimo/máximo) para cada grupo de linhas (bloco de linhas) no rodapé do arquivo. Quando você aplica um filtro por meio do parâmetro filters, o leitor ignora grupos de linhas inteiros nos quais o filtro não pode corresponder — isso é chamado de pushdown de predicados. Por exemplo, ao filtrar datas em um arquivo Parquet ordenado por tempo, blocos mensais inteiros fora do intervalo são ignorados, e apenas as partes relevantes são lidas. O mecanismo pyarrow oferece suporte nativo a isso.
import pandas as pd
# Filter using predicate pushdown — row groups outside range are skipped
df = pd.read_parquet(
'time_series.parquet',
columns=['date', 'value'],
filters=[('date', '>=', '2024-06-01'),
('date', '<', '2024-07-01')]
)
print(f'Loaded {len(df):,} rows (June only)')
print(df.head())Parquet e CSV: uma comparação
Veja uma comparação prática entre Parquet e CSV para um conjunto de dados com 10 milhões de linhas e 20 colunas:
- Tamanho do arquivo: CSV ~2 GB, Parquet (snappy) ~400 MB
- Tempo de leitura (todas as colunas): CSV ~15s, Parquet ~2s
- Tempo de leitura (3 colunas): CSV ~15s (é necessário percorrer tudo), Parquet ~0,3s
- Preservação dos tipos de dados: CSV perde os tipos, Parquet os preserva
- Legibilidade humana: CSV sim, Parquet não (binário)
Em pipelines de produção, nos quais os dados são gravados uma vez e lidos muitas vezes, Parquet quase sempre é a melhor escolha.
Conjuntos de dados Parquet particionados
Para conjuntos de dados muito grandes, Parquet oferece suporte a conjuntos de dados particionados: os dados são divididos em vários arquivos organizados em uma hierarquia de diretórios pelos valores das colunas. Por exemplo, particionar por ano e mês cria data/year=2024/month=01/part.parquet. A leitura de um conjunto de dados particionado filtra automaticamente os diretórios correspondentes a uma consulta. Esse é o layout padrão em lagos de dados e permite consultas eficientes por intervalo em bilhões de linhas.
import pandas as pd
# Write a partitioned dataset (requires pyarrow)
df = pd.read_parquet('all_data.parquet')
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df.to_parquet(
'partitioned_data/',
partition_cols=['year', 'month'],
index=False
)
# Creates: partitioned_data/year=2024/month=1/part-0.parquet etc.Lendo conjuntos de dados particionados
Ler um diretório Parquet particionado é igual a ler um único arquivo — o Pandas (por meio do pyarrow) descobre automaticamente todos os arquivos de partição. Os valores da coluna de partição são incluídos como colunas no DataFrame resultante. Você também pode usar filters para aproveitar a poda de partições, na qual subárvores inteiras de diretórios são ignoradas com base nos valores da coluna de partição. Isso faz com que consultar um conjunto de dados particionado de 1 TB seja semelhante a ler alguns MB.
import pandas as pd
# Read the entire partitioned dataset
df_all = pd.read_parquet('partitioned_data/')
print('All years:', df_all['year'].unique())
# Read only 2024 data using partition pruning
df_2024 = pd.read_parquet(
'partitioned_data/',
filters=[('year', '==', 2024)]
)
print('2024 rows:', len(df_2024))Parquet com Dask
Dask lê e grava Parquet nativamente com dd.read_parquet() e ddf.to_parquet(). Cada arquivo em um diretório Parquet particionado se torna uma partição do Dask, permitindo leituras totalmente paralelas. Dask também aproveita o pushdown de predicados quando filtros são especificados. Gravar um resultado grande do Dask em um conjunto de dados Parquet particionado é a forma padrão de produzir saídas nos pipelines modernos de engenharia de dados.
import dask.dataframe as dd
# Read partitioned Parquet with Dask (each file = one partition)
ddf = dd.read_parquet('partitioned_data/',
columns=['date', 'revenue', 'region'],
filters=[('year', '==', 2024)])
# Compute aggregation in parallel
result = ddf.groupby('region')['revenue'].sum().compute()
print(result.sort_values(ascending=False))Opções de compactação e codificação
O Parquet é compatível com vários algoritmos de compressão e esquemas internos de codificação. Snappy (padrão) prioriza a velocidade, com compressão moderada. O Gzip produz arquivos cerca de 30% menores, mas é mais lento para leitura e gravação. O Zstd equilibra velocidade e compressão melhor do que ambos. Para colunas de inteiros, o Parquet aplica automaticamente codificação delta ou codificação por dicionário para reduzir ainda mais o tamanho, sem exigir nenhuma configuração adicional da sua parte.
import pandas as pd
import numpy as np
np.random.seed(0)
df = pd.DataFrame({'id': range(500000), 'val': np.random.randn(500000)})
for comp in ['snappy', 'gzip', 'zstd']:
fname = f'data_{comp}.parquet'
df.to_parquet(fname, compression=comp, index=False)
import os
size_mb = os.path.getsize(fname) / 1e6
print(f'{comp}: {size_mb:.2f} MB')Substituindo CSV no seu fluxo de dados
A maneira mais simples de adotar o Parquet é adicionar uma etapa de conversão única no início de um projeto: ler o seu CSV uma vez, limpar os dados, converter os tipos e salvá-lo como Parquet. Nas execuções seguintes, leia o arquivo Parquet em vez do CSV. Isso proporciona benefícios imediatos de velocidade e armazenamento, com alterações mínimas no código. Para dados novos que chegam como CSV (por exemplo, exportações noturnas), adicione ao seu fluxo de dados uma etapa de conversão que grave os dados em Parquet antes do início de qualquer análise.
import pandas as pd
# One-time conversion
df = pd.read_csv('raw_data.csv',
parse_dates=['date'],
dtype={'category': 'category',
'amount': 'float32'})
df.to_parquet('clean_data.parquet', index=False)
# All future reads use Parquet
df_fast = pd.read_parquet('clean_data.parquet')
print('Loaded from Parquet:', df_fast.dtypes.to_dict())Verificação rápida
Teste sua compreensão dos conceitos de Análise de Dados desta lição.
Recapitulação da lição
Nesta lição, você aprendeu que to_parquet() e read_parquet() oferecem E/S de arquivos mais rápida, menor e com preservação dos tipos de dados em comparação com CSV; que a seleção de colunas com o parâmetro columns lê apenas as colunas necessárias, evitando varreduras completas dos arquivos; e que conjuntos de dados Parquet particionados, organizados por valores de colunas, permitem eliminar partições e realizar consultas eficientes por intervalo em grandes lagos de dados. A seguir, conectaremos o Pandas a bancos de dados relacionais usando o SQLAlchemy.
Aprenda Python com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “Parquet: armazenamento colunar rápido” é grátis?
Sim — o texto completo de “Parquet: armazenamento colunar rápido” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
O que vou aprender em “Parquet: armazenamento colunar rápido”?
Grave um DataFrame do Pandas em Parquet com to_parquet(), leia-o de volta mais rapidamente que um CSV e use a seleção de colunas para carregar apenas os campos necessários. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Pandas & NumPy Academy?
Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Parquet: armazenamento colunar rápido”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Pandas & NumPy Academy?
Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- CSV em fluxo com chunksize
- Agregação incremental entre partes
- Introdução aos DataFrames do Dask
- Parquet: armazenamento colunar rápido