Gu铆a completa para fusionar y unir DataFrames en Python Pandas, cubriendo estrategias como uniones internas, externas, izquierdas y derechas con ejemplos pr谩cticos.
Python Pandas Merging: Dominando Estrategias de Uni贸n de DataFrames para el An谩lisis de Datos
La manipulaci贸n de datos es un aspecto crucial del an谩lisis de datos, y la biblioteca Pandas en Python proporciona herramientas potentes para este prop贸sito. Entre estas herramientas, la fusi贸n y uni贸n de DataFrames son operaciones esenciales para combinar conjuntos de datos bas谩ndose en columnas o 铆ndices comunes. Esta gu铆a completa explora varias estrategias de uni贸n de DataFrames en Pandas, equip谩ndolo con el conocimiento para combinar y analizar datos de diferentes fuentes de manera efectiva.
Comprendiendo la Fusi贸n y Uni贸n de DataFrames
La fusi贸n y uni贸n de DataFrames implican combinar dos o m谩s DataFrames en un solo DataFrame bas谩ndose en una columna o 铆ndice compartido. La diferencia principal entre `merge` y `join` es que `merge` es una funci贸n de la biblioteca Pandas y t铆picamente une DataFrames por columnas, mientras que `join` es un m茅todo de DataFrame que une DataFrames principalmente por 铆ndices, aunque tambi茅n puede usarse con columnas.
Conceptos Clave
- DataFrames: Estructuras de datos etiquetadas bidimensionales con columnas de tipos potencialmente diferentes.
- Columnas/脥ndices Comunes: Columnas o 铆ndices que comparten el mismo nombre y tipo de datos entre DataFrames, sirviendo como base para la fusi贸n/uni贸n.
- Tipos de Uni贸n: Diferentes estrategias para manejar filas no coincidentes durante el proceso de fusi贸n/uni贸n, incluyendo uniones internas, externas, izquierdas y derechas.
Fusi贸n de DataFrames con `pd.merge()`
La funci贸n `pd.merge()` es la herramienta principal para fusionar DataFrames bas谩ndose en columnas. Ofrece una forma flexible de combinar datos bas谩ndose en una o m谩s columnas comunes.
Sintaxis
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
Par谩metros
- left: El DataFrame izquierdo a fusionar.
- right: El DataFrame derecho a fusionar.
- how: El tipo de fusi贸n a realizar ('inner', 'outer', 'left', 'right'). El valor predeterminado es 'inner'.
- on: El nombre de la(s) columna(s) para unir. Deben encontrarse en ambos DataFrames.
- left_on: El nombre de la(s) columna(s) en el DataFrame izquierdo a usar como claves de uni贸n.
- right_on: El nombre de la(s) columna(s) en el DataFrame derecho a usar como claves de uni贸n.
- left_index: Si es True, usa el 铆ndice del DataFrame izquierdo como la(s) clave(s) de uni贸n.
- right_index: Si es True, usa el 铆ndice del DataFrame derecho como la(s) clave(s) de uni贸n.
- sort: Ordena el DataFrame resultante lexicogr谩ficamente por las claves de uni贸n. El valor predeterminado es False.
- suffixes: Una tupla de sufijos de cadena a aplicar a nombres de columnas superpuestos. El valor predeterminado es ('_x', '_y').
- copy: Si es False, evita copiar datos al nuevo DataFrame siempre que sea posible. El valor predeterminado es True.
- indicator: Si es True, a帽ade una columna llamada '_merge' que indica la fuente de cada fila.
- validate: Comprueba si la fusi贸n es del tipo especificado. "one_to_one", "one_to_many", "many_to_one", "many_to_many".
Tipos de Uni贸n Explicados
El par谩metro `how` en `pd.merge()` determina el tipo de uni贸n realizada. Los diferentes tipos de uni贸n manejan las filas no coincidentes de diferentes maneras.
Uni贸n Interna (Inner Join)
Una uni贸n interna devuelve solo las filas que tienen valores coincidentes en ambos DataFrames bas谩ndose en las claves de uni贸n. Las filas con valores no coincidentes se excluyen del resultado.
Ejemplo:
Considera dos DataFrames:
import pandas as pd
# DataFrame 1: 脫rdenes de Clientes
df_orders = pd.DataFrame({
'order_id': [1, 2, 3, 4, 5],
'customer_id': [101, 102, 103, 104, 105],
'product_id': [1, 2, 1, 3, 2],
'quantity': [2, 1, 3, 1, 2]
})
# DataFrame 2: Informaci贸n de Clientes
df_customers = pd.DataFrame({
'customer_id': [101, 102, 103, 106],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David'],
'country': ['USA', 'Canada', 'UK', 'Australia']
})
# Uni贸n Interna
df_inner = pd.merge(df_orders, df_customers, on='customer_id', how='inner')
print(df_inner)
Salida:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
En este ejemplo, la uni贸n interna combina los DataFrames `df_orders` y `df_customers` bas谩ndose en la columna `customer_id`. Solo los clientes que han realizado pedidos se incluyen en el resultado. El cliente 'David' (customer_id 106) se excluye porque no tiene pedidos.
Uni贸n Externa (Outer Join / Full Outer Join)
Una uni贸n externa devuelve todas las filas de ambos DataFrames, incluidas las filas no coincidentes. Si una fila no tiene una coincidencia en el otro DataFrame, las columnas correspondientes contendr谩n valores `NaN` (Not a Number).
Ejemplo:
# Uni贸n Externa
df_outer = pd.merge(df_orders, df_customers, on='customer_id', how='outer')
print(df_outer)
Salida:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 4.0 104 3.0 1.0 NaN NaN
4 5.0 105 2.0 2.0 NaN NaN
5 NaN 106 NaN NaN David Australia
La uni贸n externa incluye todos los clientes y todos los pedidos. Los clientes 104 y 105 tienen pedidos pero no informaci贸n de cliente, y el cliente 106 tiene informaci贸n de cliente pero no pedidos. Los valores faltantes se representan como `NaN`.
Uni贸n Izquierda (Left Join)
Una uni贸n izquierda devuelve todas las filas del DataFrame izquierdo y las filas coincidentes del DataFrame derecho. Si una fila en el DataFrame izquierdo no tiene una coincidencia en el DataFrame derecho, las columnas correspondientes del DataFrame derecho contendr谩n valores `NaN`.
Ejemplo:
# Uni贸n Izquierda
df_left = pd.merge(df_orders, df_customers, on='customer_id', how='left')
print(df_left)
Salida:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
La uni贸n izquierda incluye todos los pedidos de `df_orders`. Los clientes 104 y 105 tienen pedidos pero no informaci贸n de cliente, por lo que las columnas `customer_name` y `country` son `NaN` para esos pedidos.
Uni贸n Derecha (Right Join)
Una uni贸n derecha devuelve todas las filas del DataFrame derecho y las filas coincidentes del DataFrame izquierdo. Si una fila en el DataFrame derecho no tiene una coincidencia en el DataFrame izquierdo, las columnas correspondientes del DataFrame izquierdo contendr谩n valores `NaN`.
Ejemplo:
# Uni贸n Derecha
df_right = pd.merge(df_orders, df_customers, on='customer_id', how='right')
print(df_right)
Salida:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 NaN 106 NaN NaN David Australia
La uni贸n derecha incluye todos los clientes de `df_customers`. El cliente 106 tiene informaci贸n de cliente pero no pedidos, por lo que las columnas `order_id`, `product_id` y `quantity` son `NaN` para ese cliente.
Uni贸n de DataFrames con `df.join()`
El m茅todo `df.join()` se utiliza principalmente para unir DataFrames bas谩ndose en sus 铆ndices. Tambi茅n puede usarse para unir por columnas, pero generalmente es m谩s conveniente usar `pd.merge()` para uniones basadas en columnas.
Sintaxis
DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
Par谩metros
- other: El otro DataFrame a unir.
- on: Nombre de la columna para unir. Debe ser pasado si el 铆ndice no se usa como clave de uni贸n.
- how: C贸mo manejar la operaci贸n de los conjuntos izquierdo y derecho. El valor predeterminado es 'left'.
- lsuffix: Sufijo a usar del DataFrame izquierdo para anular nombres de columnas superpuestos.
- rsuffix: Sufijo a usar del DataFrame derecho para anular nombres de columnas superpuestos.
- sort: Ordena el DataFrame resultante lexicogr谩ficamente por las claves de uni贸n. El valor predeterminado es False.
Uni贸n por 脥ndice
Al unir por 铆ndice, el par谩metro `on` no se usa.
Ejemplo:
# DataFrame 1: 脫rdenes de Clientes con ID de Cliente como 脥ndice
df_orders_index = df_orders.set_index('customer_id')
# DataFrame 2: Informaci贸n de Clientes con ID de Cliente como 脥ndice
df_customers_index = df_customers.set_index('customer_id')
# Uni贸n por 脥ndice (Uni贸n Izquierda)
df_join_index = df_orders_index.join(df_customers_index, how='left')
print(df_join_index)
Salida:
order_id product_id quantity customer_name country
customer_id
101 1 1 2 Alice USA
102 2 2 1 Bob Canada
103 3 1 3 Charlie UK
104 4 3 1 NaN NaN
105 5 2 2 NaN NaN
En este ejemplo, el m茅todo `join()` se usa para realizar una uni贸n izquierda en el 铆ndice (`customer_id`). El resultado es similar a la uni贸n izquierda usando `pd.merge()`, pero la uni贸n se basa en el 铆ndice en lugar de una columna.
Uni贸n por Columna
Para unir por una columna usando `df.join()`, necesitas especificar el par谩metro `on`.
Ejemplo:
# Uni贸n por una columna
df_join_column = df_orders.join(df_customers.set_index('customer_id'), on='customer_id', how='left')
print(df_join_column)
Salida:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
Este ejemplo demuestra la uni贸n de `df_orders` con `df_customers` usando la columna `customer_id`. Ten en cuenta que `customer_id` se establece como 铆ndice en `df_customers` antes de realizar la uni贸n.
Manejo de Columnas Superpuestas
Al fusionar o unir DataFrames, es com煤n encontrar nombres de columnas superpuestos (columnas con el mismo nombre en ambos DataFrames). Pandas proporciona el par谩metro `suffixes` en `pd.merge()` y los par谩metros `lsuffix` y `rsuffix` en `df.join()` para manejar estas situaciones.
Uso de `suffixes` en `pd.merge()`
El par谩metro `suffixes` te permite especificar sufijos que se a帽adir谩n a los nombres de columnas superpuestos para distinguirlos.
Ejemplo:
# DataFrame 1: Informaci贸n de Producto
df_products1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C'],
'price': [10, 20, 15]
})
# DataFrame 2: Informaci贸n de Producto (con precios potencialmente actualizados)
df_products2 = pd.DataFrame({
'product_id': [1, 2, 4],
'product_name': ['Product A', 'Product B', 'Product D'],
'price': [12, 18, 25]
})
# Fusi贸n con sufijos
df_merged_suffixes = pd.merge(df_products1, df_products2, on='product_id', suffixes=('_old', '_new'))
print(df_merged_suffixes)
Salida:
product_id product_name_old price_old product_name_new price_new
0 1 Product A 10 Product A 12
1 2 Product B 20 Product B 18
En este ejemplo, las columnas `product_name` y `price` est谩n presentes en ambos DataFrames. El par谩metro `suffixes` a帽ade los sufijos `_old` y `_new` para distinguir las columnas de los DataFrames izquierdo y derecho, respectivamente.
Uso de `lsuffix` y `rsuffix` en `df.join()`
Los par谩metros `lsuffix` y `rsuffix` proporcionan funcionalidad similar para `df.join()`. `lsuffix` se a帽ade a las columnas superpuestas del DataFrame izquierdo, y `rsuffix` a las del derecho.
Ejemplo:
# Uni贸n con lsuffix y rsuffix
df_products1_index = df_products1.set_index('product_id')
df_products2_index = df_products2.set_index('product_id')
df_joined_suffixes = df_products1_index.join(df_products2_index, lsuffix='_old', rsuffix='_new', how='outer')
print(df_joined_suffixes)
Salida:
product_name_old price_old product_name_new price_new
product_id
1 Product A 10.0 Product A 12.0
2 Product B 20.0 Product B 18.0
3 Product C 15.0 NaN NaN
4 NaN NaN Product D 25.0
Ejemplos Pr谩cticos y Casos de Uso
La fusi贸n y uni贸n de DataFrames se utilizan ampliamente en varios escenarios de an谩lisis de datos. Aqu铆 hay algunos ejemplos pr谩cticos:
Combinando Datos de Ventas con Informaci贸n de Productos
Un caso de uso com煤n es combinar datos de ventas con informaci贸n de productos. Suponga que tiene un DataFrame que contiene transacciones de ventas y otro DataFrame que contiene detalles de productos. Puede fusionar estos DataFrames para enriquecer los datos de ventas con informaci贸n de productos.
Ejemplo:
# Datos de Transacciones de Ventas
df_sales = pd.DataFrame({
'transaction_id': [1, 2, 3, 4, 5],
'product_id': [101, 102, 103, 101, 104],
'quantity': [2, 1, 3, 1, 2],
'sales_date': ['2023-01-15', '2023-02-20', '2023-03-10', '2023-04-05', '2023-05-01']
})
# Datos de Informaci贸n de Productos
df_products = pd.DataFrame({
'product_id': [101, 102, 103, 104],
'product_name': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'category': ['Electronics', 'Electronics', 'Electronics', 'Electronics'],
'price': [1200, 25, 75, 300]
})
# Fusi贸n de Datos de Ventas con Informaci贸n de Productos
df_sales_enriched = pd.merge(df_sales, df_products, on='product_id', how='left')
print(df_sales_enriched)
Salida:
transaction_id product_id quantity sales_date product_name category price
0 1 101 2 2023-01-15 Laptop Electronics 1200
1 2 102 1 2023-02-20 Mouse Electronics 25
2 3 103 3 2023-03-10 Keyboard Electronics 75
3 4 101 1 2023-04-05 Laptop Electronics 1200
4 5 104 2 2023-05-01 Monitor Electronics 300
El DataFrame resultante `df_sales_enriched` contiene las transacciones de ventas junto con la informaci贸n del producto correspondiente, lo que permite un an谩lisis m谩s detallado de las tendencias de ventas y el rendimiento del producto.
Combinando Datos de Clientes con Informaci贸n Demogr谩fica
Otro caso de uso com煤n es combinar datos de clientes con informaci贸n demogr谩fica. Esto permite analizar el comportamiento del cliente bas谩ndose en factores demogr谩ficos.
Ejemplo:
# Datos de Clientes
df_customers = pd.DataFrame({
'customer_id': [1, 2, 3, 4, 5],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin']
})
# Datos de Informaci贸n Demogr谩fica
df_demographics = pd.DataFrame({
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin'],
'population': [8419000, 8982000, 13960000, 5312000, 3769000],
'average_income': [75000, 65000, 85000, 90000, 55000]
})
# Fusi贸n de Datos de Clientes con Informaci贸n Demogr谩fica
df_customer_demographics = pd.merge(df_customers, df_demographics, on='city', how='left')
print(df_customer_demographics)
Salida:
customer_id customer_name city population average_income
0 1 Alice New York 8419000 75000
1 2 Bob London 8982000 65000
2 3 Charlie Tokyo 13960000 85000
3 4 David Sydney 5312000 90000
4 5 Eve Berlin 3769000 55000
El DataFrame resultante `df_customer_demographics` contiene datos de clientes junto con la informaci贸n demogr谩fica de sus ciudades respectivas, lo que permite el an谩lisis del comportamiento del cliente basado en la demograf铆a de la ciudad.
An谩lisis de Datos Globales de Cadena de Suministro
La fusi贸n de Pandas es valiosa para analizar datos globales de cadena de suministro, donde la informaci贸n a menudo se distribuye en varias tablas. Por ejemplo, vincular datos de proveedores, informaci贸n de env铆o y cifras de ventas puede revelar cuellos de botella y optimizar la log铆stica.
Ejemplo:
# Datos de Proveedores
df_suppliers = pd.DataFrame({
'supplier_id': [1, 2, 3],
'supplier_name': ['GlobalTech', 'EuroParts', 'AsiaSource'],
'location': ['Taiwan', 'Germany', 'China']
})
# Datos de Env铆o
df_shipments = pd.DataFrame({
'shipment_id': [101, 102, 103, 104],
'supplier_id': [1, 2, 3, 1],
'destination': ['USA', 'Canada', 'Australia', 'Japan'],
'shipment_date': ['2023-01-10', '2023-02-15', '2023-03-20', '2023-04-25']
})
# Fusi贸n de Datos de Proveedores y Env铆os
df_supply_chain = pd.merge(df_shipments, df_suppliers, on='supplier_id', how='left')
print(df_supply_chain)
Salida:
shipment_id supplier_id destination shipment_date supplier_name location
0 101 1 USA 2023-01-10 GlobalTech Taiwan
1 102 2 Canada 2023-02-15 EuroParts Germany
2 103 3 Australia 2023-03-20 AsiaSource China
3 104 1 Japan 2023-04-25 GlobalTech Taiwan
T茅cnicas Avanzadas de Fusi贸n
Fusi贸n por M煤ltiples Columnas
Puede fusionar DataFrames bas谩ndose en m煤ltiples columnas pasando una lista de nombres de columnas al par谩metro `on`.
Ejemplo:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'quantity': [10, 15, 20, 25]
})
# DataFrame 2
df2 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'price': [5, 7, 8, 10]
})
# Fusi贸n por m煤ltiples columnas
df_merged_multiple = pd.merge(df1, df2, on=['product_id', 'color'], how='inner')
print(df_merged_multiple)
Salida:
product_id color quantity price
0 1 red 10 5
1 1 blue 15 7
2 2 red 20 8
3 2 blue 25 10
Fusi贸n con Nombres de Columna Diferentes
Si las columnas de uni贸n tienen nombres diferentes en los dos DataFrames, puede usar los par谩metros `left_on` y `right_on` para especificar los nombres de columna a usar para la fusi贸n.
Ejemplo:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C']
})
# DataFrame 2
df2 = pd.DataFrame({
'id': [1, 2, 4],
'price': [10, 20, 25]
})
# Fusi贸n con nombres de columna diferentes
df_merged_different = pd.merge(df1, df2, left_on='product_id', right_on='id', how='left')
print(df_merged_different)
Salida:
product_id product_name id price
0 1 Product A 1.0 10.0
1 2 Product B 2.0 20.0
2 3 Product C NaN NaN
Uso de `indicator` para An谩lisis de Fusi贸n
El par谩metro `indicator` en `pd.merge()` a帽ade una columna llamada `_merge` al DataFrame resultante, que indica la fuente de cada fila. Esto es 煤til para comprender qu茅 filas coincidieron y cu谩les no.
Ejemplo:
# Fusi贸n con indicador
df_merged_indicator = pd.merge(df_orders, df_customers, on='customer_id', how='outer', indicator=True)
print(df_merged_indicator)
Salida:
order_id customer_id product_id quantity customer_name country _merge
0 1.0 101 1.0 2.0 Alice USA both
1 2.0 102 2.0 1.0 Bob Canada both
2 3.0 103 1.0 3.0 Charlie UK both
3 4.0 104 3.0 1.0 NaN NaN left_only
4 5.0 105 2.0 2.0 NaN NaN left_only
5 NaN 106 NaN NaN David Australia right_only
La columna `_merge` indica si la fila proviene de ambos DataFrames (`both`), solo del DataFrame izquierdo (`left_only`), o solo del DataFrame derecho (`right_only`).
Validaci贸n de Tipos de Fusi贸n
El par谩metro `validate` asegura que la operaci贸n de fusi贸n se alinee con los tipos de relaci贸n esperados entre los DataFrames (por ejemplo, 'one_to_one', 'one_to_many'). Esto ayuda a prevenir inconsistencias y errores en los datos.
Ejemplo:
# Ejemplo con validaci贸n uno a uno
df_users = pd.DataFrame({
'user_id': [1, 2, 3],
'username': ['john_doe', 'jane_smith', 'peter_jones']
})
df_profiles = pd.DataFrame({
'user_id': [1, 2, 3],
'profile_description': ['Software Engineer', 'Data Scientist', 'Project Manager']
})
# Realizando una fusi贸n uno a uno con validaci贸n
merged_df = pd.merge(df_users, df_profiles, on='user_id', validate='one_to_one')
print(merged_df)
Si la fusi贸n viola la validaci贸n especificada (por ejemplo, una relaci贸n muchos a uno cuando se especifica 'one_to_one'), se generar谩 un `MergeError`, alert谩ndole sobre posibles problemas de integridad de datos.
Consideraciones de Rendimiento
La fusi贸n y uni贸n de DataFrames pueden ser computacionalmente costosas, especialmente para conjuntos de datos grandes. Aqu铆 hay algunos consejos para mejorar el rendimiento:
- Use el tipo de uni贸n apropiado: Elegir el tipo de uni贸n correcto puede impactar significativamente el rendimiento. Por ejemplo, si solo necesita filas coincidentes, use una uni贸n interna.
- Indexe las columnas de uni贸n: Indexar las columnas de uni贸n puede acelerar el proceso de fusi贸n.
- Use tipos de datos apropiados: Aseg煤rese de que las columnas de uni贸n tengan tipos de datos compatibles.
- Evite copias innecesarias: Establezca `copy=False` en `pd.merge()` y `df.join()` para evitar la creaci贸n de copias innecesarias de los datos.
Conclusi贸n
La fusi贸n y uni贸n de DataFrames son operaciones fundamentales en el an谩lisis de datos. Al comprender los diferentes tipos y t茅cnicas de uni贸n, puede combinar y analizar datos de varias fuentes de manera efectiva, descubriendo informaci贸n valiosa y promoviendo la toma de decisiones informada. Desde combinar datos de ventas con informaci贸n de productos hasta analizar cadenas de suministro globales, dominar estas t茅cnicas lo empoderar谩 para abordar tareas complejas de manipulaci贸n de datos con confianza. Recuerde considerar las implicaciones de rendimiento al trabajar con grandes conjuntos de datos y aprovechar las funciones avanzadas como los par谩metros `indicator` y `validate` para un an谩lisis m谩s robusto y perspicaz.