Cómo leer CSV en Polars explicado

Name

Matt Popovic

Published on 9/6/2023

(opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab)

Polars, una biblioteca rápida de DataFrame en Python, proporciona una interfaz familiar y poderosa para procesar datos estructurados. Especialmente cuando se trata de archivos CSV, Polars destaca al ofrecer métodos sencillos, como read_csv() y scan_csv(), que recuerdan a los de pandas. Aprendamos cómo aprovechar al máximo estos métodos.

Importando CSV con read_csv()

Polars proporciona un método fácil de usar read_csv() para importar archivos CSV. Su sintaxis es sorprendentemente similar a la de pandas, lo que facilita la transición para aquellos acostumbrados a este último. Aquí tienes una demostración rápida:

import polars as pl
 
# Leer CSV con read_csv
df = pl.read_csv('data_sample.csv')
print(df)

Salida:

forma: (3, 4)
┌───────────┬───────┬─────┬───────────────────┐
│ studentId ┆ Name  ┆ Age ┆ Fecha de inscripción │
│ ---       ┆ ---   ┆ --- ┆ ---               │
│ i64       ┆ str   ┆ i64 ┆ str               │
╞═══════════╪═══════╪═════╪═══════════════════╡
│ 1         ┆ Mike  ┆ 24  ┆ 2020-01-17        │
│ 2         ┆ Sarah ┆ 33  ┆ 2021-07-23        │
│ 3         ┆ John  ┆ 19  ┆ 2022-12-20        │
└───────────┴───────┴─────┴───────────────────┘

Analizando fechas con read_csv()

Al importar archivos CSV, es posible que se desee analizar ciertas columnas como objetos de fecha y hora. Esta funcionalidad se habilita mediante el parámetro parse_dates=True. Por ejemplo:

# Leer CSV con análisis de fechas
df_fechas = pl.read_csv('data_sample.csv', parse_dates=True)
print(df_fechas)

Cambiar tipos de columnas sobre la marcha

También se puede convertir el tipo de datos de columnas específicas mientras se lee el archivo. Por ejemplo, así es como se cambia el tipo de la columna 'Age' de i64 a Int32:

# Leer CSV con un tipo de datos específico
df_edad_convertida = pl.read_csv('data_sample.csv', parse_dates=True).with_column(pl.col('Age').cast(pl.Int32))
print(df_edad_convertida)

Una ventaja que tiene Polars sobre pandas es su capacidad para mostrar los tipos de columna al mostrar un DataFrame, lo que facilita la solución de problemas de tipo de datos.

Optimizar lecturas con scan_csv()

Para conjuntos de datos grandes, Polars ofrece un método más eficiente en cuanto a recursos: scan_csv(). Al aprovechar la evaluación perezosa, este método carga los datos en la memoria solo cuando es necesario (es decir, cuando se llama a collect()), lo que puede reducir potencialmente la sobrecarga de memoria. Aquí tienes una vista rápida:

# Lectura eficiente con scan_csv
q = pl.scan_csv('data_sample.csv')
df_perezoso = q.collect()
print(df_perezoso)

Recuerda llamar a collect() para ejecutar las operaciones; de lo contrario, se devolverá una representación de las operaciones (plan).

Estas son solo algunas de las formas en que Polars se puede utilizar para interactuar con archivos CSV. Su sintaxis clara y sus funciones potentes lo convierten en una excelente herramienta para la manipulación de datos en Python.

Comprendiendo las expresiones y acciones de Polars

Polars admite tanto operaciones impacientes como operaciones perezosas. En el modo impaciente, los cálculos se ejecutan de inmediato, mientras que en el modo perezoso, las operaciones se enfilan y se evalúan solo cuando sea necesario, optimizando la eficiencia y el uso de memoria.

Empleando la evaluación perezosa con scan_csv()

