No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

# Merge y Concat

20/24
Recursos

Como podemos usar la lógica anteriormente vista en código, usando los parámetros de Pandas

• Importamos Pandas y Numpy
``````import pandas as pd
import numpy as np
``````

## Concat

• En esta ocasión vamos a crear un DataFrame nuevo
``````df1 = pd.DataFrame({'A':['A0', 'A1', 'A2','A3'],
'B':['B0', 'B1', 'B2','B3'],
'C':['C0', 'C1', 'C2','C3'],
'D':['D0', 'D1', 'D2','D3']})

df2 = pd.DataFrame({'A':['A4', 'A5', 'A6','A7'],
'B':['B4', 'B5', 'B6','B7'],
'C':['C4', 'C5', 'C6','C7'],
'D':['D4', 'D5', 'D6','D7']})
``````
• Concatenar los DataFrames
``````pd.concat([df1,df2])
---> A  B   C   D
0   A0  B0  C0  D0
1   A1  B1  C1  D1
2   A2  B2  C2  D2
3   A3  B3  C3  D3
0   A4  B4  C4  D4
1   A5  B5  C5  D5
2   A6  B6  C6  D6
3   A7  B7  C7  D7
``````
• Corregir los índices
``````pd.concat([df1,df2], ignore_index= True)
---> A  B   C   D
0   A0  B0  C0  D0
1   A1  B1  C1  D1
2   A2  B2  C2  D2
3   A3  B3  C3  D3
4   A4  B4  C4  D4
5   A5  B5  C5  D5
6   A6  B6  C6  D6
7   A7  B7  C7  D7
``````
• Por axis 1
``````pd.concat([df1,df2], axis = 1)
---> A  B   C   D   A.1 B.1 C.1 D.1
0   A0  B0  C0  D0  A4  B4  C4  D4
1   A1  B1  C1  D1  A5  B5  C5  D5
2   A2  B2  C2  D2  A6  B6  C6  D6
3   A3  B3  C3  D3  A7  B7  C7  D7
``````

## Merge

• Creamos DataFrame
``````izq = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'A' : ['A0', 'A1', 'A2','A3'],
'B': ['B0', 'B1', 'B2','B3']})

der = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'C' : ['C0', 'C1', 'C2','C3'],
'D': ['D0', 'D1', 'D2','D3']})
``````
• Unir el DataFrame `Der` a `Izq`
``````izq.merge(der)
---> key A  B   C   D
0   k0  A0  B0  C0  D0
1   k1  A1  B1  C1  D1
2   k2  A2  B2  C2  D2
3   k3  A3  B3  C3  D3
``````
``````MERGE 2
izq = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'A' : ['A0', 'A1', 'A2','A3'],
'B': ['B0', 'B1', 'B2','B3']})

der = pd.DataFrame({'key_2' : ['k0', 'k1', 'k2','k3'],
'C' : ['C0', 'C1', 'C2','C3'],
'D': ['D0', 'D1', 'D2','D3']})
``````
• Hay diferencias entre algunas columnas, por esa razón hay que separarlos de esta manera:
``````izq.merge(der, left_on = 'key', right_on='key_2')
---> key A  B   key_2   C   D
0   k0  A0  B0  k0    C0  D0
1   k1  A1  B1  k1    C1  D1
2   k2  A2  B2  k2    C2  D2
3   k3  A3  B3  k3    C3  D3
``````
``````MERGE 3

izq = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'A' : ['A0', 'A1', 'A2','A3'],
'B': ['B0', 'B1', 'B2','B3']})

der = pd.DataFrame({'key_2' : ['k0', 'k1', 'k2',np.nan],
'C' : ['C0', 'C1', 'C2','C3'],
'D': ['D0', 'D1', 'D2','D3']})
``````
• Si tenemos un `NaN`en nuestro DataFrame, pandas no lo detectará como un mach. Se soluciona con `How`, dando así, una preferencia.
``````izq.merge(der, left_on = 'key', right_on='key_2', how='left')
---> key A  B   key_2   C   D
0   k0  A0  B0  k0    C0  D0
1   k1  A1  B1  k1    C1  D1
2   k2  A2  B2  k2    C2  D2
3   k3  A3  B3  NaN  NaN  NaN
``````

Aportes 38

Preguntas 9

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Aquí los diccionarios:

CONCAT

``````	df1 = pd.DataFrame({'A':['A0', 'A1', 'A2','A3'],
'B':['B0', 'B1', 'B2','B3'],
'C':['C0', 'C1', 'C2','C3'],
'D':['D0', 'D1', 'D2','D3']})

