Fusión de DataFrames con Pandas: merge, concat y join

Clase 21 de 32 • Curso de Python para Ciencia de Datos

Paola Alapizco

student•

Les dejo los DataFrames que la profesora utiliza en la clase:

# Ejercicios con merge()
df1 = pd.DataFrame({
  'key': ['A', 'B', 'C'],
  'value1': [1,2,3]
})

df2 = pd.DataFrame({
  'key': ['B', 'C', 'D'],
  'value2': [4,5,6]
})

# Ejercicios con concat()
df3 = pd.DataFrame({
  'A': ['A0', 'A1', 'A2'],
  'B': ['B0', 'B1', 'B2'],
})

df4 = pd.DataFrame({
  'A': ['A3', 'A4', 'A5'],
  'B': ['B3', 'B4', 'B5'],
}) 

# Ejercicios con join()
df5 = pd.DataFrame({
    'A': ['A0', 'A1', 'A2'],
    'B': ['B0', 'B1', 'B2']
  }, 
  index = ['K0', 'K1', 'K2']
) 

df6 = pd.DataFrame({
    'C': ['C0', 'C1', 'C2'],
    'D': ['DO', 'D1', 'D2']
  }, 
  index = ['K0', 'K2', 'K3']
)

Espero este aporte les sea de ayuda 💚.

Hanns Maza

student•

gracias

Dayana Castillo

student•

muchas gracias :3

Mario Alexander Vargas Celis

student•

La fusión de **DataFrames** en **Pandas** es una operación clave para combinar datos de diferentes fuentes, similar a las uniones de tablas en SQL. Se puede realizar de diferentes maneras, dependiendo de cómo deseas combinar los conjuntos de datos. Las funciones principales para fusionar son merge(), join(), y concat().

### 1. **merge() para fusionar DataFrames**

El método merge() es el más común para fusionar dos **DataFrames** basándose en una o más columnas o índices en común. Ofrece varias opciones de tipo de unión (join), como **inner**, **outer**, **left**, y **right**.

#### Tipos de uniones:

- **Inner join**: Devuelve solo las filas que tienen correspondencias en ambos DataFrames.

- **Left join**: Devuelve todas las filas del DataFrame izquierdo y solo las que coinciden del DataFrame derecho.

- **Right join**: Devuelve todas las filas del DataFrame derecho y solo las que coinciden del DataFrame izquierdo.

- **Outer join**: Devuelve todas las filas de ambos DataFrames, completando con NaN donde no haya correspondencias.

#### Ejemplo básico de merge():


import pandas as pd



\# Crear dos DataFrames de ejemplo

df1 = pd.DataFrame({

&#x20;   'id': \[1, 2, 3, 4],

&#x20;   'nombre': \['Ana', 'Pedro', 'Juan', 'Lucía']

})



df2 = pd.DataFrame({

&#x20;   'id': \[3, 4, 5, 6],

&#x20;   'ciudad': \['Madrid', 'Sevilla', 'Valencia', 'Barcelona']

})



\# Fusión usando la columna 'id'

df\_merged = pd.merge(df1, df2, on='id', how='inner')

print(df\_merged)

**Resultado (inner join):**


&#x20;  id nombre    ciudad

0   3   Juan    Madrid

1   4  Lucía   Sevilla

#### Otros tipos de uniones:

- **Left join**:


df\_left = pd.merge(df1, df2, on='id', how='left')

print(df\_left)

**Resultado:**


&#x20;  id nombre    ciudad

0   1    Ana       NaN

1   2  Pedro       NaN

2   3   Juan    Madrid

3   4  Lucía   Sevilla

- **Right join**:


df\_right = pd.merge(df1, df2, on='id', how='right')

print(df\_right)

**Resultado:**


&#x20;  id nombre    ciudad

0   3   Juan    Madrid

1   4  Lucía   Sevilla

2   5    NaN  Valencia

3   6    NaN  Barcelona

- **Outer join**:


df\_outer = pd.merge(df1, df2, on='id', how='outer')

