A medida que el panorama de la ciencia de datos se vuelve más complejo, con tecnologías nuevas cada día, elegir bien tu caja de herramientas es clave para el proyecto. Cuanto más complejo sea, más cuidado deberás tener al escoger los recursos, porque tus decisiones impactarán de forma importante en el desarrollo y, en última instancia, en el éxito del proyecto.
Si estás trabajando en un proyecto de ciencia de datos, las decisiones de diseño van mucho más allá del debate Python vs R. También se trata de qué librerías usar una vez definido el lenguaje de programación sobre el que se basará tu proyecto.
En el caso de Python para ciencia de datos, pandas es la herramienta estándar de facto para la manipulación de datos. Las razones para usar pandas son numerosas y convincentes, pero también tiene limitaciones que pueden generar cuellos de botella importantes. En particular, pandas es conocido por su rendimiento limitado con conjuntos de datos muy grandes.
Para abordar estos problemas, pandas ha lanzado recientemente su versión 2.0, con revisiones importantes y mejoras de rendimiento (echa un vistazo a este artículo para saber todo lo que debes saber sobre pandas 2.0).
Mientras tanto, han surgido alternativas en el ecosistema de Python que cuestionan el dominio de pandas. Una de las más populares es polars, una librería basada en Python y Rust para realizar análisis de datos más rápidos.
En este artículo analizaremos las diferencias entre pandas 2.0 y polars para la manipulación de datos. Empezaremos con un repaso de estrategias para mejorar el rendimiento computacional y cerraremos con una serie de pruebas para comparar el rendimiento de ambas herramientas. ¡Vamos allá!
Cómo elegir entre pandas y polars
No existe una tecnología que sea la mejor en términos absolutos para resolver todos los problemas y situaciones que pueden surgir en tus flujos de trabajo de ciencia de datos. Hay que equilibrar distintos factores antes de decidir. Estos son algunos de los más relevantes:
- Rendimiento computacional. Como regla general, cuanto más grande y complejo sea el proyecto, más deberías valorar herramientas de alto rendimiento para evitar cuellos de botella.
- Encaje con tu stack tecnológico. Las herramientas de un proyecto de ciencia de datos rara vez funcionan de forma aislada. Operan en combinación con el resto del stack. Antes de elegir, valora las sinergias y el encaje entre tecnologías.
- Compatibilidad de código. Adoptar una tecnología nueva también implica pensar en la compatibilidad y la eficiencia del código. Si adoptar una herramienta supone reescribir código en proyectos existentes, debes incluirlo en la ecuación.
- Popularidad. La popularidad es un indicador del número de personas que la usan, lo que puede ser ventajoso para contratar talento o resolver dudas en plataformas como Stack Overflow.
¿Cómo mejorar el rendimiento en la manipulación de datos?
En esta sección cubrimos las técnicas principales que ayudan a aumentar el rendimiento en la manipulación de datos.
Reducir copias con copy-on-write
En las herramientas tradicionales de manipulación de datos, cada operación genera una copia nueva de toda la base de datos. Este comportamiento puede ser problemático para la memoria cuando trabajas con datasets grandes.
Copy-on-write es la técnica más habitual para resolverlo. En esencia, es una estrategia de gestión de recursos que permite implementar de forma eficiente una operación de "duplicado" o "copia" sobre recursos modificables. Es decir, si un dataset se duplica pero no se modifica (por completo), no es necesario crear un recurso nuevo: la memoria puede compartirse entre la copia y el original.
Cómputo en paralelo
Una de las principales desventajas de pandas es que es monohilo, lo que impide aprovechar técnicas de computación paralela, comunes hoy en ciencia de datos. La paralelización puede hacerse con máquinas multi‑núcleo o con computación distribuida (un conjunto de equipos trabajando en clúster).
Toma este ejemplo con la popular operación group by. Si quieres calcular la edad media de jugadores de baloncesto agrupada por equipos, podrías usar computación paralela para asignar el cálculo de la media de cada grupo a un núcleo o máquina, en lugar de calcularlos uno a uno, aumentando así el rendimiento.
Optimizar la importación de datos
El punto de partida suele ser leer los datasets que quieres analizar. Sin embargo, esto a menudo es un cuello de botella cuando hay grandes volúmenes de datos. Algunas técnicas para mejorar el rendimiento al leer archivos:
- Lectura por bloques (chunking). En lugar de leer el archivo completo, puedes dividirlo en trozos (chunks). Así importas más rápido y reduces la memoria necesaria para almacenarlo todo a la vez.
- Leer solo las columnas necesarias. Si sabes de antemano qué columnas vas a usar, aplica un filtro preliminar y lee únicamente las requeridas.
- Reducir el tamaño de los tipos de datos (downcasting). Herramientas como pandas asignan por defecto ciertos tipos a las columnas importadas. A veces hay tipos alternativos que consumen menos memoria sin perder información. El downcasting consiste en cambiar a los tipos más pequeños que soporten sus valores.
Evaluación perezosa (lazy) y planificación de consultas
El orden de las operaciones afecta al rendimiento. A menudo puedes reordenar cálculos y obtener el mismo resultado de forma más eficiente.
Hay dos estrategias: la evaluación perezosa (lazy), que retrasa los cálculos hasta que son estrictamente necesarios, y la planificación de consultas, que busca la forma más eficiente de ejecutar múltiples manipulaciones de datos dadas varias consultas. Para ello, la planificación suele usar un optimizador de consultas.
Procesamiento out-of-core
Herramientas como pandas almacenan datasets completos en memoria, lo que da problemas si trabajas con datos que no caben en la memoria del equipo o con operaciones muy intensivas en memoria.
Aquí entra en juego el procesamiento out-of-core. En pocas palabras, se refiere a usar memoria externa (p. ej., un disco externo) para almacenar datos que no caben en la memoria principal. El procesamiento out-of-core permite procesar datos almacenados externamente por bloques, obteniendo finalmente los mismos resultados que si lo hicieses todo en tu equipo.
¿Qué alternativas de alto rendimiento hay a pandas?
Este artículo se centra en la comparación entre pandas 2.0 y polars, pero conviene mencionar otras herramientas que pueden encajar como alternativa a pandas. Algunas de las más prometedoras:
- Koalas. Una API de pandas sobre PySpark. Si usas Spark, deberías considerarla.
- Vaex. API de pandas para cómputo out-of-memory, ideal para analizar grandes datos tabulares a miles de millones de filas por segundo.
- Modin. API de pandas para programación en paralelo, basada en Dask o Ray para proyectos de big data. Si usas Dask o Ray, Modin es un gran recurso.
- cuDF. Parte de RAPIDS, una API similar a pandas para cómputo en GPU que se apoya en GPUs de NVIDIA u otros componentes de RAPIDS para manipular datos a gran velocidad.
¿Por qué elegir polars?
Pandas es la opción preferida de quienes trabajan con datos en Python, pero, como ya hemos visto, presenta limitaciones importantes con datasets grandes. La misión de polars es ofrecer una librería de dataframes ultrarrápida que resuelva los problemas de pandas.
Escrita en Rust (un potente lenguaje que ofrece rendimiento tipo C/C++ y permite controlar por completo las partes críticas del motor de consultas), polars integra metodologías de vanguardia para aumentar el rendimiento, diseñadas para:
- Potenciar la computación paralela y aprovechar todos los núcleos disponibles de tu máquina.
- Optimizar consultas para reducir trabajo y asignaciones de memoria innecesarias mediante evaluación perezosa y planificación de consultas.
- Mejorar el rendimiento de almacenamiento usando semántica copy‑on‑write y Apache Arrow.
- Manejar datasets mucho mayores gracias a sus capacidades out‑of‑core mediante su API de streaming.
Por último, una ventaja importante de polars es su sintaxis, bastante similar a la de pandas, y que comparte bloques básicos como Series y DataFrames. Si decides pasarte a polars, te resultará más sencillo.
¿Cómo responde pandas a la mayor competencia con pandas 2.0?
Para mejorar su rendimiento y contrarrestar la presión de la competencia, pandas ha lanzado la esperada versión 2.0. Al ser una actualización mayor, pandas 2.0 trae un abanico de novedades e introduce deprecaciones forzadas que cambian partes de la API.
La gran apuesta para atajar las limitaciones de rendimiento es el nuevo backend PyArrow. Ahora puedes elegir entre el backend tradicional de NumPy o el nuevo backend de PyArrow. PyArrow es una librería de Python que ofrece una interfaz para manejar grandes datasets usando estructuras de memoria Arrow.
pd.read_csv(my_file, engine='pyarrow')Otra novedad importante es la incorporación de varias mejoras de copy‑on‑write orientadas a ganar rendimiento ahorrando memoria.
Como resultado, muchas operaciones de pandas incluyen ahora un parámetro "copy" por defecto que devuelve una copia perezosa de objetos básicos de pandas, como series y dataframes, en lugar de copias idénticas materializadas en caché.
Aún es pronto para saber si las nuevas capacidades de pandas resolverán sus problemas de rendimiento. Incluso si otras herramientas lo superan, seguirá habiendo buenas razones para usar pandas: no tendrás que reescribir código existente ni aprender nuevas sintaxis porque probablemente ya lo utilizas.
pandas 2.0 vs polars: marco de comparación
Ahora que ya tienes la teoría, toca mancharse las manos. En las siguientes secciones haremos una serie de pruebas para comparar el rendimiento de pandas 2.0 y polars. Nuestro benchmark será el tiempo necesario para completar cada tarea. Para ello usaremos el módulo time, que permite calcular tiempos de ejecución de forma sencilla.
Además del rendimiento, analizaremos la compatibilidad de código de polars con pandas (es decir, ¿cuánto código debes cambiar si quieres pasarte a polars?).
El dataset
Probamos el rendimiento de pandas 2.0 y polars con un dataset ficticio de ventas por hora de una empresa con oficinas en distintos países entre 1980 y 2022. Para añadir complejidad al benchmark, incluimos valores ausentes aleatorios.
En total, el dataset supera los 22 millones de filas y ocupa más de 1,6 GB en memoria, suficiente para poner a pandas contra las cuerdas. Puedes encontrar todo el código de las pruebas en este cuaderno de DataLab.
Prueba de importación
Empecemos comparando el rendimiento de pandas 2.0 y polars al importar datos. Polars presume de un gran rendimiento al importar desde CSV. ¿Se sostiene?
Haremos una prueba para medir cuánto tardan pandas y polars en leer un subconjunto de columnas y filas. Por ejemplo, supón que solo quieres analizar las ventas de la oficina de Francia. Con pandas, tendrás que leer todas las filas y luego filtrar para eliminar las que no interesan. Usaremos el nuevo método .query() para ello. Para probar el comportamiento de pandas 2.0, importaremos el CSV tanto con el motor clásico de numpy como con el nuevo de pyarrow.
En cambio, polars ofrece el método filter(), que puedes combinar con condiciones para leer únicamente las filas de tu interés.
# pandas query
df_pd = pd.read_csv("./example.csv", engine="pyarrow")
df_pd = df_pd[['id', 'date', 'office', 'sales']]
df_pd = df_pd.query("office=='France'")
# polars filter
df_pl = pl.read_csv('example.csv').filter(
(pl.col('office') == 'France'))
df_pl.select(pl.col(['id', 'date', 'office', 'sales']))
Al ejecutar la prueba, polars rinde considerablemente mejor que pandas, como muestra el gráfico. Sorprendentemente, el motor pyarrow no arrojó mejores resultados que el motor estándar de numpy.
En cuanto a la compatibilidad de sintaxis, polars tiene claramente un aire a pandas, con funciones como pl.read_csv() que reflejan a la perfección a pandas. Sin embargo, ambas librerías funcionan de forma distinta bajo el capó, lo que inevitablemente lleva a diferencias de sintaxis, como se ve con los métodos query() vs filter().
Prueba de group by
Las operaciones de groupby son candidatas ideales para paralelizar. Veamos cómo se comportan pandas y polars en varias operaciones agregadas por grupos. En particular, calcularemos la media y la mediana de ventas por oficina y mes.
df_pd.groupby([df_pd.office, df_pd.date.dt.month])['sales'].agg('mean') # pandas groupby mean
df_pl.groupby([pl.col('office'), pl.col('date').dt.month()]).agg([pl.mean('sales')]) # polars groupby mean
df_pd.groupby([df_pd.office, df_pd.date.dt.month])['sales'].agg('median') # pandas groupby median
df_pl.groupby([pl.col('office'), pl.col('date').dt.month()]).agg([pl.median('sales')]) pandas groupby median
Los resultados muestran que, en cálculos de agrupación y agregación, polars supera a pandas. De nuevo, la sintaxis de polars recuerda a la de pandas.
Prueba de estadísticas móviles
Otra operación interesante para probar el rendimiento de pandas y polars son las estadísticas móviles. Optimizar este tipo de cómputos exige bastante trabajo algorítmico. Veamos cómo se comportan al calcular una media móvil diaria de ventas.
# pandas rolling mean
df_pd['sales'].rolling(1440, min_periods=1).mean()
# polars rolling mean
df_pl['sales'].rolling_mean(1440, min_periods=1)De nuevo, polars es el ganador. Fíjate en la sutil diferencia de sintaxis: polars incluye el método rolling_mean(), mientras que pandas utiliza rolling(), que debe combinarse con otros métodos, como mean(), para obtener el mismo resultado.
Prueba de muestreo
Estudiar toda una población rara vez es posible. Por eso el muestreo es una de las tareas más comunes en estadística y ciencia de datos. Consiste en tomar muestras aleatorias mediante técnicas de simulación de Monte Carlo, como bootstrapping y permutaciones. Sin embargo, esta operación suele implicar muchas copias de variables, lo que puede ser un reto si te faltan recursos de cómputo.
Veamos cómo trabajan pandas y polars al realizar un bootstrap, es decir, remuestreo con reemplazo. Estimaremos la media de las ventas en 10000 muestras de 1000 datos cada una.
#pandas bootstrap
simu_weights = []
for i in range(10000):
bootstrap_sample = random.choices(df_pd['sales'], k=1000)
simu_weights.append(np.nanmean(bootstrap_sample))
#polars bootstrap
simu_weights = []
for i in range(10000):
bootstrap_sample = df_pl['sales'].sample(n=1000,with_replacement=True)
simu_weights.append(bootstrap_sample.mean())En el muestreo bootstrap, polars es casi 5 veces más rápido que pandas.
En cuanto a sintaxis, mientras pandas se apoya en numpy para muestrear, polars incorpora un práctico método sample() integrado.
Manipulaciones encadenadas
En la última prueba realizaremos una serie de manipulaciones de datos encadenadas. Esto forma parte del día a día de los profesionales de datos. Aun así, las operaciones que implican muchos pasos son fáciles de escribir de forma subóptima.
Imagina que la oficina de Italia de nuestra empresa ficticia está valorando contratar a parte de las personas en prácticas de 2022 al término de su periodo de formación. Nuestro objetivo es analizar qué becarios realizaron las diez mayores operaciones de venta de 2022 para elegir a las personas más adecuadas.
Para ello, debemos unir nuestro dataset con un segundo dataset, llamado "italy_2022", que contiene información sobre quién realizó cada transacción en 2022. La columna "id" es común a ambos datasets.
# pandas compound operations
df_pd.merge(italy_2022, on='id').query("responsibility =='Sales Intern'").sort_values('sales', ascending=False).head(10)[['name','surname','sales','sex']]
#polars compound manipulations
df_pl.join(italy_2022_pl, on="id").filter(pl.col('responsability') == 'Sales Intern').sort('sales',descending=True).head(10).select(pl.col(['name','surname','sales','sex']))
Como en las pruebas anteriores, polars supera a pandas en rendimiento. En este caso, la operación de join parece ser el mayor escollo de pandas. En cambio, polars es mucho más eficiente y tarda menos de dos segundos en completar todas las tareas encadenadas.
Tabla comparativa: pandas 2.0 vs polars
Resumimos las pruebas en esta tabla para una comparación rápida:
|
Prueba |
Pandas 2.0 |
Polars |
Ganador |
Similitud de sintaxis |
|
Prueba de importación |
Lee todas las filas y después filtra las no deseadas con .query() |
Lee directamente solo las filas de interés con filter() |
Polars (mejor rendimiento) |
Parecida, con diferencias por la implementación (.query() vs filter()) |
|
Prueba de group by |
Usa .groupby() para agregaciones como media y mediana de ventas por oficina y mes |
Igual que pandas, pero con mejor rendimiento |
Polars (mejor rendimiento) |
Similar |
|
Prueba de estadísticas móviles |
Usa rolling() combinado con otros métodos, como mean(), para medias móviles |
Usa rolling_mean() para calcular medias móviles |
Polars (mejor rendimiento) |
Similar, con diferencias sutiles (.rolling().mean() vs rolling_mean()) |
|
Prueba de muestreo |
Usa numpy para operaciones de bootstrap |
Usa el método integrado sample() para bootstrap |
Polars (casi 5 veces más rápido) |
Diferente: pandas depende de numpy; polars tiene métodos propios |
|
Prueba de manipulaciones encadenadas |
Realiza un join con otro dataset y después ordena y selecciona |
Hace lo mismo pero de forma más eficiente |
Polars (significativamente más rápido) |
Similar, con diferencias (merge().query().sort_values().head() vs join().filter().sort().head().select()) |
Llévalo al siguiente nivel
Enhorabuena por llegar al final de este tutorial. Según las pruebas, polars rinde considerablemente mejor que pandas 2.0 en casi todos los tests. Aunque esto supone una amenaza real a su dominio, pandas sigue teniendo la ventaja de ser la opción de referencia para manipulación de datos en Python, con todos los beneficios de una comunidad de usuarios más amplia.
Si trabajas con datasets grandes, mejorar el rendimiento es imprescindible. DataCamp te cubre. Aquí tienes algunos cursos para llevar tu rendimiento de cómputo al siguiente nivel:
