Como Ler CSV no Polars Explicado

Name

Matt Popovic

Atualizado em 09/06/2023

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 COLUNAS

Para 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.

(opens in a new tab)

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:

Executar PyGWalker no Kaggle Notebook (opens in a new tab)	Executar PyGWalker no Google Colab (opens in a new tab)	Dê uma ⭐️ para o PyGWalker no GitHub (opens in a new tab)
(opens in a new tab)	(opens in a new tab)	(opens in a new tab)

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:

1. Qual é a principal diferença entre as funções read_csv() e scan_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.

2. 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.

3. 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.