print(df\_outer)

**Resultado:**


&#x20;  id nombre    ciudad

0   1    Ana       NaN

1   2  Pedro       NaN

2   3   Juan    Madrid

3   4  Lucía   Sevilla

4   5    NaN  Valencia

5   6    NaN  Barcelona

### 2. **Fusión en base a múltiples columnas**

También puedes fusionar DataFrames basándote en más de una columna.

#### Ejemplo:


df1 = pd.DataFrame({

&#x20;   'id': \[1, 2, 3, 4],

&#x20;   'nombre': \['Ana', 'Pedro', 'Juan', 'Lucía'],

&#x20;   'ciudad': \['Madrid', 'Sevilla', 'Valencia', 'Barcelona']

})



df2 = pd.DataFrame({

&#x20;   'id': \[3, 4, 5, 6],

&#x20;   'ciudad': \['Valencia', 'Barcelona', 'Madrid', 'Sevilla'],

&#x20;   'ventas': \[200, 150, 300, 400]

})



\# Fusión usando tanto 'id' como 'ciudad'

df\_multi\_merge = pd.merge(df1, df2, on=\['id', 'ciudad'], how='inner')

print(df\_multi\_merge)

**Resultado:**


&#x20;  id    nombre    ciudad  ventas

0   3     Juan  Valencia     200

1   4    Lucía  Barcelona     150

### 3. **concat() para concatenar DataFrames**

El método concat() se utiliza para apilar DataFrames uno encima del otro (unión vertical) o uno al lado del otro (unión horizontal).

#### Concatenación vertical (por filas):


\# Crear dos DataFrames de ejemplo

df1 = pd.DataFrame({

&#x20;   'id': \[1, 2],

&#x20;   'nombre': \['Ana', 'Pedro']

})



df2 = pd.DataFrame({

&#x20;   'id': \[3, 4],

&#x20;   'nombre': \['Juan', 'Lucía']

})



\# Concatenar los DataFrames por filas

df\_concat = pd.concat(\[df1, df2], axis=0)

print(df\_concat)

**Resultado:**


&#x20;  id  nombre

0   1    Ana

1   2  Pedro

0   3   Juan

1   4  Lucía

#### Concatenación horizontal (por columnas):


\# Crear dos DataFrames de ejemplo con el mismo número de filas

df3 = pd.DataFrame({

&#x20;   'edad': \[25, 30],

&#x20;   'ciudad': \['Madrid', 'Barcelona']

})



\# Concatenar por columnas

df\_concat\_cols = pd.concat(\[df1, df3], axis=1)

print(df\_concat\_cols)

**Resultado:**


&#x20;  id  nombre  edad    ciudad

0   1    Ana    25    Madrid

1   2  Pedro    30  Barcelona

### 4. **join() para combinar DataFrames basados en el índice**

El método join() se utiliza para combinar DataFrames usando sus índices en lugar de una columna específica. Esto es útil cuando ya tienes índices bien definidos en los DataFrames.

#### Ejemplo:


\# Crear dos DataFrames con índices

df1 = pd.DataFrame({

&#x20;   'nombre': \['Ana', 'Pedro'],

&#x20;   'edad': \[25, 30]

}, index=\['A', 'B'])



df2 = pd.DataFrame({

&#x20;   'ciudad': \['Madrid', 'Barcelona'],

&#x20;   'ventas': \[100, 200]

}, index=\['A', 'B'])



\# Hacer join usando el índice

df\_join = df1.join(df2)

print(df\_join)

**Resultado:**


&#x20; nombre  edad     ciudad  ventas

A    Ana    25     Madrid     100

B  Pedro    30  Barcelona     200

#### Usando join() con diferentes índices:

Si los índices no coinciden, puedes usar el argumento how para especificar el tipo de unión (por defecto es left).


df3 = pd.DataFrame({

&#x20;   'ciudad': \['Sevilla', 'Valencia'],

&#x20;   'ventas': \[150, 250]

}, index=\['C', 'D'])



