PySpark para usuarios de Pandas | Hacia la ciencia de datos

un problema real cuando se trata de conjuntos de datos muy grandes. Lo que quiero decir con “muy grandes” son datos que exceden la capacidad de la RAM de una sola máquina.

Algunos de los puntos de fricción clave que enfrentan los usuarios de Pandas incluyen:

Restricciones en memoria

Pandas requiere que todo el conjunto de datos que está procesando esté en la memoria de acceso aleatorio (RAM) de la máquina. No puede procesar fácilmente los datos almacenados en un disco duro a menos que se cargue primero, y si esos datos son demasiado grandes para su memoria, tendrá problemas.

Por ejemplo, si intenta cargar un archivo CSV de 100 GB en Pandas en una computadora portátil estándar con 16 GB de RAM, el código fallará inmediatamente.

Y no es sólo una proporción de 1:1. Debido a los tipos de datos y la sobrecarga de objetos, Pandas generalmente requiere varios múltiplos de la RAM requerida por el tamaño del archivo en el disco. Con 16 GB de RAM, el límite de tamaño de archivo puede ser tan bajo como 3-4 GB.

Ejecución de un solo subproceso

Pandas fue diseñado para conveniencia y análisis, no para escalar el rendimiento en bruto. De forma predeterminada, Pandas ejecuta operaciones en un único núcleo de CPU. Incluso si un usuario ejecuta su código en un servidor potente con 64 núcleos, Pandas utilizará en gran medida solo uno, dejando los demás inactivos.

Ejecución ansiosa versus evaluación perezosa

Pandas utiliza Eager Execution, lo que significa que realiza cálculos tan pronto como se ejecuta el código. Las herramientas de Big Data (como Apache Spark) utilizan Lazy Evaluación. Esto último suele tener más rendimiento que la ejecución entusiasta porque cuando se requieren una serie de pasos para realizar alguna tarea, la evaluación diferida puede observar todos los pasos y el resultado final requerido y optimizarlos adecuadamente. La ejecución ansiosa no puede hacer eso. Ejecuta ciegamente cada paso por turno, pase lo que pase.

Límites de escala vertical

Para que Pandas funcione con conjuntos de datos más grandes, debe confiar en el escalado vertical (comprar una computadora más cara con más RAM y una CPU más rápida). Pero esto sólo puede llevarte hasta cierto punto. Por ejemplo, Pandas no tiene la capacidad nativa de "hablar" con un clúster. No puede distribuir un marco de datos entre varias máquinas.

Entonces, ¿qué hacer?

Como siempre en el mundo de las tecnologías de la información, se presentan varias soluciones. Tres de las alternativas más populares son: –

1/ Dask o Rayo

Estas son bibliotecas de terceros que le ayudan a escribir código distribuido que puede ejecutarse en grupos de computadoras. Si bien estos intentan imitar la API de Pandas, todavía tienen diferencias y limitaciones sutiles que pueden requerir una refactorización del código.

2/ Spark: otro motor informático distribuido. Requiere una sintaxis diferente y un modelo mental diferente.

3/ RDBMS: Requiere mover sus datos a una base de datos y aprender SQL.

Todas las opciones anteriores requieren bastante trabajo para implementarse, pero durante el resto de este artículo, me concentraré en la opción 2.

Entonces, digamos que lo he convencido, o al menos despertado su interés, y está considerando trasladar parte o todo su procesamiento existente basado en Pandas a PySpark. ¿Cuál debería ser tu próximo paso? Bueno, necesitarás comenzar a convertir parte o la totalidad de tu código base. Esto puede resultar desalentador, pero no te preocupes, lo tengo cubierto.

Continúe leyendo mientras le explico una serie de fragmentos de código de ejemplo que muestran algunas operaciones típicas de procesamiento de datos, desde las más fáciles hasta las más complejas. Estoy seguro de que reconocerá algunos de estos patrones en su propio código. Le mostraré la forma en que Pandas hace las cosas y la replicaré en PySpark, proporcionando comparaciones de resultados y tiempos entre los dos.

Configurar el entorno de desarrollo

Estoy ejecutando Ubuntu en WSL2. Primero, configuraremos un entorno de desarrollo separado para este trabajo, asegurando que nuestros proyectos estén aislados y no interfieran entre sí. Estoy usando Conda para esta parte, pero siéntete libre de usar cualquier método al que estés acostumbrado.

Instale PySpark, Pandas, etc.

(base) $ conda create -n pandas_to_pyspark python=3.11 -y (base) $ conda active pandas_to_pyspark (pands_to_pyspark) $ conda install jupyter polars pyarrow pandas -y (pands_to_pyspark) $ conda install -c conda-forge pyspark

Para verificar que PySpark se haya instalado correctamente, escriba el comando pyspark en una ventana de terminal.

