Skip to content

Polars DataFrame: Introducción al procesamiento de datos de alta velocidad

Adentrándose más allá de los reinos familiares de Pandas, los entusiastas de Python ahora están adoptando las capacidades de procesamiento de datos de alta velocidad y eficiencia de Polars DataFrame. Ofreciendo un conjunto de herramientas formidable para gestionar grandes conjuntos de datos, esta librería de DataFrame, construida completamente en Rust, está ganando terreno entre científicos de datos y analistas. Esta guía exhaustiva profundiza en el DataFrame de Polars, impartiendo una comprensión más profunda de sus funcionalidades y mostrando cómo se presenta como una alternativa superior a Pandas.

Aprovechando Polars sobre Pandas

Una rápida comparación revela las ventajas distintivas de Polars sobre Pandas. A diferencia de Pandas, Polars se abstiene de usar un índice para el DataFrame, lo que hace considerablemente más sencilla la manipulación de datos. Además, Polars utiliza matrices de Apache Arrow para la representación interna de datos, mejorando los tiempos de carga, el uso de memoria y la eficiencia computacional. Además, al estar escrito en Rust, Polars ofrece más operaciones paralelas, acelerando muchas tareas. Y no hay que olvidar que Polars admite evaluación perezosa, optimizando las consultas según sea necesario y minimizando el uso de memoria, una característica no disponible en la evaluación ávida de Pandas.

Comenzando con Polars DataFrame

La instalación de Polars es sencilla. Puedes usar los comandos pip o conda:

pip install polars
conda install polars

Vamos a empezar nuestro viaje creando un DataFrame de Polars. A continuación, estamos importando el módulo de Polars y creando un DataFrame:

import polars as pl
 
df = pl.DataFrame(
    {
        'Modelo': ['iPhone X','iPhone XS','iPhone 12','iPhone 13','Samsung S11','Samsung S12','Mi A1','Mi A2'],
        'Ventas': [80,170,130,205,400,30,14,8],     
        'Compañía': ['Apple','Apple','Apple','Apple','Samsung','Samsung','Xiao Mi','Xiao Mi'],
    }
)
df

A diferencia de Pandas, Polars espera que los nombres de las columnas sean de tipo cadena. Si quieres usar enteros como nombres de columnas, asegúrate de usarlos como cadenas:

df2 = pl.DataFrame(
    {
        "0" : [1,2,3],
        "1" : [80,170,130],
    }
)

El tipo de datos de cada columna en Polars también se muestra junto al nombre de la columna. Si quieres mostrar explícitamente el tipo de datos de cada columna, puedes usar la propiedad dtypes:

df.dtypes

Para obtener los nombres de las columnas, puedes usar la propiedad columns:

df.columns    # Devuelve ['Modelo', 'Ventas', 'Compañía']

Para obtener el contenido del DataFrame como una lista de tuplas, usa el método rows():

df.rows()

Una característica crucial a tener en cuenta es que Polars no utiliza el concepto de índice, a diferencia de Pandas. La filosofía de diseño de Polars establece explícitamente que el índice no es particularmente útil en DataFrames.

Desentrañar la selección de columnas en Polars

Seleccionar columnas en Polars es sencillo. Especifica el nombre de la columna usando el método select():

df.select('Modelo')

La declaración devuelve un DataFrame de Polars que contiene la columna 'Modelo'. Sin embargo, Polars desaconseja el uso del método de indexación con corchetes y sus futuras versiones incluso podrían eliminar esta característica. Para seleccionar múltiples columnas, proporciona los nombres de las columnas como una lista:

df.select(['Modelo','Compañía'])

El poder de las expresiones es otra característica importante de Polars. Por ejemplo, para recuperar todas las columnas enteras (específicamente Int64) en el DataFrame, puedes usar una expresión dentro del método select():

df.select(pl.col(pl.Int64))