df2 = pd.DataFrame({'A':['A4', 'A5', 'A6','A7'],
'B':['B4', 'B5', 'B6','B7'],
'C':['C4', 'C5', 'C6','C7'],
'D':['D4', 'D5', 'D6','D7']})
``````

MERGE 1

``````izq = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'A' : ['A0', 'A1', 'A2','A3'],
'B': ['B0', 'B1', 'B2','B3']})

der = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'C' : ['C0', 'C1', 'C2','C3'],
'D': ['D0', 'D1', 'D2','D3']})
``````

MERGE 2

``````izq = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'A' : ['A0', 'A1', 'A2','A3'],
'B': ['B0', 'B1', 'B2','B3']})

der = pd.DataFrame({'key_2' : ['k0', 'k1', 'k2','k3'],
'C' : ['C0', 'C1', 'C2','C3'],
'D': ['D0', 'D1', 'D2','D3']})
``````

MERGE 3

``````izq = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'A' : ['A0', 'A1', 'A2','A3'],
'B': ['B0', 'B1', 'B2','B3']})

der = pd.DataFrame({'key_2' : ['k0', 'k1', 'k2',np.nan],
'C' : ['C0', 'C1', 'C2','C3'],
'D': ['D0', 'D1', 'D2','D3']})
``````

A estás alturas del curso puedo decir que está mil veces mejor que el anterior curso sobre pandas, demasiado bueno el profesor.

Hola, un ejercicio que hice y pueden hacer para practicar estos conceptos es pedirle datos de ejemplo de la vida real al chatgpt.
Le pedi ejemplos de datos de pacientes. y me salieron varios dataframes que pude usar para hacer merge, join y concatenate.

Para no confundierse con el axis entre el 0 y el 1 pueden usar la palabra “columns” o “rows”.

``````pd.concat([df1,df2],axis="columns")
``````

Si usas el comando outer te va votar 4 registros,ya que, estarán contenidos los registros del left ,del right y del inner.

Aporte para crear los diccionarios usados en la clase. Es un método mucho más complejo que simplemente copiar, pegar y modificar.

Sin embargo, lo aporto como ejemplo del uso de list y dictionary comprehensions en python nivel intermedio.

``````# genera lista con keys: 'A', 'B', 'C', 'D'
keys = list('ABCD')

# values será un list comprehension que contendrá una lista de listas:
# ['A0', 'A1', ..., 'A3'], ['B0', 'B1', ..., 'B3'], ...
# es un list comprehension anidado
values = [
# crea una lista del tipo: ['A0', 'A1', ..., 'A3']
[f'{letter}{number}' for number in range(4)]
# para las letras A, B, C, D, E, F
for letter in list('ABCDEF')
]

df3 = pd.DataFrame(
# dictionary comprehension:
# uso zip para crear tuplas de dos elementos que suministren
# pares de valores k:v al diccionario
{k:v for k,v  in zip(keys, values)}
)
``````

El CONCATENATE se puede usar con dataframe que pueden tener diferencias en alguna columna.
Del dataframe de los libros hacemos 2 dataframe con columnas distintas y los concatenamos

``````df_books = pd.read_csv('/content/VIDEO 12 bestsellers-with-categories.csv',sep=',',header=0)
``````

Con las primeros registros

``````df_books_1=df_books[['Name','Author','Price','Year']].head(5)
df_books_1
``````

Con los últimos registros y además tiene la columna GENRE

``````df_books_2=df_books[['Name','Author','Price','Year','Genre']].tail(5)
df_books_2
``````

Concatenamos en sentido axis = 0. Los valores faltantes son NULL

``````df_books_concat = pd.concat([df_books_1,df_books_2],ignore_index=True)
df_books_concat
``````

A los valores nulos le asignamos Unrated (sin clasificación) que es más descriptivo.
Para eso usamos where y la concatenación en sentido de las columnas (axis=1).

``````df_genre = df_books_concat.Genre.where(df_books_concat.Genre.notnull() ,'Unrated')
df_books_concat2 = pd.concat([df_books_concat[['Name','Author','Price','Year']],df_genre],axis=1)
``````

Información resumida de esta clase
#EstudiantesDePlatzi

• Utilizando la función concat puedo unir diferentes DataFrame y estos deben ir dentro de [ ]

• Por defecto la fusión se hace por el Axis = 0, es decir por las filas, si utilizamos el Axis = 1, la fusión se realizará por las columnas

• También podemos utilizar la función merge para fusionar 2 DataFrame, lo ideal seria que nuestros DataFrame tengan una llave en común para realizar un correcto merge

• Cuando los conjuntos de datos no poseen una llave en común, debemos especificar que llave se usara en right y que llave en left