Con scan_csv(), los datos no se cargan en la memoria de inmediato. En su lugar, Polars construye un plan de consulta que incluye las operaciones que se deben realizar. Este plan de consulta se ejecuta solo cuando se llama a collect(). Esta técnica, conocida como evaluación perezosa, puede resultar en un uso más eficiente de la memoria y una computación más rápida, especialmente con conjuntos de datos grandes. Aquí tienes un ejemplo:

# Lectura perezosa con scan_csv
consulta = pl.scan_csv('data_sample.csv')
print(consulta)

La ejecución del código anterior da como resultado un resumen del "plan" de operaciones, pero las operaciones propiamente dichas aún no se ejecutan.

plan ingenuo: (ejecuta LazyFrame.describe_optimized_plan() para ver el plan optimizado)

  CSV SCAN data_sample.csv
  PROJECT */4 COLUMNS

Para ejecutar este plan y cargar los datos en la memoria, debes usar el método collect():

df_perezoso = consulta.collect()
print(df_perezoso)

Más que solo leer CSVs: Manipulación de datos

Más allá de simplemente leer CSVs, Polars ofrece un conjunto completo de funciones de manipulación de datos que se alinean bien con las operaciones de pandas. Esto hace que Polars sea una herramienta eficiente y versátil para el análisis de datos. Ya sea filtrando datos, aplicando transformaciones o agregando información, Polars puede manejar todo con un gran rendimiento.

Visualizar tu DataFrame de Polars con PyGWalker

PyGWalker (opens in a new tab) es una biblioteca de Python de código abierto que puede ayudarte a crear visualizaciones de datos a partir de tu DataFrame de Polars con facilidad.

(opens in a new tab)

¡Ya no necesitas realizar procesamiento complicado con programación en Python! Simplemente importa tus datos y arrastra y suelta variables para crear todo tipo de visualizaciones de datos. Aquí tienes un video rápido sobre la operación:

Así es cómo puedes usar PyGWalker en tu Jupyter Notebook:

pip install pygwalker
import pygwalker as pyg
gwalker = pyg.walk(df)

Alternativamente, puedes probarlo en Kaggle Notebook/Google Colab:

Ejecutar PyGWalker en Kaggle Notebook (opens in a new tab)	Ejecutar PyGWalker en Google Colab (opens in a new tab)	Dale ⭐️ a PyGWalker en GitHub (opens in a new tab)
(opens in a new tab)	(opens in a new tab)	(opens in a new tab)

PyGWalker se construye con el apoyo de nuestra comunidad de código abierto. ¡No olvides visitar PyGWalker GitHub (opens in a new tab) y darnos una estrella!

Preguntas frecuentes:

Mientras navegas por Polars, es posible que te encuentres con algunas preguntas. Aquí tienes algunas de las más comunes:

1. ¿Cuál es la diferencia principal entre las funciones read_csv() y scan_csv() en Polars?

read_csv() es una función directa que lee un archivo CSV y carga todos los datos en la memoria. Por otro lado, scan_csv() opera de forma perezosa, lo que significa que no carga los datos hasta que se llama a collect(). Esto hace que scan_csv() sea más eficiente al trabajar con conjuntos de datos grandes, ya que solo carga los datos necesarios en la memoria.

2. ¿Polars puede manejar el análisis de fechas al leer archivos CSV?

Sí, Polars puede manejar el análisis de fechas. Al usar la función read_csv(), simplemente establece el argumento parse_dates=True y Polars intentará analizar automáticamente las columnas con información de fechas.

3. ¿Puedo cambiar el tipo de dato de columnas específicas al leer un archivo CSV?

Absolutamente. Polars te permite modificar los tipos de dato de las columnas durante el proceso de lectura del archivo CSV. Puedes usar el método with_columns() junto con la función cast() para lograr esto. Por ejemplo, df = pl.read_csv('data.csv').with_columns(pl.col('Age').cast(pl.Int32)) cambiará la columna 'Age' a tipo de dato Int32.