(pands_to_pyspark) pyspark Python 3.11.14 | empaquetado por conda-forge | (principal, 22 de octubre de 2025, 22:46:25) [GCC 14.3.0] en Linux Escriba "ayuda", "derechos de autor", "créditos" o "licencia" para obtener más información. ADVERTENCIA: Uso de módulos de incubadora: jdk.incubator.vector ADVERTENCIA: el paquete sun.security.action no está en java.base Uso del perfil log4j predeterminado de Spark: org/apache/spark/log4j2-defaults.properties 26/01/15 16:15:21 ADVERTENCIA Utilidades: su nombre de host, tpr-desktop, se resuelve en una dirección de bucle invertido: 127.0.1.1; usando 10.255.255.254 en su lugar (en la interfaz baja) 26/01/15 16:15:21 Utilidades WARN: configure SPARK_LOCAL_IP si necesita vincularse a otra dirección Usando el perfil log4j predeterminado de Spark: org/apache/spark/log4j2-defaults.properties Configuración del nivel de registro predeterminado en "WARN". Para ajustar el nivel de registro, utilice sc.setLogLevel(newLevel). Para SparkR, utilice setLogLevel(newLevel). 26/01/15 16:15:22 ADVERTENCIA NativeCodeLoader: No se puede cargar la biblioteca nativa-hadoop para su plataforma… usando clases integradas de Java cuando corresponda ADVERTENCIA: Se ha llamado a un método obsoleto terminal en sun.misc.Unsafe ADVERTENCIA: sun.misc.Unsafe::arrayBaseOffset ha sido llamado por org.apache.spark.unsafe.Platform (archivo:/home/tom/miniconda3/envs/pandas_to_pyspark/lib/python3.11/site-packages/pyspark/jars/spark-unsafe_2.13-4.1.1.jar) ADVERTENCIA: Considere informar esto a los mantenedores de la clase org.apache.spark.unsafe.Platform ADVERTENCIA: sun.misc.Unsafe::arrayBaseOffset se eliminará en una versión futura Bienvenido a ____ __ / __/__ ___ _____/ /__ _ / _ / _ `/ __/ '_/ /__ / .__/_,_/_/ /_/_ versión 4.1.1 /_/ Uso de Python versión 3.11.14 (principal, 22 de octubre de 2025 22:46:25) Interfaz de usuario web de contexto Spark disponible en http://10.255.255.254:4040 Contexto de Spark disponible como 'sc' (master = local[*], ID de aplicación = local-1768493723158). SparkSession disponible como 'spark'. >>>

Si no ve el banner de bienvenida de Spark, entonces algo salió mal y debe volver a verificar su instalación.

Obteniendo nuestro conjunto de datos de muestra

No necesitamos un conjunto complicado para nuestros propósitos. Será suficiente un conjunto de datos sintéticos de ventas con el siguiente esquema:

order_id (int) order_date (fecha) customer_id (int) customer_name (str) product_id (int) product_name (str) categoría (str) cantidad (int) precio (flotante) total (flotante)

Nuestros datos de entrada serán un archivo CSV de 30 millones de registros. Aquí hay un programa Python para generar los datos de prueba:

importar polares como pl importar aleatorio desde fecha y hora importar fecha y hora, timedelta # Generar datos falsos def generate_fake_data(num_records): random.seed(42) product_names = ['Laptop', 'Smartphone', 'Escritorio', 'Silla', 'Monitor', 'Impresora', 'Papel', 'Pluma', 'Cuaderno', 'Cafetera'] categorías = ['Electrónica', 'Electrónica', 'Oficina', 'Oficina', 'Electrónica', 'Electrónica', 'Oficina', 'Oficina', 'Oficina', 'Electrónica'] datos = { 'order_id': rango(num_records), 'order_date': [datetime(2023, 1, 1) + timedelta(days=random.randint(0, 364)) for _ in range(num_records)], 'customer_id': [random.randint(100, 999) para _ en range(num_records)], 'customer_name': [f'Customer_{random.randint(0, 99999)}' para _ in range(num_records)], 'product_id': [random.randint(200, 209) para _ in rango(num_records)], 'nombre_producto': [random.choice(nombres_productos) para _ en rango(num_records)], 'categoría': [random.choice(categorías) para _ en rango(num_records)], 'cantidad': [random.randint(1, 10) para _ en rango(num_records)], 'precio': [round(random.uniform(1.99, 999.99), 2) for _ in range(num_records)] } df = pl.DataFrame(data) df = df.with_columns((pl.col('price') * pl.col('cantidad')).alias('total')) return df # Generar 30 millones de registros num_records = 30000000 df = generate_fake_data(num_records) # Guardar en CSV df.write_csv('/mnt/d/sales_data/sales_data_30m.csv') print('Se ha creado un archivo CSV con datos de ventas falsos.')

Así es como se veían las primeras filas de mi archivo de datos de prueba.

order_id,order_date,customer_id,customer_name,product_id,product_name,categoría,cantidad,precio,total 0,2023-11-24T00:00:00.000000,434,Customer_46318,201,Notebook,Office,6,925.68,5554.08 1,2023-02-27T00:00:00.000000,495,Cliente_26514,203,Cafetera,Oficina,3,676.44,2029.3200000000002 2,2023-01-13T00:00:00.000000,377,Cliente_56676,204,Bolígrafo,Electrónica,10,533.2,5332.0 3,2023-05-21T00:00:00.000000,272,Cliente_13772,209,Portátil,Electrónica,5,752.0,3760.0 4,2023-05-06T00:00:00.000000,490,Cliente_23118,206,Cafetera,Electrónica,3,747.46,2242.38 5,2023-04-25T00:00:00.000000,515,Cliente_88284,202,Escritorio,Electrónica,10,886.22,8862.2 6,2023-03-13T00:00:00.000000,885,Cliente_47303,200,Escritorio,Electrónica,1,38.97,38.97 7,2023-02-22T00:00:00.000000,598,Cliente_90712,203,Escritorio,Electrónica,5,956.31,4781.549999999999 8,2023-12-13T00:00:00.000000,781,Cliente_32943,205,Cafetera,Electrónica,7,258.25,1807.75 9,2023-10-07T00:00:00.000000,797,Cliente_40215,208,Bolígrafo,Electrónica,8,464.81,3718.48 10,2023-02-14T00:00:00.000000,333,Cliente_18388,209,Monitor,Electrónica,1,478.95,478.95

Ejemplos de código

Inicie un Jupyter Notebook:

(pands_to_pyspark) $ cuaderno jupyter

Los datos y los dos conjuntos de códigos que ejecutaré están en mi PC de escritorio. Mostraré los resultados de ambas ejecuciones de código para que pueda verificar que realizan la misma tarea e incluiré tiempos (en segundos) para que pueda comparar el rendimiento. Primero el código y la salida de Pandas, luego el código y la salida de Spark.

Los fragmentos de código son breves y están bien comentados, por lo que si ya eres un programador de Pandas, debería ser bastante fácil seguir lo que sucede en el código de PySpark si aún no estás familiarizado con él.

Para ser claros, como el conjunto de datos de entrada que usaré NO son “grandes datos”, los tiempos deben considerarse como de importancia secundaria.

Ejemplo 1: cargar datos desde un CSV

Comenzaremos con una operación sencilla: simplemente leer nuestro archivo de datos CSV de entrada y ordenarlo por las columnas order_date y order_id antes de mostrar los primeros y últimos cinco registros.

Aquí está el código de Pandas.

importar pandas como pd tiempo de importación # 1. Definir ruta (formato WSL) file_path = "/mnt/d/sales_data/sales_data_30m.csv" print(f"Iniciando proceso para {file_path}…") # — FASE DE CARGA — start_load = time.time() df = pd.read_csv(file_path) end_load = time.time() print(f"Carga completa. Tiempo necesario: {end_load – start_load:.2f} segundos") # — FASE DE ORDENACIÓN — start_sort = time.time() # Nota: Ordenar por dos columnas a la vez df_sorted = df.sort_values(by=['order_date', 'order_id']) end_sort = time.time() print(f"Clasificación completa. Tiempo necesario: {end_sort – start_sort:.2f} segundos") # — DISPLAY — print("n" + "="*30) print("5 REGISTROS PRINCIPALES") print(df_sorted.head(5)) print("n5 REGISTROS INFERIORES") print(df_sorted.tail(5)) print("="*30) tiempo_total = end_sort – start_load print(f"nTiempo total de ejecución: {total_time:.2f} segundos")

Aquí está el resultado.

(pands_to_pyspark) $ python ex1_pandas.py Iniciando proceso para /mnt/d/sales_data/sales_data_30m.csv… Carga completa. Tiempo necesario: 34,02 segundos Clasificación completa. Tiempo necesario: 7,00 segundos ============================== 5 REGISTROS PRINCIPALES id_pedido fecha_pedido id_cliente nombre_cliente… categoría cantidad precio total 179 179 2023-01-01T00:00:00.000000 350 Cliente_93033… Oficina 5 640.16 3200.80 520 520 2023-01-01T00:00:00.000000 858 Cliente_31280 … Electrónica 3 841.21 2523.63 557 557 2023-01-01T00:00:00.000000 651 Cliente_95137 … Oficina 7 75,66 529,62 1080 1080 2023-01-01T00:00:00.000000 303 Cliente_87422 … Electrónica 10 98,34 983,40 2023 2023 2023-01-01T00:00:00.000000 838 Cliente_95193 … Oficina 4 427,96 1711,84 [5 filas x 10 columnas] 5 REGISTROS INFERIORES id_pedido fecha_pedido id_cliente nombre_cliente … categoría cantidad precio total 29997832 29997832 2023-12-31T00:00:00.000000 831 Cliente_49372 … Electrónica 6 418.86 2513.16 29997903 29997903 2023-12-31T00:00:00.000000 449 Cliente_17384 … Oficina 3 494,29 1482,87 29998337 29998337 2023-12-31T00:00:00.000000 649 Cliente_24018 … Electrónica 5 241,71 1208,55 29999674 29999674 2023-12-31T00:00:00.000000 105 Cliente_39890 … Oficina 1 94.97 94.97 29999933 29999933 2023-12-31T00:00:00.000000 572 Cliente_38794 … Oficina 8 375,36 3002,88 [5 filas x 10 columnas] =============================== Tiempo total de ejecución: 41,03 segundos

Aquí está el código Spark equivalente y el resultado del procesamiento.

desde pyspark.sql importar SparkSession desde pyspark.sql.types importar StructType, StructField, IntegerType, StringType, DateType, DoubleType importar tiempo importar pandas como pd start_overall = time.time() # 1. Inicializar con memoria explícita y ajuste aleatorio spark = SparkSession.builder .appName("OptimizedSpark") .config("spark.sql.shuffle.partitions", "16") .config("spark.driver.memory", "8g") .getOrCreate() spark.sparkContext.setLogLevel("ERROR") # 2. Definir esquema manual (omite la doble lectura de inferSchema) esquema = StructType([ StructField("order_id", IntegerType(), True), StructField("order_date", DateType(), True), StructField("customer_id", IntegerType(), True), StructField("customer_name", StringType(), True), StructField("product_id", IntegerType(), True), StructField("product_name", StringType(), True), StructField("categoría", StringType(), True), StructField("cantidad", IntegerType(), True), StructField("precio", DoubleType(), True), StructField("total", DoubleType(), True) ]) file_path = "/mnt/d/sales_data/sales_data_30m.csv" print(f"Procesando {file_path} con Optimized Spark…") # — LOAD — start_load = time.time() # ¡Sin esquema de inferencia! df = spark.read.csv(file_path, header=True, esquema=schema) print(f"CARGA INICIADA. (Tiempo necesario: {time.time() – start_load:.2f}s)") # — ORDENAR — start_sort = time.time() # Ordenar 30 millones de filas df_sorted = df.orderBy(["order_date", "order_id"]) # Forzar la clasificación con una acción ligera (NO caché) row_count = df_sorted.count() end_sort = time.time() print(f"ORDENACIÓN COMPLETA. Filas: {row_count}") print(f" Tiempo necesario: {end_sort – start_sort:.2f} segundos") # — MOSTRAR — print("n" + "="*80) print("5 REGISTROS PRINCIPALES") print(df_sorted.limit(5).toPandas().to_string(index=False)) print("nBOTTOM 5 RECORDS") tail_data = df_sorted.tail(5) print(pd.DataFrame(tail_data, columns=df.columns).to_string(index=False)) print("="*80) print(f"nTiempo total de ejecución: {time.time() – start_overall:.2f} segundos") spark.stop()

Y la salida.

(pands_to_pyspark) $ spark-submit ex1_spark.py 2> /dev/null Procesando /mnt/d/sales_data/sales_data_30m.csv con Spark optimizado… CARGA INICIADA. (Tiempo empleado: 0,72 s) ORDENACIÓN COMPLETA. Filas: 30000000 Tiempo necesario: 5,65 segundos ================================================================================================================================================================= nombre_cliente id_producto nombre_producto categoría cantidad precio total 179 2023-01-01 350 Cliente_93033 207 Escritorio Oficina 5 640,16 3200,80 520 2023-01-01 858 Cliente_31280 201 Pluma electrónica 3 841,21 2523,63 557 2023-01-01 651 Cliente_95137 209 Oficina de impresión 7 75,66 529,62 1080 2023-01-01 303 Cliente_87422 204 Electrónica para teléfonos inteligentes 10 98,34 983,40 2023 2023-01-01 838 Cliente_95193 201 Papel Oficina 4 427,96 1711,84 INFERIOR 5 REGISTROS id_pedido fecha_pedido id_cliente nombre_cliente id_producto nombre_producto categoría cantidad precio total 29997832 2023-12-31 831 Cliente_49372 201 Silla Electrónica 6 418,86 2513,16 29997903 2023-12-31 449 Cliente_17384 205 Escritorio Oficina 3 494.29 1482.87 29998337 2023-12-31 649 Cliente_24018 201 Smartphone Electrónica 5 241.71 1208.55 29999674 2023-12-31 105 Cliente_39890 203 Silla Oficina 1 94,97 94,97 29999933 2023-12-31 572 Cliente_38794 201 Escritorio Oficina 8 375,36 3002,88 ========================================================================================= Tiempo total de ejecución: 36,12 segundos

Ejemplo 2: convertir un archivo CSV a Parquet

En este ejemplo, leeremos el mismo archivo CSV de entrada de registros de 30 millones y luego lo escribiremos nuevamente como un archivo Parquet.

Como antes, comenzaremos con el código y la salida de pandas.

importar pandas como pd importar pyarrow.parquet como pq importar pyarrow como pa importar tiempo csv_file = "/mnt/d/sales_data/sales_data_30m.csv" parquet_file = "/mnt/d/sales_data/sales_data_pandas_30m.parquet" chunk_size = 1_000_000 # Procesar 1 millón de filas a la vez print(f"Iniciando conversión eficiente en memoria…") start_total = time.time() # 1. Cree un objeto lector CSV (esto aún no carga datos) lector = pd.read_csv(csv_file, chunksize=chunk_size) parquet_writer = Ninguno para i, fragmento en enumerate(reader): start_chunk = time.time() # Convertir fragmento de Pandas a tabla PyArrow table = pa.Table.from_pandas(chunk) # Inicialice el escritor en el primer fragmento si parquet_writer es Ninguno: parquet_writer = pq.ParquetWriter(parquet_file, table.schema, compresión='snappy') # Escriba este fragmento en el archivo parquet_writer.write_table(table) print(f"Parte procesada {i+1} (Filas {i*chunk_size} a {(i+1)*chunk_size}) en {time.time() – start_chunk:.2f}s") # 2. Cierre el escritor si parquet_writer: parquet_writer.close() print("n" + "="*40) print(f"¡Conversión completa!") print(f"Tiempo total: {time.time() – start_total:.2f} segundos") print("="*40)

La salida.

(pands_to_pyspark) $ python ex2_pandas.py Iniciando conversión con uso eficiente de la memoria… Fragmento procesado 1 (filas 0 a 1000000) en 4,82 s Fragmento procesado 2 (filas 1000000 a 2000000) en 0,40 s Fragmento procesado 3 (filas 2000000 a 3000000) en 0,39 s Fragmento procesado 4 (filas 3000000 a 4000000) en 0,36 s Fragmento procesado 5 (filas 4000000 a 5000000) en 0,43 s Fragmento procesado 6 (filas 5000000 a 6000000) en 0,45 s Fragmento procesado 7 (filas 6000000 a 7000000) en 0,35 s Fragmento procesado 8 (filas 7000000 a 8000000) en 0,34 s Fragmento procesado 9 (filas 8000000 a 9000000) en 0,36 s Fragmento procesado 10 (filas 9000000 a 10000000) en 0,36 s Fragmento procesado 11 (filas 10000000 a 11000000) en 0,37 s Fragmento procesado 12 (filas 11000000 a 12000000) en 0,41 s Fragmento procesado 13 (filas 12000000 a 13000000) en 0,48 s Fragmento procesado 14 (filas 13000000 a 14000000) en 0,43 s Fragmento procesado 15 (filas 14000000 a 15000000) en 0,38 s Fragmento procesado 16 (filas 15000000 a 16000000) en 0,35 s Fragmento procesado 17 (filas 16000000 a 17000000) en 0,34 s Fragmento procesado 18 (filas 17000000 a 18000000) en 0,35 s Fragmento procesado 19 (filas 18000000 a 19000000) en 0,36 s Fragmento procesado 20 (filas 19000000 a 20000000) en 0,35 s Fragmento procesado 21 (filas 20000000 a 21000000) en 0,34 s Fragmento procesado 22 (filas 21000000 a 22000000) en 0,34 s Fragmento procesado 23 (filas 22000000 a 23000000) en 0,34 s Fragmento procesado 24 (filas 23000000 a 24000000) en 0,36 s Fragmento procesado 25 (filas 24000000 a 25000000) en 0,36 s Fragmento procesado 26 (filas 25000000 a 26000000) en 0,35 s Fragmento procesado 27 (filas 26000000 a 27000000) en 0,36 s Fragmento procesado 28 (filas 27000000 a 28000000) en 0,35 s Fragmento procesado 29 (filas 28000000 a 29000000) en 0,35 s Fragmento procesado 30 (filas 29000000 a 30000000) en 0,34 s ======================================== Conversión completa! Tiempo total: 43,30 segundos ==========================================

Y ahora para PySpark.

desde pyspark.sql import SparkSession desde pyspark.sql.types import StructType, StructField, IntegerType, StringType, DateType, DoubleType import time # Iniciar el cronómetro general inmediatamente start_overall = time.time() # 1. Inicializar Spark con una configuración de memoria alta spark = SparkSession.builder .appName("EfficientParquetConversion") .config("spark.driver.memory", "8g") .master("local[*]") .getOrCreate() # Silenciar registros spark.sparkContext.setLogLevel("ERROR") # 2. Defina explícitamente el esquema (más eficiente para CSV) esquema = StructType([ StructField("order_id", IntegerType(), True), StructField("order_date", DateType(), True), StructField("customer_id", IntegerType(), True), StructField("customer_name", StringType(), True), StructField("product_id", IntegerType(), True), StructField("product_name", StringType(), True), StructField("categoría", StringType(), True), StructField("cantidad", IntegerType(), True), StructField("price", DoubleType(), True), StructField("total", DoubleType(), True) ]) csv_path = "/mnt/d/sales_data/sales_data_30m.csv" parquet_path = "/mnt/d/sales_data/sales_data_parquet" print(f"Iniciando la conversión de Spark a {parquet_path}…") # 3. Lea el CSV usando el esquema definido start_proc = time.time() df = spark.read.csv(csv_path, header=True, esquema=schema) # 4. Escribir en Parquet (sobrescribir si existe) df.write.mode("overwrite").parquet(parquet_path) end_proc = time.time() print("-" * 40) print(f"CONVERSIÓN COMPLETA") print(f"Tiempo de procesamiento (Lectura + Escritura): {end_proc – start_proc:.2f} segundos") print(f"Tiempo total de ejecución (incluido el inicio de Spark): {time.time() – start_overall:.2f} segundos") print("-" * 40) spark.stop()

Puedo confirmar que el contenido del archivo parquet creado por Pandas y Pyspark era idéntico.

(pands_to_pyspark) $ spark-submit –driver-memory 8g ex2_spark.py 2> /dev/null Iniciando la conversión de Spark a /mnt/d/sales_data/sales_data_parquet… —————————————- CONVERSIÓN COMPLETA Tiempo de procesamiento (lectura + escritura): 21,62 segundos Tiempo total de ejecución (incluido el inicio de Spark): 23,26 segundos —————————————-

Ejemplo 3: pivotación de datos

Lea los archivos de Parquet que acabamos de crear y calcule las ventas totales por nombre_producto por fecha_pedido.

Pandas.

importar pandas como pd desde timeit import default_timer as timer parquet_path = r'/mnt/d/sales_data/sales_data_pandas_30m.parquet' start = timer() # Leer el archivo Parquet df = pd.read_parquet(parquet_path) # 1) Hacer que order_date sea una fecha adecuada # Convertir a datetime y luego extraer el componente de fecha df["order_date"] = pd.to_datetime(df["order_date"]).dt.date # 2) Pivote (suma) # Pandas pivot_table maneja la agregación (suma) y la forma simultáneamente pivot = df.pivot_table(values="total", index="order_date", columns="product_name", aggfunc="sum" ) # 3) Ordenar filas por fecha (índice Pandas) pivot = pivot.sort_index() # 4) Aplicar un orden de columnas coherente (columnas de producto alfabéticas) # pivot_table ya ordena las columnas de forma predeterminada, pero podemos ser explícitos pivot = pivot.reindex(sorted(pivot.columns), axis=1) # 5) (Opcional) Reemplazar valores nulos con 0 # pivot = pivot.fillna(0) end = timer() print(f"Pandas: read + pivot estandarizado tomó {end – start:.2f} segundos") imprimir (cabezal.pivote (5))

Salida de pandas.

(pandas_pysaprk) $ python ex3_pandas.py Pandas: lectura + pivote estandarizado tomó 9,98 segundos nombre_producto Silla Cafetera Escritorio Computadora portátil… Papel Bolígrafo Impresora Teléfono inteligente fecha_pedido… 2023-01-01 22041864.51 22596967.46 22228235.43 22319250.97… 22778128,78 22690394,34 22747419,90 22848102,42 2023-01-02 22702337,42 21960074,98 23539803,82 23332945,56 … 22414013.44 22378123.52 22494364.89 22321919.79 2023-01-03 22626028.85 22651440.10 22930421.42 22938328.34 … 22880161.09 21607713.73 22937117.72 22262604.28 2023-01-04 22605466.70 22652219.77 22463371.43 22506729.47 … 23097987,72 22327386,63 22922449,38 22673066,75 2023-01-05 22581240,40 23004302,70 22511769,34 22882968,52 … 22058769,99 22379327,80 22946133,94 22988219,48 [5 filas x 10 columnas]

PySpark.

desde pyspark.sql importar SparkSession desde pyspark.sql importar funciones como F desde timeit importar default_timer como temporizador # Inicializar Spark spark = SparkSession.builder .appName("SparkPivotBenchmark") .config("spark.driver.memory", "8g") .master("local[*]") .getOrCreate() spark.sparkContext.setLogLevel("ERROR") parquet_path = '/mnt/d/sales_data/sales_data_parquet' start = timer() # 1. Leer el archivo Parquet df = spark.read.parquet(parquet_path) # 2. Hacer que order_date sea una fecha adecuada # Emitimos la columna a DateType df = df.withColumn("order_date", F.col("order_date").cast("date")) # 3. Pivot (sum) # El pivote de Spark es mucho más rápido si proporcionas los valores únicos (product_names) # pero también puede inferirlos automáticamente como se muestra a continuación pivot_df = df.groupBy("order_date") .pivot("product_name") .agg(F.sum("total")) # 4. Ordenar filas por fecha pivot_df = pivot_df.orderBy("order_date") # 5. Aplicar un orden de columnas coherente (columnas de productos alfabéticas) # La primera columna es 'order_date', el resto son productos pivotados columns = pivot_df.columns product_cols = sorted([c for c in columns if c != "order_date"]) pivot_df = pivot_df.select(["order_date"] + product_cols) # 6. Reemplace los valores nulos con 0 pivot_df = pivot_df.na.fill(0) # Activar una acción para medir el rendimiento real (recuento de días pivotados) row_count = pivot_df.count() end = timer() print(f"PySpark: lectura + pivote estandarizado tomó {end – start:.2f} segundos") print(f"Total de días procesados: {row_count}") # 7. Mostrar los 5 principales pivot_df.show(5) chispa.parada()

Salida de PySpark.

(pandas_pyspark) $ spark-submit –driver-memory 8g ex3_spark.py 2> /dev/null PySpark: lectura + pivote estandarizado tardó 3,54 segundos Total de días procesados: 365 +———-+——————–+——————–+——————–+——————–+——————–+——————–+——————–+——————–+——————–+——————–+ |order_date| Silla| Cafetera| Escritorio| Computadora portátil| Monitorear| Cuaderno| Papel| Pluma| Impresora| Teléfono inteligente| +———-+——————–+——————–+——————–+——————–+——————–+——————–+——————–+——————–+——————–+——————–+ |2023-01-01|2.2041864510000005E7|2.2596967459999997E7| 2.222823543E7|2.2319250969999995E7| 2.309861159E7|2.2687765309999995E7|2.2778128780000005E7|2.2690394339999996E7| 2.27474199E7|2.2848102419999998E7| |2023-01-02| 2.270233742E7|2.1960074980000004E7|2.3539803819999993E7|2.3332945560000006E7|2.2441403840000004E7| 2.282151253E7| 2.241401344E7|2.2378123520000003E7| 2.249436489E7| 2.232191979E7| |2023-01-03|2.2626028849999998E7| 2.26514401E7| 2.293042142E7| 2.293832834E7| 2.290862974E7|2.2432433990000006E7|2.2880161090000004E7|2.1607713730000008E7| 2.293711772E7| 2.226260428E7| |2023-01-04|2.2605466699999996E7|2.2652219770000003E7| 2.246337143E7| 2.250672947000001E7|2.1930874809999995E7|2.3261865149999995E7| 2.309798772E7|2.2327386629999995E7|2.2922449380000003E7|2.2673066749999996E7| |2023-01-05|2.2581240400000002E7|2.3004302700000003E7| 2.251176934E7|2.2882968520000003E7| 2.284090005E7| 2.272256243E7|2.2058769990000002E7|2.2379327800000004E7|2.2946133940000005E7| 2.298821948E7| +———-+——————–+——————–+——————–+——————–+——————–+——————–+——————–+——————–+——————–+——————–+ solo muestra las 5 filas superiores

Ejemplo 4: Análisis de ventanas con LAG/LEAD

Para mi código de ejemplo final, calcularemos la SUMA de todos los pedidos por fecha_pedido, luego usaremos la funcionalidad LAG/LEAD para calcular el cambio porcentual en el total de pedidos durante fechas de pedido consecutivas.

Pandas.

importar pandas como pd desde timeit import default_timer as timer parquet_path = '/mnt/d/sales_data/sales_data_pandas_30m.parquet' start = timer() # 1. Leer el archivo Parquet df = pd.read_parquet(parquet_path) # 2. Normalizar order_date # Pandas to_datetime es generalmente lo suficientemente flexible como para manejar múltiples formatos # automáticamente, lo que reemplaza el manual pl.lógica fusionada. df['order_date'] = pd.to_datetime(df['order_date'], errores='coerce').dt.date # 3. Agrupar por fecha y agregar result_pandas = df.groupby("order_date")["total"].sum().reset_index() # 4. Ordenar por fecha result_pandas = result_pandas.sort_values("order_date") # 5. Funciones analíticas (Retraso y adelanto) # En Pandas, shift(1) es retraso, shift(-1) es adelanto result_pandas["total_lag"] = result_pandas["total"].shift(1) result_pandas["total_lead"] = result_pandas["total"].shift(-1) # 6. Calcular cambios porcentuales # Usamos operaciones en serie que manejan la lógica 'Ninguno/NaN' y 'dividir por cero' # similar a pl.when().otherwise() result_pandas["percent_change_from_lag"] = ( (result_pandas["total"] – result_pandas["total_lag"]) * 100 / result_pandas["total_lag"] ) result_pandas["percent_change_from_lead"] = ( (result_pandas["total"] – result_pandas["total_lead"]) * 100 / result_pandas["total_lead"] ) end = timer() print(f"Pandas: lectura + análisis (retraso/adelanto) tomó {end – inicio:.2f} segundos") print(result_pandas.head(10).to_string(index=False))

Salida de pandas.

(pandas_pyspark) $ python ex4_pandas.py Pandas: lectura + análisis (retraso/adelanto) tomó 8,99 segundos fecha_pedido total total_lag total_lead percent_change_from_lag percent_change_from_lead 2023-01-01 226036740.71 NaN 226406499.79 NaN -0.163316 2023-01-02 226406499.79 226036740.71 226174879.26 0.163584 0.102408 2023-01-03 226174879.26 226406499.79 226441417.81 -0,102303 -0,117708 2023-01-04 226441417,81 226174879,26 226916194,65 0,117846 -0,209230 2023-01-05 226916194,65 226441417.81 226990804.43 0.209669 -0.032869 2023-01-06 226990804.43 226916194.65 225973424.85 0.032880 0.450221 2023-01-07 225973424.85 226990804.43 227894370.99 -0.448203 -0.842911 2023-01-08 227894370.99 225973424.85 227111347.09 0.850076 0.344775 2023-01-09 227111347.09 227894370.99 226271884.19 -0.343591 0.370997 2023-01-10 226271884.19 227111347.09 226635543.97 -0.369626 -0.160460

PySpark.

desde pyspark.sql importar SparkSession desde pyspark.sql importar funciones como F desde pyspark.sql.window importar ventana desde timeit importar default_timer como temporizador # Inicializar Spark spark = SparkSession.builder .appName("SparkAnalyticBenchmark") .config("spark.driver.memory", "8g") .master("local[*]") .getOrCreate() spark.sparkContext.setLogLevel("ERROR") # Ruta al archivo Parquet parquet_path = '/mnt/d/sales_data/sales_data_parquet' start = timer() # 1. Leer el archivo Parquet df = spark.read.parquet(parquet_path) # 2. Normalizar order_date # El to_date de Spark es eficiente; coalesce maneja múltiples formatos potenciales si es necesario df = df.withColumn("order_date", F.to_date(F.col("order_date"))) # 3. Agrupar por fecha y agregar daily_revenue = df.groupBy("order_date").agg(F.sum("total").alias("total")) # 4. Definir la ventana para funciones analíticas # Debemos ordenar por fecha para que el retraso/avance tenga sentido window_spec = Window.orderBy("order_date") # 5. Aplicar Lag y Lead # lag(col, 1) = fila anterior; lead(col, 1) = siguiente fila daily_revenue = daily_revenue.withColumn("total_lag", F.lag("total", 1).over(window_spec)) daily_revenue = daily_revenue.withColumn("total_lead", F.lead("total", 1).over(window_spec)) # 6. Calcular cambios porcentuales # Usamos F.when() para manejar valores nulos y evitarlos división por cero ingresos_diarios = ingresos_diarios.withColumn( "cambio_porcentaje_de_lag", F.when((F.col("total_lag").isNotNull()) & (F.col("total_lag") != 0), (F.col("total") – F.col("total_lag")) * 100 / F.col("total_lag")) .de lo contrario(Ninguno) ) ingresos_diarios = ingresos_diarios.withColumn( "cambio_porcentaje_de_plomo", F.when((F.col("total_plomo").isNotNull()) & (F.col("total_plomo") != 0), (F.col("total") – F.col("total_plomo")) * 100 / F.col("total_plomo")) .de lo contrario(Ninguno) ) # 7. Clasificación y acción final result_spark = daily_revenue.orderBy("order_date") # Activar acción para medir el rendimiento row_count = result_spark.count() end = timer() print(f"PySpark: lectura + análisis (lag/lead) tomó {end – start:.2f} segundos") print(f"Total de días procesados: {row_count}") # Mostrar los 10 principales result_spark.show(10) spark.stop()

Salida de PySpark.

(pandas_pyspark) $ spark-submit –driver-memory 8g ex4_spark.py 2> /dev/null PySpark: lectura + análisis (retraso/adelanto) tardó 4,05 segundos Total de días procesados: 365 +———-+——————–+——————–+——————–+———————–+————————+ |order_date| total| retraso_total| total_lead|porcentaje_cambio_del_lag|porcentaje_cambio_del_plomo| +———-+——————–+——————–+——————–+———————–+————————+ |2023-01-01| 2.2603674071E8| NULO|2.2640649979000002E8| NULO| -0,16331645970543143| |2023-01-02|2.2640649979000002E8| 2.2603674071E8| 2.2617487926E8| 0,16358361868011784| 0,10240771687724477| |2023-01-03| 2.2617487926E8|2.2640649979000002E8|2.2644141781000003E8| -0,1023029507610723| -0,11770750800707579| |2023-01-04|2.2644141781000003E8| 2.2617487926E8|2.2691619464999998E8| 0,11784622185810545| -0,2092300378702583| |2023-01-05|2.2691619464999998E8|2.2644141781000003E8|2.2699080442999995E8| 0,20966872782889678| -0,03286907599068832| |2023-01-06|2.2699080442999995E8|2.2691619464999998E8| 2.259734248499999E8| 0,032879883304517334| 0,45022089684898775| |2023-01-07| 2.259734248499999E8|2.2699080442999995E8|2.2789437099000004E8| -0,4482029933127909| -0,8429107448575048| |2023-01-08|2.2789437099000004E8| 2.259734248499999E8|2.2711134708999988E8| 0,8500761278788644| 0,344775331586518| |2023-01-09|2.2711134708999988E8|2.2789437099000004E8|2.2627188419000003E8| -0,34359071555765364| 0,37099744097899573| |2023-01-10|2.2627188419000003E8|2.2711134708999988E8|2.2663554396999997E8| -0,3696261374678007| -0,1604601703817825| +———-+——————–+——————–+——————–+———————–+————————+ mostrando solo las 10 filas superiores

Resumen

En este artículo, expliqué que hay muchas formas de actualizar sus sistemas si los datos con los que está tratando comienzan a invadir el territorio de "grandes datos", de modo que resulta difícil (o imposible) procesar utilizando su base de código Pandas existente.

Cité tres alternativas comunes: bibliotecas distribuidas como dask o ray, mover sus datos a un RDBMS e interrogarlos con SQL, o usar la biblioteca de computación distribuida: Spark.

Centrándome en esto último, describí el caso de PySpark y luego utilicé cuatro ejemplos del mundo real de tareas típicas de procesamiento de datos para las que se usa Pandas regularmente, junto con el código PySpark equivalente para cada uno.

Si bien los puntos de referencia de tiempo mostraron algunas mejoras en los tiempos de ejecución de PySpark en comparación con Pandas, estos no fueron el enfoque principal. Después de todo, con conjuntos de datos aún más grandes, Pandas simplemente no podría procesarlos en absoluto, y mucho menos dentro de un período de tiempo específico.

En cambio, el objetivo principal de este artículo era mostrarle lo relativamente sencillo que es:

Obtenga un entorno Spark en funcionamiento rápidamente. Replica las operaciones de datos comunes de Pandas en el lenguaje PySpark para tener la seguridad de que los big data no deberían limitar tus capacidades de procesamiento.

Al cerrar la brecha entre el análisis de un solo subproceso y el procesamiento escalable de big data, sepa que puede realizar con confianza la transición de sus flujos de trabajo a medida que sus datos superen su hardware local.