• Utilizando el parámetro how, puedo definir qué tipo de unión voy a realizar. Muy parecido a las consultas que se hacen en SQL

NOTA QUE TE AHORRARÁ TIEMPO:
Google Colab tiene atajos de teclado similares a VS code. Puedes cambiar de golpe varias líneas de código.
En vez de cambiar cada letra una por una, usa Ctrl + D para seleccionar las ocurrencias.

``````dic={"A":[f"A{i}" for i in np.arange(0,4) if i==i],
"B":[f"B{i}" for i in np.arange(0,4) if i==i],
"C":[f"C{i}" for i in np.arange(0,4) if i==i],
"D":[f"D{i}" for i in np.arange(0,4) if i==i]
}
``````

Probemos lo que hace este comando:

``````izq.merge(der, left_on='key', right_on='key_2', how='outer')
``````

#### Mis apuntes #21 (Notion)

Hola! Un pequeño grafico colorido de merge por izquierda para nosotros los dummies

Alta remera profe!
(remera = camiseta)

Información para entender la clase

Creo que el concat es el UNION de sql en pandas, si ya se que los pythoneros me vana decir que el concat es mas poderoso!!

Sigo recalcando, los recurso de la clase están muy incompletas no se guíen por ahí para hacer sus apuntes o no les van a servir, háganle las correcciones pertinentes.

Otra gran herramienta para salir adelante en las pruebas técnicas.

Me encanto el uso de este codigo y como lo podemos implementar con elementos nulos. Esto si es interesante.

" Producto cartesiano

Mi tutorial en Italiano =)

``````import pandas as pd

# Creazione dei DataFrames
data_azzurra = {
'Nome': ['Marco', 'Alessandro', 'Matteo', 'Luca'],
'Posizione': ['Portiere', 'Difensore', 'Centrocampista', 'Attaccante'],
}
df_azzurra = pd.DataFrame(data_azzurra)

data_bianca = {
'Nome': ['Giovanni', 'Andrea', 'Francesco', 'Gabriele'],
'Posizione': ['Portiere', 'Difensore', 'Centrocampista', 'Attaccante'],
}
df_bianca = pd.DataFrame(data_bianca)

# Left Join
left_join = pd.merge(df_azzurra, df_bianca, on='Posizione', how='left', suffixes=('_Azzurra', '_Bianca'))

# Right Join
right_join = pd.merge(df_azzurra, df_bianca, on='Posizione', how='right', suffixes=('_Azzurra', '_Bianca'))

# Inner Join
inner_join = pd.merge(df_azzurra, df_bianca, on='Posizione', how='inner', suffixes=('_Azzurra', '_Bianca'))

# Outer Join
outer_join = pd.merge(df_azzurra, df_bianca, on='Posizione', how='outer', suffixes=('_Azzurra', '_Bianca'))

# Concat
concat_df = pd.concat([df_azzurra, df_bianca]).reset_index(drop=True)

``````

Por si alguien usando el how encuentra un método llamado ‘cross’ resulta que la docu de pandas lo define como:

cross: creates the cartesian product from both frames, preserves the order of the left keys.

Es bueno que a esta clase le añadas el concepto de clave primaria, para que la gente no se confunda con el uso compartido de Key.

Le pedí unos ejemplos en OpenAi Gpt3 y puso ese mismo ejemplo el de Merge jejeje

Combinar DataFrames
Para combinar dataframes tenemos los métodos concat, merge y join

• pd.concat(df_1,df_2) → concatena, añade un dataframe luego de otro, permite los parámetros de axis (por defecto 0) e ignore_index (True para resetear los índices ignorando los índices originales)

• pd.merge(df_left, df_right) o df_left.merge(df_right), realiza una unión de dataframes de manera similar a los conjuntos, admite el parámetro on, que indica el nombre de la columna llave (la columna en común), en caso no tengan el mismo nombre usamos los parámetros left_on y right_on, otro parámetro que admite es how que puede ser ‘left’, ‘right’, ‘inner’ o ‘outer’

