Como Ler CSV no Polars Explicado
- Name
- Matt Popovic
Published on
Polars, uma biblioteca de DataFrame rápida em Python, oferece uma interface familiar e poderosa para processar dados estruturados. Especialmente ao lidar com arquivos CSV, o Polars brilha ao oferecer métodos diretos, como read_csv() e scan_csv(), semelhantes aos do pandas. Vamos aprender como aproveitar ao máximo esses métodos.
Importando CSV com read_csv()
O Polars fornece um método de uso fácil read_csv() para importar arquivos CSV. Sua sintaxe é surpreendentemente semelhante à do pandas, o que facilita a transição para aqueles acostumados com o pandas. Aqui está uma demonstração rápida:
import polars as pl
# Ler CSV com read_csv
df = pl.read_csv('data_sample.csv')
print(df)Saída:
formato: (3, 4)
┌───────────┬───────┬─────┬───────────────────┐
│ studentId ┆ Name ┆ Age ┆ FirstEnrollment │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 ┆ str │
╞═══════════╪═══════╪═════╪═══════════════════╡
│ 1 ┆ Mike ┆ 24 ┆ 2020-01-17 │
│ 2 ┆ Sarah ┆ 33 ┆ 2021-07-23 │
│ 3 ┆ John ┆ 19 ┆ 2022-12-20 │
└───────────┴───────┴─────┴───────────────────┘Analisando Datas com read_csv()
Ao importar arquivos CSV, pode ser necessário analisar determinadas colunas como objetos de data e hora. Essa funcionalidade é ativada pelo parâmetro parse_dates=True. Por exemplo:
# Ler CSV com análise de datas
df_datas = pl.read_csv('data_sample.csv', parse_dates=True)
print(df_datas)Alterando Tipos de Coluna na Hora
Também é possível converter o tipo de dados de colunas específicas durante a leitura do arquivo. Por exemplo, veja como converter a coluna 'Age' de i64 para Int32:
# Ler CSV com um tipo de dados específico
df_idade_convertida = pl.read_csv('data_sample.csv', parse_dates=True).with_column(pl.col('Age').cast(pl.Int32))
print(df_idade_convertida)Uma vantagem que o Polars tem sobre o pandas é sua capacidade de revelar os tipos de coluna ao exibir um DataFrame, tornando a solução de problemas de tipo de dados muito mais fácil.
Otimizando Leituras com scan_csv()
Para conjuntos de dados grandes, o Polars oferece um método mais eficiente em termos de recursos - scan_csv(). Ao aproveitar a avaliação preguiçosa, este método carrega dados na memória apenas quando necessário (ou seja, quando o collect() é chamado), potencialmente reduzindo a sobrecarga de memória. Aqui está uma breve olhada:
# Leitura eficiente com scan_csv
q = pl.scan_csv('data_sample.csv')
df_preguiçoso = q.collect()
print(df_preguiçoso)Lembre-se de chamar collect() para executar as operações, caso contrário, uma representação das operações (plano) será retornada.
Estas são apenas algumas das formas como o Polars pode ser usado para interagir com arquivos CSV. Sua sintaxe clara e funções poderosas o tornam uma excelente ferramenta para manipulação de dados em Python.
Entendendo Expressões e Ações do Polars
O Polars suporta operações tanto impacientes quanto preguiçosas. No modo impaciente, os cálculos são executados imediatamente, enquanto no modo preguiçoso, as operações são enfileiradas e avaliadas apenas quando necessário, otimizando a eficiência e o uso da memória.
Utilizando Avaliação Preguiçosa com scan_csv()
Com o scan_csv(), os dados não são carregados imediatamente na memória. Em vez disso, o Polars constrói um plano de consulta que inclui as operações a serem realizadas. Esse plano de consulta é executado apenas quando o collect() é chamado. Essa técnica, conhecida como avaliação preguiçosa, pode resultar em um uso mais eficiente da memória e computação mais rápida, especialmente com conjuntos de dados grandes. Aqui está um exemplo:
# Leitura preguiçosa com scan_csv
consulta = pl.scan_csv('data_sample.csv')
print(consulta)A execução do código acima resulta em um resumo do "plano" das operações, mas as operações em si ainda não são executadas.
plano ingênuo: (execute LazyFrame.describe_optimized_plan() para ver o plano otimizado)
SCAN CSV data_sample.csv
PROJECT */4 COLUNASPara executar esse plano e carregar os dados na memória, você precisa usar o método collect():
df_preguiçoso = consulta.collect()
print(df_preguiçoso)Mais do que Apenas Ler CSVs: Manipulação de Dados
Além de apenas ler CSVs, o Polars oferece um conjunto abrangente de funções de manipulação de dados que se alinham bem com as operações do pandas. Isso torna o Polars uma ferramenta eficiente e versátil para análise de dados. Seja filtrando dados, aplicando transformações ou agregando informações, o Polars pode lidar com tudo isso com ótimo desempenho.
Visualize Seu Dataframe Polars com o PyGWalker
PyGWalker (opens in a new tab) é uma biblioteca Open Source em Python que pode ajudar você a criar visualizações de dados a partir do seu dataframe Polars com facilidade.
Não é mais necessário realizar processamentos complicados com codificação Python, basta importar seus dados e arrastar e soltar variáveis para criar todos os tipos de visualizações de dados! Aqui está um vídeo de demonstração rápida sobre a operação:
Veja como usar o PyGWalker no seu Jupyter Notebook:
pip install pygwalker
import pygwalker as pyg
gwalker = pyg.walk(df)Alternativamente, você pode experimentá-lo no Kaggle Notebook/Google Colab:
O PyGWalker é construído com o apoio da nossa comunidade de código aberto. Não se esqueça de conferir PyGWalker no GitHub (opens in a new tab) e nos dar uma estrela!
Perguntas frequentes:
Ao navegar pelo Polars, você pode encontrar algumas perguntas. Aqui estão algumas comuns:
- Qual é a principal diferença entre as funções
read_csv()escan_csv()no Polars?
read_csv() é uma função direta que lê um arquivo CSV e carrega todos os dados na memória. Por outro lado, scan_csv() opera de forma preguiçosa, ou seja, não carrega os dados até que collect() seja chamado. Isso torna o scan_csv() mais eficiente ao lidar com grandes conjuntos de dados, pois carrega apenas os dados necessários na memória.
- O Polars pode lidar com análise de datas ao ler arquivos CSV?
Sim, o Polars pode lidar com análise de datas. Ao usar a função read_csv(), basta definir o argumento parse_dates=True, e o Polars tentará analisar colunas com informações de data automaticamente.
- Posso alterar o tipo de dados de colunas específicas ao ler um arquivo CSV?
Com certeza. O Polars permite modificar os tipos de dados das colunas durante o processo de leitura do arquivo CSV. Você pode usar o método with_columns() em conjunto com a função cast() para fazer isso. Por exemplo, df = pl.read_csv('data.csv').with_columns(pl.col('Age').cast(pl.Int32)) irá alterar a coluna 'Age' para Int32.