Polars tiene una forma única de encadenar expresiones. Por ejemplo, la siguiente expresión selecciona las columnas 'Modelo' y 'Ventas' y luego ordena las filas según los valores de la columna 'Ventas':

df.select(pl.col(['Modelo','Ventas']).sort_by('Ventas'))    

Si quieres recuperar todas las columnas de tipo cadena, usa la propiedad pl.Utf8:

df.select([pl.col(pl.Utf8)])

Las expresiones en Polars se explicarán más adelante en la siguiente parte del artículo.

Descubriendo la selección de filas en Polars

Para seleccionar una sola fila en un DataFrame, pasa el número de fila usando el método row():

df.row(0)   # obtener la primera fila

Esto devuelve una tupla:

('iPhone X', 80, 'Apple')

Para seleccionar varias filas, Polars recomienda usar la función filter(). Por ejemplo, si deseas recuperar todos los productos de Apple, puedes usar la siguiente expresión:

df.filter(pl.col('Compañía') == 'Apple')

Puedes especificar múltiples condiciones usando operadores lógicos:

df.filter((pl.col('Compañía') == 'Apple') | (pl.col('Compañía') == 'Samsung'))

En Polars, puedes usar los siguientes operadores lógicos:

  • | — OR
  • & — AND
  • ~ — Not

Seleccionar filas y columnas simultáneamente

A menudo, querrás seleccionar filas y columnas simultáneamente. Encadena los métodos filter() y select() para lograr esto:

df.filter(pl.col('Compañía') == 'Apple').select('Modelo')

La declaración anterior selecciona todas las filas que contienen 'Apple' y luego muestra solo la columna 'Modelo'. Para mostrar también la columna 'Ventas', pasa una lista al método select():

df.filter(pl.col('Compañía') == 'Apple').select(['Modelo','Ventas'])

La esencia de la historia es que Polars DataFrame proporciona una alternativa eficiente y de alta velocidad a Pandas tradicional, aprovechando su evaluación perezosa, su política de no índices y sus capacidades de operación paralela. Desde instalaciones sencillas hasta manipulaciones complejas de datos, Polars se presenta como una herramienta poderosa que simplifica la manipulación de datos y mejora el uso de memoria.

Visualiza tu DataFrame de Polars con PyGWalker

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

PyGWalker para visualización de datos (opens in a new tab)

¡Ya no es necesario completar un procesamiento complicado con código Python, simplemente importe sus datos y arrastre y suelte variables para crear todo tipo de visualizaciones de datos! Aquí hay un video de demostración rápida sobre el funcionamiento:


Así es cómo usar PyGWalker en su 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)Darle a PyGWalker una ⭐️ en GitHub (opens in a new tab)
Ejecutar PyGWalker en Kaggle Notebook (opens in a new tab)Ejecutar PyGWalker en Google Colab (opens in a new tab)Ejecutar PyGWalker en Google Colab (opens in a new tab)

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

Preguntas frecuentes

  1. ¿Cuáles son algunas ventajas importantes de Polars sobre Pandas?

    El DataFrame de Polars ofrece varias ventajas sobre Pandas. Utiliza arreglos de Apache Arrow para manejar eficientemente los datos, no depende de índices para la manipulación de datos, admite operaciones paralelas y emplea la evaluación perezosa para optimizar las consultas según los requisitos, mejorando el uso de la memoria.

  2. ¿Cómo puedo seleccionar columnas en el DataFrame de Polars?

    El DataFrame de Polars proporciona el método select() para elegir columnas. Puede pasar el nombre de la columna como una cadena para seleccionar una sola columna o una lista de nombres de columnas para seleccionar múltiples columnas.

  3. ¿Cómo puedo filtrar filas en función de condiciones específicas en Polars?

    El método filter() se utiliza para seleccionar filas en función de condiciones específicas. Puede pasar una expresión a este método que iguala una columna a un cierto valor para filtrar filas. También puede utilizar operadores lógicos para especificar múltiples condiciones.