df\_join\_outer = df1.join(df3, how='outer')

print(df\_join\_outer)

**Resultado:**


&#x20; nombre  edad     ciudad  ventas

A    Ana  25.0     Madrid    100.0

B  Pedro  30.0  Barcelona    200.0

C    NaN   NaN    Sevilla    150.0

D    NaN   NaN   Valencia    250.0

### Resumen de funciones:

- **merge()**: Fusiona dos DataFrames basado en columnas comunes, con soporte para diferentes tipos de uniones (inner, outer, left, right).

- **concat()**: Concatenación de DataFrames por filas (vertical) o columnas (horizontal).

- **join()**: Combina DataFrames usando índices, con soporte para diferentes tipos de uniones.

Estas operaciones son útiles para consolidar datos de diferentes fuentes y reorganizar la información de manera eficiente. Si tienes algún caso específico o necesitas más detalles, ¡déjame saber!

Francisco Cisneros

student•

Buenas clases pero no entendí el desafío de como hacer uso de la fusión de Dataframes al nuestro df Retail. El método trata de unir más de dos dataframes y el Retail solo es uno solo df.

Miguel Ángel Torregrosa Calvo

student•

Aquí están los seis DataFrames:

df1 = pd.DataFrame({

'key': ['A', 'B', 'C'],

'value1': [1,2,3]

})

df2 = pd.DataFrame({

'key': ['B', 'C', 'D'],

'value2': [4,5,6]

})

df3 = pd.DataFrame({

'A': ['A0', 'A1', 'A2'],

'B': ['B0', 'B1', 'B2'],

})

df4 = pd.DataFrame({

'A': ['A3', 'A4', 'A5'],

'B': ['B3', 'B4', 'B5'],

})

df5 = pd.DataFrame({

'A': ['A0', 'A1', 'A2'],

'B': ['B0', 'B1', 'B2']

}, index = ['K0', 'K1', 'K2'])

df6 = pd.DataFrame({

'C': ['C0', 'C1', 'C2'],

'D': ['DO', 'D1', 'D2']

}, index = ['K0', 'K2', 'K3'])

Daniel Humberto Ortiz Vargas

student•

el codigo que deja esta clase en los archivos no esta acorde a lo practicadpo

Gabriel Obregón

student•

1. Creación de DataFrames de Ejemplo

df1 = pd.DataFrame({

'key': ['A', 'B', 'C'],

'value1': [1, 2, 3]

})

df2 = pd.DataFrame({

'key': ['B', 'C', 'D'],

'value2': [4, 5, 6]

})

print(df1)

print(df2)

Descripción:

Se crean dos DataFrames, df1 y df2:
- df1 tiene dos columnas: key y value1.
- df2 tiene dos columnas: key y value2.
Ambos DataFrames se imprimen.

Resultado: df1:

key value1

0 A 1

1 B 2

2 C 3

df2:

key value2

0 B 4

1 C 5

2 D 6

2. Inner Join

inner_merged = pd.merge(df1, df2, on='key', how='inner')

print(inner_merged)

Descripción:

Realiza un inner join en df1 y df2 utilizando la columna key.
Solo incluye las filas con claves coincidentes en ambos DataFrames.

Resultado:

key value1 value2

0 B 2 4

1 C 3 5

3. Outer Join

outer_merged = pd.merge(df1, df2, on='key', how='outer')

print(outer_merged)

Descripción:

Realiza un outer join en df1 y df2 utilizando la columna key.
Incluye todas las filas de ambos DataFrames, rellenando con NaN los valores faltantes.

Resultado:

key value1 value2

0 A 1.0 NaN

1 B 2.0 4.0

2 C 3.0 5.0

3 D NaN 6.0

4. Left Join

left_merged = pd.merge(df1, df2, on='key', how='left')

print(left_merged)

Descripción:

Realiza un left join en df1 y df2.
Incluye todas las filas de df1 y las filas coincidentes de df2.

Resultado:

