Merge y Concat

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")

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 = [ 
            # list comprehension anidado
            # 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)}
)

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

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)
df_books.head(2)

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.

Mis apuntes #21 (Notion)

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')

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

Muy buena la clase. Mejor explicado que en la Universidad.

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'],
    'Squadra': ['Juventus', 'Milan', 'Roma', 'Inter']
}
df_azzurra = pd.DataFrame(data_azzurra)

data_bianca = {
    'Nome': ['Giovanni', 'Andrea', 'Francesco', 'Gabriele'],
    'Posizione': ['Portiere', 'Difensore', 'Centrocampista', 'Attaccante'],
    'Squadra': ['Napoli', 'Lazio', 'Fiorentina', 'Atalanta']
}
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.