• left → trae todos los valores del df izquierdo, añade valores nulos en las filas en las que no hay intersección con el df right
• right → similar a left pero con el df derecho
• outer → trae todos los datos, rellenandolos los valores que no tienen en común cin valores nulos
• inner → trae solo los valores de la intersección, es el valor por defecto
• pd.join(), similar a merge pero la llave será el indice (por tanto no es necesario el parámetro on no es necesario

``````izq.merge(der, left_on = 'Key', right_on = 'Key_2', how = 'right')
``````

Dejo mis apuntes de clase aqui

****NOTAS CLASE ****

``````Merge y Concat
Como podemos usar la lógica anteriormente vista en código, usando los parámetros de Pandas
________________________________________
[1]
0 s
import pandas as pd
import numpy as np
________________________________________
[2]
0 s
df1 = pd.DataFrame({'A':['A0', 'A1', 'A2','A3'],
'B':['B0', 'B1', 'B2','B3'],
'C':['C0', 'C1', 'C2','C3'],
'D':['D0', 'D1', 'D2','D3']})
________________________________________
[3]
0 s
df1
________________________________________
[4]
df2 = pd.DataFrame({'A':['A4', 'A5', 'A6','A7'],
'B':['B4', 'B5', 'B6','B7'],
'C':['C4', 'C5', 'C6','C7'],
'D':['D4', 'D5', 'D6','D7']})

#aca estamos declarando nuestros dos data frame
#el siguiente paso es concatenar ambos data frame con las funciones que vimos anteriormente
________________________________________
[5]
0 s
df2
________________________________________
[6]
pd.concat([df1,df2])
#aca ya estan nuestros dos dataframe concatenados con todos los valores, como se puede ver los indices
#heredan el indice dela alterios esto no quiere desir que se repiten
________________________________________
[7]
pd.concat([df1,df2],ignore_index=True)
#aca estamos corigiendo lo de los indices repetidos, tomando los valores y reorganizandoloes
________________________________________
[9]
0 s
pd.concat([df1,df2],axis=1)

#en esta funciom organizamos con axis 1, a nivel de columnas el ampliara de manera columnar nuetra
#concatenacion respetando la forma del dataframe lo cual ya no crecemos de forma vertical sino de formar
#orizontal pero es muy raro hacerlo de esta forma
________________________________________
funcion Merge
________________________________________
[13]
0 s
izq = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'A' : ['A0', 'A1', 'A2','A3'],
'B': ['B0', 'B1', 'B2','B3']})
________________________________________
[14]
0 s
izq
________________________________________
[15]
0 s
der = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'C' : ['C0', 'C1', 'C2','C3'],
'D': ['D0', 'D1', 'D2','D3']})
________________________________________
[16]
0 s
der
________________________________________
[18]
izq.merge(der, on="key")
#aca se esta haciendo un merge por las columnas que tienen en comun tanto de izquierda como de derecha haciendo
#de uan forma muy ordenada con la lleve (key) y asi  podemos hacer join
________________________________________
[19]
0 s
izq = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'A' : ['A0', 'A1', 'A2','A3'],
'B': ['B0', 'B1', 'B2','B3']})

der = pd.DataFrame({'key2' : ['k0', 'k1', 'k2','k3'],
'C' : ['C0', 'C1', 'C2','C3'],
'D': ['D0', 'D1', 'D2','D3']})
________________________________________
[21]
izq.merge(der, left_on="key", right_on="key2")
#estamos combinando ambos con la modificacion que se le hiso al segundo dataframe que se cambio key por key2
#está haciendo la relación en el cambio de la derecha
#esto lo hacemos cuando los dataframe no tienen el mismo nombre an la columna
________________________________________
[23]
0 s
izq = pd.DataFrame({'key' : ['k0', 'k1', 'k2','k3'],
'A' : ['A0', 'A1', 'A2','A3'],
'B': ['B0', 'B1', 'B2','B3']})

der = pd.DataFrame({'key2' : ['k0', 'k1', 'k2',np.nan],
'C' : ['C0', 'C1', 'C2','C3'],
'D': ['D0', 'D1', 'D2','D3']})
________________________________________
[24]
0 s
der
________________________________________
[25]
izq.merge(der, left_on="key", right_on="key2")
#aca no me trae la tercera fila porque no me esta haciendo merge, solo esta trallendo la intercesion
# entre ambos
________________________________________
[26]
izq.merge(der, left_on="key", right_on="key2", how="left")
#con how me trae el valor de la izquierda respetando los valores asi no esten
________________________________________
[27]
izq.merge(der, left_on="key", right_on="key2", how="inner")
#con inner traemos el valor por defaul que teniamos anteriormente
________________________________________
[28]
izq.merge(der, left_on="key", right_on="key2", how="right")
#aca me trae todo lo de la dereche asi no este y lo digeranciara con valores nulos, de esta manera
#puedo jugar con la combinación de mis datafrem
________________________________________
y así podemos utilizar el cooncat y merge para hacer la combinación y fusión de distintos datafrem, esto es muy parecido a SQL

``````

Seria bueno que se hiciera ese ejercicio con el DataFrame del csv

Muy buena clase, tenía dudas sobre .merge() y con esta clase se aclararon.