key value1 value2

0 A 1 NaN

1 B 2 4.0

2 C 3 5.0

5. Right Join

right_merged = pd.merge(df1, df2, on='key', how='right')

print(right_merged)

Descripción:

Realiza un right join en df1 y df2.
Incluye todas las filas de df2 y las filas coincidentes de df1.

Resultado:

key value1 value2

0 B 2.0 4

1 C 3.0 5

2 D NaN 6

6. Concatenación Vertical

vertical_concat = pd.concat([df3, df4])

print(vertical_concat)

Descripción:

Concatena dos DataFrames, df3 y df4, de forma vertical.

Resultado:

A B

0 A0 B0

1 A1 B1

2 A2 B2

0 A3 B3

1 A4 B4

2 A5 B5

7. Concatenación Horizontal

horizontal_concat = pd.concat([df3, df4], axis=1)

print(horizontal_concat)

Descripción:

Concatena df3 y df4 de forma horizontal.

Resultado:

A B A B

0 A0 B0 A3 B3

1 A1 B1 A4 B4

2 A2 B2 A5 B5

8. Operación Join

joined = df5.join(df6, how='inner')

print(joined)

Descripción:

Realiza un inner join entre df5 y df6 utilizando sus índices.

Resultado:

A B C D

K0 A0 B0 C0 D0

K2 A2 B2 C1 D1

Juan David Lozada Calderon

student•

Gracias por las informaciones, pero hubiese sido mucho mejor con usos en dataFrames.

Marina Barraza

student•

La fusión de DataFrames en pandas es un proceso esencial para combinar datos de diferentes fuentes en un solo DataFrame. Este proceso es crucial en la manipulación de datos y en el análisis porque permite integrar información dispersa para un análisis más completo.

Marina Barraza

student•

Mis Apuntes:

Importancia de la Fusión de DataFrames

Integración de Datos:
- Unificación: Permite combinar datos que están en diferentes DataFrames pero que comparten una o más columnas comunes. Por ejemplo, fusionar datos de ventas con datos de clientes basados en una columna de ID de cliente.
- Enriquecimiento: Añade información adicional a un DataFrame principal, lo que permite un análisis más enriquecido. Por ejemplo, agregar detalles de productos a un DataFrame de ventas para obtener un contexto adicional.
Análisis Completo:
- Combinación de Información: Facilita el análisis de datos combinando diferentes aspectos del mismo problema o contexto. Por ejemplo, combinar datos de transacciones con datos de stock para evaluar el rendimiento de productos.
- Contextualización: Proporciona una vista más completa al combinar datos relacionados, lo que ayuda a identificar patrones y relaciones entre variables.

Hector Puentes

student•

El merge me recordo mucho a las operaciones que se hacen con conjuntos

Union seria el Outer
Intersección el inner
Diferencia seria el right o el left

FABIAN PEREZ

student•

No se si es asombroso o me da meido

FABIAN PEREZ

student•

Esta clase se facilita mucho si ya tienes conocimientos previos en bases de datos

Cristian Rodríguez

student•

En los DataFrames de Pandas, los nombres de las columnas deben ser únicos para evitar confusiones al acceder a los datos. Sin embargo, los índices pueden no ser únicos; puedes tener índices duplicados, lo cual puede complicar ciertas operaciones. Es recomendable tener índices únicos para facilitar la manipulación y análisis de datos. Esto se relaciona con la importancia de la organización y limpieza de datos, un aspecto clave en el análisis de datos que se ha tratado en tu curso.

Esteban Diaz Diez

student•

Si alguien se confundió aquí y no ha estudiado SQL, revise los JOIN en SQL, eso lo guiará muy bien. Es pura teoría de conjuntos.

Glenda López

student•

Cuando se utilizan joins en Pandas y hay columnas coincidentes, el resultado dependerá del tipo de join que se esté utilizando:

