Fusión de DataFrames en Pandas

Les dejo los DataFrames que la profesora utiliza en la clase: ```python # 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 💚.

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()`: ```python import pandas as pd \# Crear dos DataFrames de ejemplo df1 = pd.DataFrame({ 'id': \[1, 2, 3, 4], 'nombre': \['Ana', 'Pedro', 'Juan', 'Lucía'] }) df2 = pd.DataFrame({ 'id': \[3, 4, 5, 6], '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):\*\* ``` id nombre ciudad 0 3 Juan Madrid 1 4 Lucía Sevilla ``` \#### Otros tipos de uniones: \- \*\*Left join\*\*: ```python df\_left = pd.merge(df1, df2, on='id', how='left') print(df\_left) ``` \*\*Resultado:\*\* ``` id nombre ciudad 0 1 Ana NaN 1 2 Pedro NaN 2 3 Juan Madrid 3 4 Lucía Sevilla ``` \- \*\*Right join\*\*: ```python df\_right = pd.merge(df1, df2, on='id', how='right') print(df\_right) ``` \*\*Resultado:\*\* ``` id nombre ciudad 0 3 Juan Madrid 1 4 Lucía Sevilla 2 5 NaN Valencia 3 6 NaN Barcelona ``` \- \*\*Outer join\*\*: ```python df\_outer = pd.merge(df1, df2, on='id', how='outer') print(df\_outer) ``` \*\*Resultado:\*\* ``` 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: ```python df1 = pd.DataFrame({ 'id': \[1, 2, 3, 4], 'nombre': \['Ana', 'Pedro', 'Juan', 'Lucía'], 'ciudad': \['Madrid', 'Sevilla', 'Valencia', 'Barcelona'] }) df2 = pd.DataFrame({ 'id': \[3, 4, 5, 6], 'ciudad': \['Valencia', 'Barcelona', 'Madrid', 'Sevilla'], '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:\*\* ``` 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): ```python \# Crear dos DataFrames de ejemplo df1 = pd.DataFrame({ 'id': \[1, 2], 'nombre': \['Ana', 'Pedro'] }) df2 = pd.DataFrame({ 'id': \[3, 4], 'nombre': \['Juan', 'Lucía'] }) \# Concatenar los DataFrames por filas df\_concat = pd.concat(\[df1, df2], axis=0) print(df\_concat) ``` \*\*Resultado:\*\* ``` id nombre 0 1 Ana 1 2 Pedro 0 3 Juan 1 4 Lucía ``` \#### Concatenación horizontal (por columnas): ```python \# Crear dos DataFrames de ejemplo con el mismo número de filas df3 = pd.DataFrame({ 'edad': \[25, 30], 'ciudad': \['Madrid', 'Barcelona'] }) \# Concatenar por columnas df\_concat\_cols = pd.concat(\[df1, df3], axis=1) print(df\_concat\_cols) ``` \*\*Resultado:\*\* ``` 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: ```python \# Crear dos DataFrames con índices df1 = pd.DataFrame({ 'nombre': \['Ana', 'Pedro'], 'edad': \[25, 30] }, index=\['A', 'B']) df2 = pd.DataFrame({ 'ciudad': \['Madrid', 'Barcelona'], 'ventas': \[100, 200] }, index=\['A', 'B']) \# Hacer join usando el índice df\_join = df1.join(df2) print(df\_join) ``` \*\*Resultado:\*\* ``` 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`). ```python df3 = pd.DataFrame({ 'ciudad': \['Sevilla', 'Valencia'], 'ventas': \[150, 250] }, index=\['C', 'D']) df\_join\_outer = df1.join(df3, how='outer') print(df\_join\_outer) ``` \*\*Resultado:\*\* ``` 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!

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

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.

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

#### **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

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

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.

Mis Apuntes: ### **Importancia de la Fusión de DataFrames** 1. **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. 2. **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.

Cuando se utilizan joins en Pandas y hay columnas coincidentes, el resultado dependerá del tipo de join que se esté utilizando: 1. **Inner Join**: Solo se incluirán las filas donde las columnas coinciden en ambos DataFrames. 2. **Outer Join**: Se incluirán todas las filas de ambos DataFrames. Las filas que no tienen coincidencias se llenarán con NaN. 3. **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. 4. **Right Join**: Similar al left, pero incluye todas las filas del DataFrame de la derecha. Estos métodos permiten combinar datos de manera efectiva.

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.

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"

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 ```python 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())

📝 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. ```python 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. ```js 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). ```python 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 💚.

Quería combinar el DF de "sales\_data" con otro DF que tenga la densidad de población por país "population\_densities": 1. Sacar el listado de los países ```js # 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) ``` 1. Buscar la información y crear el DF ```js #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 ``` 1. Hacer el merge de ambos DF utilizando el país ```js merged_data = pd.merge(sales_data, df_population_densities, on='Country', how='left') merged_data.head() ```

# **Tipos de Uniones:** * **Inner Join:** Combina solo las filas que tienen coincidencias en ambas tablas. * **Left Join:** Combina todas las filas del DataFrame de la izquierda, y las filas coincidentes del DataFrame de la derecha. * **Right Join:** Combina todas las filas del DataFrame de la derecha, y las filas coincidentes del DataFrame de la izquierda. * **Outer Join:** Combina todas las filas de ambos DataFrames, rellenando con `NaN` donde no hay coincidencias

 Combinando los dos DataFrame que estoy trabajando el el curso

Como no encontré, a la fecha, el notebook en los recursos de esta lección, les comparto el que yo elaboré: <https://colab.research.google.com/drive/1t9ySHH8Ca3fidahMh1pusIuLVRE9Y7EW?usp=sharing>


Cuando concatenas dataframes en Pandas, especialmente de forma vertical, los índices de las filas se repiten si ambos dataframes tienen la misma estructura de columnas. Esto sucede porque Pandas mantiene su índice original. Para evitar esto, puedes usar el método `reset_index()` en los dataframes antes de concatenar. Esto generará nuevos índices únicos para las filas en el dataframe resultante. Al hacer merges, el comportamiento depende del tipo de unión; si no se especifican adecuadamente, también pueden generarse duplicados.

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.

### By: Chatgpt 3\. **Tipos de fusión**: La función principal para fusionar DataFrames es `merge()`, que tiene diferentes tipos de combinaciones. Aquí están las más comunes: * **Inner Join**: Solo incluye las filas donde hay coincidencia en ambas tablas (como una intersección). * **Left Join**: Incluye todas las filas de la tabla de la izquierda y las coincidentes de la tabla de la derecha. Si no hay coincidencia, los valores de la tabla de la derecha serán `NaN`. * **Right Join**: Similar al Left Join, pero incluye todas las filas de la tabla de la derecha. * **Outer Join**: Incluye todas las filas de ambas tablas. Los valores no coincidentes son `NaN`.