Inner Join: Solo se incluirán las filas donde las columnas coinciden en ambos DataFrames.
Outer Join: Se incluirán todas las filas de ambos DataFrames. Las filas que no tienen coincidencias se llenarán con NaN.
Left Join: Se incluirán todas las filas del DataFrame de la izquierda y solo las coincidencias del de la derecha. Los valores no coincidentes se llenarán con NaN.
Right Join: Similar al left, pero incluye todas las filas del DataFrame de la derecha.

Estos métodos permiten combinar datos de manera efectiva.

Juan Felipe Hernandez Giraldo

student•

El on='key' especifica la columna 'key' que se usará para buscar coincidencias entre df1 y df2. El how='inner' indica que solo se incluirán las filas donde hay coincidencias en ambas tablas, es decir, sólo las filas que tienen el mismo valor en la columna 'key'. Esto resulta en un DataFrame que combina datos de ambos DataFrames solo para las claves coincidentes.

Roberto Arriaga

student•

La plataforma es excelente y la maestra también, pero el curso parece hecho con miedo, con desconfianza a los alumnos; si va a haber este mismo curso en nivel dos, entonces entendería... igual hay varios "errorcitos" a lo largo del curso"

jesus manuel vergara arias

student•

Esto puede servir para entender NaN:

NaN and None in Pandas

NaN and None both have their place, and Pandas is built to handle the two of them nearly interchangeably, converting between them where appropriate:

x = pd.Series([1, np.nan, 2, None]) print(x)

0 1.0 1 NaN 2 2.0 3 NaN dtype: float64 For types that don’t have an available sentinel value, Pandas automatically type-casts when NA values are present. For example, if we set a value in an integer array to np.nan, it will automatically be upcast to a floating-point type to accommodate the NA:

x = pd.Series(range(2), dtype=int) print(x)

0 0

1 1

dtype: int64

x[0] = None print(x)

0 NaN 1 1.0 dtype: float64 Notice that in addition to casting the integer array to floating point, Pandas automati‐ cally converts the None to a NaN value.

pag: 123

https://archive.org/details/python-data-science-handbook.pdf/page/122/mode/2up

En el caso del código de la profe, si escogemos la columna value1 en el caso outer: "los NaN en la mayoria de los casos funcionan algo asi como 0.0" versiones de cero flotantes

outer_merge = pd.merge(df1, df2, on='key', how='outer')
columna_value1 = outer_merge['value1']
print(columna_value1) 
0    1.0
1    2.0
2    3.0
3    NaN
print(columna_value1.sum()) 
6.0


```columna\_value1 = outer\_merge\['value1']print(columna\_value1.sum())

Paola Alapizco

student•

📝 Mis apuntes de la clase

La fusión/unión de DataFrames consiste en crear un nuevo DataFrame a partir de dos DataFrames, lo que nos permite integrar información de diferentes fuentes en una sola, de esta manera podemos realizar un análisis más integral.

Pandas provee tres funciones para está tarea.

merge()

Permite la unión de dos DataFrames a partir de una columna especifica, los valores de esta columna deben coincidir en ambos DF.

Parámetros:

left: DataFrame que esta estará la izquierda.
right: DataFrame que esta estará la derecha.
how: Cómo será la union entre los DF.
- inner: Intersección entre los dos DataFrames.
- outer: Lo opuesto a la intersección, solo los elementos que no estén en ambos DataFrames.
- left: Regresa todos los elementos del DataFrame de la izquierda (incluyendo la intersección).
- right: Regresa todos los elementos del DataFrame de la derecha (incluyendo la intersección).
on: Nombre de la columna a partir del cual se realizará el merge.

import pandas as pd
df1 = pd.DataFrame({
  'key': ['A', 'B', 'C'],
  'value1': [1,2,3]
})

df2 = pd.DataFrame({
  'key': ['B', 'C', 'D'],
  'value2': [4,5,6]
})

display(df1, df2)

inner_merge = pd.merge(left=df1, right=df2, on="key", how="inner")
print("Inner merge:")
display(inner_merge)

outer_merge = pd.merge(left=df1, right=df2, on="key", how="outer")
print("Outer merge:")
display(outer_merge)

display(df1,df2)
left_merge = pd.merge(left=df1, right=df2, on="key", how="left")
print("Left merge:")
display(left_merge)

right_merge = pd.merge(left=df1, right=df2, on="key", how="right")
print("Right merge:")
display(right_merge)

concat()

Esta función también nos permite unir DataFrames, con las diferencias de que podemos incluir más de dos DF y podemos seleccionar la orientación de la unión (horizontal ó vertical).

Parámetros

objs: Lista con los DataFrames.
axis: Orientación, 0 = vertical/filas (default), 1 = horizontal/columnas
join: Tipo de concatenación, inner o outer.


df3 = pd.DataFrame({
  'A': ['A0', 'A1', 'A2'],
  'B': ['B0', 'B1', 'B2'],
})

df4 = pd.DataFrame({
  'A': ['A3', 'A4', 'A5'],
  'B': ['B3', 'B4', 'B5'],
}) 

display(df3, df4)

vertical_concat = pd.concat([df3, df4], axis=0)
print("Concatenación vertical (filas)")
display(vertical_concat)

horizontal_concat = pd.concat([df3, df4], axis=1)
print("Concatenación horizontal (columnas)")
display(horizontal_concat)

join()

Permite la unión de dos DataFrames a partir de los indices de ambos DF, ésta función se utiliza a partir del propio DataFrame.

Parámetros:

other: DataFrame que queremos unir
on: Default es el índice del DF.
how: Cómo será la union entre los DF.
- inner: Intersección entre los dos DataFrames.
- outer: Lo opuesto a la intersección, solo los elementos que no estén en ambos DataFrames.
- left: Regresa todos los elementos del DataFrame de la izquierda (incluyendo la intersección).
- right: Regresa todos los elementos del DataFrame de la derecha (incluyendo la intersección).


df5 = pd.DataFrame({
    'A': ['A0', 'A1', 'A2'],
    'B': ['B0', 'B1', 'B2']
  }, 
  index = ['K0', 'K1', 'K2']
) 

df6 = pd.DataFrame({
    'C': ['C0', 'C1', 'C2'],
    'D': ['DO', 'D1', 'D2']
  }, 
  index = ['K0', 'K2', 'K3']
)

display(df5, df6)

inner_join = df5.join(other=df6, how="inner")
print("Inner join")
display(inner_join)

left_join = df5.join(other=df6, how="left")
print("Left join")
display(left_join)

📌NOTA: merge y join aplican la misma lógica que los joins en SQL.

Espero este aporte les sea de utilidad 💚.

Javier Ladino

student•

Quería combinar el DF de "sales_data" con otro DF que tenga la densidad de población por país "population_densities":

Sacar el listado de los países

# Listado de paises
sales_data_countries = sales_data['Country'].unique()
sales_data_countries
``````js
array(['United Kingdom', 'France', 'Australia', 'Netherlands', 'Germany',
       'Norway', 'EIRE', 'Switzerland', 'Spain', 'Poland', 'Portugal',
       'Italy', 'Belgium', 'Lithuania', 'Japan', nan], dtype=object)

Buscar la información y crear el DF

#crear dataframe 
df_population_densities = pd.DataFrame(population_densities, columns=['Country', 'PopulationDensity'])
df_population_densities
``````js
Country	PopulationDensity
0	United Kingdom	275
1	France	122
2	Australia	3.4
3	Netherlands	512
4	Germany	237
5	Norway	15
6	EIRE	72
7	Switzerland	215
8	Spain	94
9	Poland	124
10	Portugal	112
11	Italy	203
12	Belgium	377
13	Lithuania	43
14	Japan	347

Hacer el merge de ambos DF utilizando el país

merged_data = pd.merge(sales_data, df_population_densities, on='Country', how='left')
merged_data.head()
```![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202024-08-20%20a%20la%28s%29%208.10.31-2c91305c-2fd8-4a52-8095-f194995b2726.jpg)