Cómo fusionar tramas de datos en Pandas: fusionar (), unir (), agregar (), concat () y actualizar ()

En este tutorial, combinaremos DataFrames en Pandas usando la función de combinación. También fusionaremos datos con join, append, concat, combine_first y update, con ejemplos.

Introducción

Pandas proporciona una amplia gama de métodos y funciones para manipular datos, incluida la fusión de tramas de datos. Combinar DataFrames le permite crear un nuevo DataFrame sin modificar la fuente de datos original ni alterar la fuente de datos original.

Si está familiarizado con SQL o un tipo similar de datos tabulares, probablemente esté familiarizado con el término “unirse”, que significa combinar DataFrames para formar un nuevo DataFrame. Si es un principiante, puede ser difícil comprender completamente los tipos de combinación (interior, exterior, izquierda, derecha). En este tutorial repasaremos los tipos de unión con ejemplos.

Nuestro enfoque principal sería usar las funciones merge() y concat(). Sin embargo, discutiremos otros métodos de fusión para brindarle tantas alternativas prácticas como sea posible.

Para este tutorial, estamos usando la versión de Pandas 1.1.4 y la versión de NumPy 1.19.4.

Combinar tramas de datos usando merge()

Comencemos configurando nuestros DataFrames, que usaremos para el resto del tutorial.

df1 incluirá nuestra lista de usuarios imaginarios con nombres, correos electrónicos e ID.

1
2
3
4
5
6
7
8
import pandas as pd

df1 = pd.DataFrame({'user_id': ['id001', 'id002', 'id003', 'id004', 'id005', 'id006', 'id007'],
                    'first_name': ['Rivi', 'Wynnie', 'Kristos', 'Madalyn', 'Tobe', 'Regan', 'Kristin'],
                    'last_name': ['Valti', 'McMurty', 'Ivanets', 'Max', 'Riddich', 'Huyghe', 'Illis'],
                    'email': ['[correo electrónico protegido]', '[correo electrónico protegido]', '[correo electrónico protegido]',
                              '[correo electrónico protegido]', '[correo electrónico protegido]', '[correo electrónico protegido]', '[correo electrónico protegido]']
                    })

Al diseñar bases de datos, se considera una buena práctica mantener la configuración del perfil (como el color de fondo, el enlace de la imagen del avatar, el tamaño de fuente, etc.) en una tabla separada de los datos del usuario (correo electrónico, fecha de adición, etc.). Estas tablas pueden tener una relación de uno a uno.

Para simular este escenario, haremos lo mismo creando df2 con URL de imagen e ID de usuario:

1
2
3
4
5
df2 = pd.DataFrame({'user_id': ['id001', 'id002', 'id003', 'id004', 'id005'],
                    'image_url': ['http://example.com/img/id001.png', 'http://example.com/img/id002.jpg',
                                  'http://example.com/img/id003.bmp', 'http://example.com/img/id004.jpg',
                                  'http://example.com/img/id005.png']
                    })

Así es como se ven nuestros DataFrames:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
# df1
  user_id first_name last_name                  email
0   id001       Rivi     Valti    [correo electrónico protegido]
1   id002     Wynnie   McMurty  [correo electrónico protegido]
2   id003    Kristos   Ivanets  [correo electrónico protegido]
3   id004    Madalyn       Max      [correo electrónico protegido]
4   id005       Tobe   Riddich  [correo electrónico protegido]
5   id006      Regan    Huyghe    [correo electrónico protegido]
6   id007    Kristin     Illis    [correo electrónico protegido]

#df2
  user_id                         image_url
0   id001  http://example.com/img/id001.png
1   id002  http://example.com/img/id002.jpg
2   id003  http://example.com/img/id003.bmp
3   id004  http://example.com/img/id004.jpg
4   id005  http://example.com/img/id005.png

Combinemos estos DataFrames con la función merge(). Primero, eche un vistazo a todas las opciones que esta función puede aceptar de un vistazo:

1
2
3
4
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
         left_index=False, right_index=False, sort=True,
         suffixes=('_x', '_y'), copy=True, indicator=False,
         validate=None)

La mayoría de estas opciones tienen un valor predeterminado, excepto izquierda y derecha. Estos dos parámetros son los nombres de los DataFrames que fusionaremos. La función en sí devolverá un nuevo DataFrame, que almacenaremos en la variable df3_merged.

Ingrese el siguiente código en su shell de Python:

1
df3_merged = pd.merge(df1, df2)

Dado que nuestros dos DataFrames tienen la columna user_id con el mismo nombre, la función merge() une automáticamente dos tablas que coinciden con esa clave. Si tuviéramos dos columnas con nombres diferentes, podríamos usar left_on='left_column_name' y right_on='right_column_name' para especificar claves en ambos DataFrames explícitamente.

Imprimamos la variable df3_merged para ver su contenido:

1
2
3
4
5
6
  user_id first_name last_name                  email                         image_url
0   id001       Rivi     Valti    [correo electrónico protegido]  http://example.com/img/id001.png
1   id002     Wynnie   McMurty  [correo electrónico protegido]  http://example.com/img/id002.jpg
2   id003    Kristos   Ivanets  [correo electrónico protegido]  http://example.com/img/id003.bmp
3   id004    Madalyn       Max      [correo electrónico protegido]  http://example.com/img/id004.jpg
4   id005       Tobe   Riddich  [correo electrónico protegido]  http://example.com/img/id005.png

Notarás que df3_merged tiene solo 5 filas mientras que el df1 original tenía 7. ¿Por qué?

Cuando el valor predeterminado del parámetro how se establece en inner, se genera un nuevo DataFrame a partir de la intersección de los DataFrames izquierdo y derecho. Por lo tanto, si falta un user_id en una de las tablas, no estará en el DataFrame fusionado.

Esto se mantendría cierto incluso si se intercambiaran los lugares de las filas izquierda y derecha:

1
df3_merged = pd.merge(df2, df1)

Los resultados siguen siendo:

1
2
3
4
5
6
  user_id                         image_url first_name last_name                  email
0   id001  http://example.com/img/id001.png       Rivi     Valti    [correo electrónico protegido]
1   id002  http://example.com/img/id002.jpg     Wynnie   McMurty  [correo electrónico protegido]
2   id003  http://example.com/img/id003.bmp    Kristos   Ivanets  [correo electrónico protegido]
3   id004  http://example.com/img/id004.jpg    Madalyn       Max      [correo electrónico protegido]
4   id005  http://example.com/img/id005.png       Tobe   Riddich  [correo electrónico protegido]

Los usuarios con ID 'id006' y 'id007' no forman parte de los DataFrames fusionados ya que no se cruzan en ambas tablas.

Sin embargo, hay ocasiones en las que queremos usar uno de los DataFrames como el DataFrame principal e incluir todas las filas incluso si no se cruzan entre sí. Es decir, tener todos nuestros usuarios, mientras que image_url es opcional.

¿Cómo? Usando merge(), podemos pasar el argumento 'left' al parámetro how:

1
2
3
df_left_merge = pd.merge(df1, df2, how='left')

print(df_left_merge)

Con una unión izquierda, hemos incluido todos los elementos del DataFrame izquierdo (df1) y todos los elementos del DataFrame derecho (df2). Ejecutar el código anterior mostraría esto:

1
2
3
4
5
6
7
8
  user_id first_name last_name                  email                         image_url
0   id001       Rivi     Valti    [correo electrónico protegido]  http://example.com/img/id001.png
1   id002     Wynnie   McMurty  [correo electrónico protegido]  http://example.com/img/id002.jpg
2   id003    Kristos   Ivanets  [correo electrónico protegido]  http://example.com/img/id003.bmp
3   id004    Madalyn       Max      [correo electrónico protegido]  http://example.com/img/id004.jpg
4   id005       Tobe   Riddich  [correo electrónico protegido]  http://example.com/img/id005.png
5   id006      Regan    Huyghe    [correo electrónico protegido]                               NaN
6   id007    Kristin     Illis    [correo electrónico protegido]                               NaN

Las celdas que no tienen ningún valor coincidente con el DataFrame izquierdo se rellenan con NaN.

¿Por qué no intentamos unirnos a la derecha? Cree el siguiente DataFrame combinado:

1
2
3
df_right_merge = pd.merge(df1, df2, how='right')

print(df_right_merge)

Como habrás esperado, la combinación derecha devolvería todos los valores del DataFrame izquierdo que coincidan con el DataFrame derecho:

1
2
3
4
5
6
  user_id first_name last_name                  email                         image_url
0   id001       Rivi     Valti    [correo electrónico protegido]  http://example.com/img/id001.png
1   id002     Wynnie   McMurty  [correo electrónico protegido]  http://example.com/img/id002.jpg
2   id003    Kristos   Ivanets  [correo electrónico protegido]  http://example.com/img/id003.bmp
3   id004    Madalyn       Max      [correo electrónico protegido]  http://example.com/img/id004.jpg
4   id005       Tobe   Riddich  [correo electrónico protegido]  http://example.com/img/id005.png

Como cada fila en df2 tiene un valor en df1, esta unión derecha es similar a la unión interior, en este caso.

Echemos un vistazo a las uniones externas. Para ilustrar mejor cómo funcionan, intercambiemos los lugares de nuestros DataFrames y creemos 2 nuevas variables para las uniones izquierda y externa:

1
2
3
4
5
df_left = pd.merge(df2, df1, how='left', indicator=True)
df_outer = pd.merge(df2, df1, how='outer', indicator=True)

print(df_left)
print(df_outer)

Tenga en cuenta que nuestro DataFrame izquierdo es df2 y el DataFrame derecho es df1. El uso de how='outer' combina DataFrames que coinciden con la clave pero también incluye los valores que faltan o no coinciden.

También agregamos el indicador indicator y lo configuramos en True para que Pandas agregue una columna adicional _merge al final de nuestro DataFrame. Esta columna nos dice si se encontró una fila en el DataFrames izquierdo, derecho o ambos.

La variable df_left se ve así:

1
2
3
4
5
6
  user_id                         image_url first_name last_name                  email _merge
0   id001  http://example.com/img/id001.png       Rivi     Valti    [correo electrónico protegido]   both
1   id002  http://example.com/img/id002.jpg     Wynnie   McMurty  [correo electrónico protegido]   both
2   id003  http://example.com/img/id003.bmp    Kristos   Ivanets  [correo electrónico protegido]   both
3   id004  http://example.com/img/id004.jpg    Madalyn       Max      [correo electrónico protegido]   both
4   id005  http://example.com/img/id005.png       Tobe   Riddich  [correo electrónico protegido]   both

Sin embargo, df_outer tiene estos datos:

1
2
3
4
5
6
7
8
  user_id                         image_url first_name last_name                  email      _merge
0   id001  http://example.com/img/id001.png       Rivi     Valti    [correo electrónico protegido]        both
1   id002  http://example.com/img/id002.jpg     Wynnie   McMurty  [correo electrónico protegido]        both
2   id003  http://example.com/img/id003.bmp    Kristos   Ivanets  [correo electrónico protegido]        both
3   id004  http://example.com/img/id004.jpg    Madalyn       Max      [correo electrónico protegido]        both
4   id005  http://example.com/img/id005.png       Tobe   Riddich  [correo electrónico protegido]        both
5   id006                               NaN      Regan    Huyghe    [correo electrónico protegido]  right_only
6   id007                               NaN    Kristin     Illis    [correo electrónico protegido]  right_only

Tenga en cuenta que en el DataFrame df_outer id006 e id007 solo existen en el DataFrame derecho (en este caso es df1). Si intentáramos comparar las uniones izquierda y externa sin intercambiar los lugares, terminaríamos con los mismos resultados para ambas.

Fusionar marcos de datos usando join()

A diferencia de merge(), que es un método de la instancia de Pandas, join() es un método del propio DataFrame. Esto significa que podemos usarlo como un método estático en el DataFrame: DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False).

El DataFrame al que llamamos join() será nuestro DataFrame izquierdo. El DataFrame en el argumento otro sería nuestro DataFrame correcto.

El parámetro on puede tomar uno o más argumentos (['key1', 'key2' ...]) para definir la clave coincidente, mientras que el parámetro how toma uno de los argumentos handle (left, right, outside , interior), y está configurado en izquierda de forma predeterminada.

Intentemos unir df2 a df1:

1
2
3
df_join = df1.join(df2, rsuffix='_right')

print(df_join)

Al igual que la función merge(), la función join() automáticamente intenta hacer coincidir las claves (columnas) con el mismo nombre. En nuestro caso, es la clave user_id.

El código anterior imprime esto:

1
2
3
4
5
6
7
8
  user_id first_name last_name                  email user_id_right                         image_url
0   id001       Rivi     Valti    [correo electrónico protegido]         id001  http://example.com/img/id001.png
1   id002     Wynnie   McMurty  [correo electrónico protegido]         id002  http://example.com/img/id002.jpg
2   id003    Kristos   Ivanets  [correo electrónico protegido]         id003  http://example.com/img/id003.bmp
3   id004    Madalyn       Max      [correo electrónico protegido]         id004  http://example.com/img/id004.jpg
4   id005       Tobe   Riddich  [correo electrónico protegido]         id005  http://example.com/img/id005.png
5   id006      Regan    Huyghe    [correo electrónico protegido]           NaN                               NaN
6   id007    Kristin     Illis    [correo electrónico protegido]           NaN                               NaN

Probablemente notó una "columna duplicada" llamada user_id_right. Si no desea mostrar esa columna, puede configurar las columnas user_id como un índice en ambas columnas para que se unan sin un sufijo:

1
2
3
df_join_no_duplicates = df1.set_index('user_id').join(df2.set_index('user_id'))

print(df_join_no_duplicates)

Al hacerlo, nos deshacemos de la columna user_id y la configuramos como la columna de índice en su lugar. Esto nos proporciona un DataFrame resultante más limpio:

1
2
3
4
5
6
7
8
9
        first_name last_name                  email                         image_url
user_id                                                                              
id001         Rivi     Valti    [correo electrónico protegido]  http://example.com/img/id001.png
id002       Wynnie   McMurty  [correo electrónico protegido]  http://example.com/img/id002.jpg
id003      Kristos   Ivanets  [correo electrónico protegido]  http://example.com/img/id003.bmp
id004      Madalyn       Max      [correo electrónico protegido]  http://example.com/img/id004.jpg
id005         Tobe   Riddich  [correo electrónico protegido]  http://example.com/img/id005.png
id006        Regan    Huyghe    [correo electrónico protegido]                               NaN
id007      Kristin     Illis    [correo electrónico protegido]                               NaN

Combinar tramas de datos usando append()

Como señala la documentación oficial de Pandas, dado que los métodos concat() y append() devuelven nuevas copias de DataFrames, el uso excesivo de estos métodos puede afectar el rendimiento de su programa.

Append es muy útil cuando desea fusionar dos DataFrames solo en el eje de fila. Esto significa que en lugar de hacer coincidir los datos en sus columnas, queremos un nuevo DataFrame que contenga todas las filas de 2 DataFrames.

Agreguemos df2 a df1 e imprimamos los resultados:

1
2
3
df_append = df1.append(df2, ignore_index=True)

print(df_append)

El uso de append() no coincidirá con DataFrames en ninguna clave. Simplemente agregará el otro DataFrame al primero y devolverá una copia del mismo. Si las formas de los DataFrames no coinciden, Pandas reemplazará las celdas que no coincidan con un NaN.

El resultado para agregar los dos DataFrames se ve así:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
   user_id first_name last_name                  email                         image_url
0    id001       Rivi     Valti    [correo electrónico protegido]                               NaN
1    id002     Wynnie   McMurty  [correo electrónico protegido]                               NaN
2    id003    Kristos   Ivanets  [correo electrónico protegido]                               NaN
3    id004    Madalyn       Max      [correo electrónico protegido]                               NaN
4    id005       Tobe   Riddich  [correo electrónico protegido]                               NaN
5    id006      Regan    Huyghe    [correo electrónico protegido]                               NaN
6    id007    Kristin     Illis    [correo electrónico protegido]                               NaN
7    id001        NaN       NaN                    NaN  http://example.com/img/id001.png
8    id002        NaN       NaN                    NaN  http://example.com/img/id002.jpg
9    id003        NaN       NaN                    NaN  http://example.com/img/id003.bmp
10   id004        NaN       NaN                    NaN  http://example.com/img/id004.jpg
11   id005        NaN       NaN                    NaN  http://example.com/img/id005.png

La mayoría de los usuarios eligen concat() en lugar de append(), ya que también proporciona la opción de coincidencia de clave y eje.

Combinar marcos de datos usando concat()

La concatenación es un poco más flexible en comparación con merge() y join(), ya que nos permite combinar DataFrames ya sea verticalmente (en filas) u horizontalmente (en columnas).

La compensación es que cualquier dato que no coincida será descartado. Aquí está la función completa con los parámetros:

1
2
pandas.concat(objs, axis=0, join='outer', ignore_index=False, keys=None,
              levels=None, names=None, verify_integrity=False, sort=False, copy=True)

Estos son los parámetros más utilizados para la función concat():

  • objs es la lista de objetos DataFrame ([df1, df2, ...]) a concatenar
  • eje define la dirección de la concatenación, 0 para filas y 1 para columnas
  • join puede ser interior (intersección) o outer (unión)
  • ignore_index se establece de forma predeterminada en False, lo que permite que los valores de índice permanezcan como estaban en los DataFrames originales, lo que puede causar valores de índice duplicados. Si se establece en Verdadero, ignorará los valores originales y reasignará los valores de índice en orden secuencial
  • keys nos permite construir un índice jerárquico. Piense en ello como otro nivel del índice que se adjunta en la parte exterior izquierda del DataFrame que nos ayuda a distinguir los índices cuando los valores no son únicos.

Vamos a crear un nuevo DataFrame con los mismos tipos de columna con df2, pero este incluye image_url para id006 e id007:

1
2
3
4
df2_addition = pd.DataFrame({'user_id': ['id006', 'id007'],
                             'image_url': ['http://example.com/img/id006.png',
                                           'http://example.com/img/id007.jpg']
                             })

Para unir df2 y df2_addition por filas, podemos pasarlos en una lista como el parámetro objs y asignar el DataFrame resultante a una nueva variable:

1
2
3
df_row_concat = pd.concat([df2, df2_addition])

print(df_row_concat)

Completamos con éxito los valores faltantes:

1
2
3
4
5
6
7
8
  user_id                         image_url
0   id001  http://example.com/img/id001.png
1   id002  http://example.com/img/id002.jpg
2   id003  http://example.com/img/id003.bmp
3   id004  http://example.com/img/id004.jpg
4   id005  http://example.com/img/id005.png
0   id006  http://example.com/img/id006.png
1   id007  http://example.com/img/id007.jpg

Sin embargo, eche un vistazo a los índices en la columna más a la izquierda. Los índices 0 y 1 se repiten. Para obtener valores de índice completamente nuevos y únicos, pasamos True al parámetro ignore_index:

1
df_row_concat = pd.concat([df2, df2_addition], ignore_index=True)

Ahora nuestro df_row_concat tiene valores de índice únicos:

1
2
3
4
5
6
7
8
  user_id                         image_url
0   id001  http://example.com/img/id001.png
1   id002  http://example.com/img/id002.jpg
2   id003  http://example.com/img/id003.bmp
3   id004  http://example.com/img/id004.jpg
4   id005  http://example.com/img/id005.png
5   id006  http://example.com/img/id006.png
6   id007  http://example.com/img/id007.jpg

Como mencionamos anteriormente, la concatenación puede funcionar tanto horizontal como verticalmente. Para unir dos DataFrames en forma de columna, necesitaremos cambiar el valor del eje del predeterminado 0 a 1:

1
2
3
df_column_concat = pd.concat([df1, df_row_concat], axis=1)

print(df_column_concat)

Notarás que no funciona como fusionar, haciendo coincidir dos tablas en una clave:

1
2
3
4
5
6
7
8
  user_id first_name last_name                  email user_id                         image_url
0   id001       Rivi     Valti    [correo electrónico protegido]   id001  http://example.com/img/id001.png
1   id002     Wynnie   McMurty  [correo electrónico protegido]   id002  http://example.com/img/id002.jpg
2   id003    Kristos   Ivanets  [correo electrónico protegido]   id003  http://example.com/img/id003.bmp
3   id004    Madalyn       Max      [correo electrónico protegido]   id004  http://example.com/img/id004.jpg
4   id005       Tobe   Riddich  [correo electrónico protegido]   id005  http://example.com/img/id005.png
5   id006      Regan    Huyghe    [correo electrónico protegido]   id006  http://example.com/img/id006.png
6   id007    Kristin     Illis    [correo electrónico protegido]   id007  http://example.com/img/id007.jpg

Si nuestro DataFrame derecho ni siquiera tuviera una columna user_id, esta concatenación aún devolvería el mismo resultado. La función concat() pega dos DataFrames juntos, teniendo en cuenta los valores de los índices de DataFrames y la forma de la tabla

No hace coincidencias de claves como merge() o join(). Pruebe diferentes combinaciones de concatenación cambiando el parámetro join para ver las diferencias.

Combinar marcos de datos usando combine_first() y update()

En algunos casos, es posible que desee completar los datos que faltan en su DataFrame fusionándolos con otro DataFrame. Al hacerlo, mantendrá todos los valores no perdidos en el primer DataFrame mientras reemplaza todos los valores NaN con valores no perdidos disponibles del segundo DataFrame (si hay alguno).

Para este ejemplo, importaremos NumPy para usar valores NaN. Si instaló Pandas con pip, NumPy ya debería estar instalado.

Escriba el siguiente código en su shell de Python o archivo de secuencia de comandos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import numpy as np

df_first = pd.DataFrame({'COL 1': ['X', 'X', np.nan],
                         'COL 2': ['X', np.nan, 'X'],
                         'COL 3': [np.nan, 'X', 'X']},
                        index=range(0, 3))

df_second = pd.DataFrame({'COL 1': [np.nan, 'O', 'O'],
                          'COL 2': ['O', 'O', 'O']},
                         index=range(0, 3))

print(df_first)
print(df_second)

El DataFrame df_first tiene 3 columnas y 1 valor faltante en cada una de ellas:

1
2
3
4
  COL 1 COL 2 COL 3
0     X     X   NaN
1     X   NaN     X
2   NaN     X     X

Mientras que df_second tiene solo 2 columnas y un valor faltante en la primera columna:

1
2
3
4
  COL 1 COL 2
0   NaN     O
1     O     O
2     O     O

Podemos usar df_second para parchar los valores que faltan en df_first con todos los valores correspondientes:

1
2
3
df_tictactoe = df_first.combine_first(df_second)

print(df_tictactoe)

Como se mencionó anteriormente, usar el método combine_first() solo reemplazará los valores NaN en el orden del índice, y dejará todos los valores que no falten en el primer DataFrame tal como están:

1
2
3
4
  COL 1 COL 2 COL 3
0     X     X   NaN
1     X     O     X
2     O     X     X

Por otro lado, si quisiéramos sobrescribir los valores en df_first con los valores correspondientes de df_second (sin importar si son NaN o no), usaríamos el método update().

Primero agreguemos otro DataFrame a nuestro código:

1
2
3
df_third = pd.DataFrame({'COL 1': ['O'], 'COL 2': ['O'], 'COL 3': ['O']})

print(df_third)

La forma es (1, 3) - 1 fila y tres columnas, excluyendo el índice:

1
2
  COL 1 COL 2 COL 3
0     O     O     O

Ahora actualicemos df_first con los valores de df_third:

1
2
3
df_first.update(df_third)

print(df_first)

Tenga en cuenta que, a diferencia de combine_first(), update() no devuelve un nuevo DataFrame. Modifica df_first en el lugar, alterando los valores correspondientes:

1
2
3
4
  COL 1 COL 2 COL 3
0     O     O     O
1     X   NaN     X
2   NaN     X     X

El parámetro overwrite de la función update() se establece en True de forma predeterminada. Es por eso que cambia todos los valores correspondientes, en lugar de solo los valores NaN. Podemos cambiarlo a False para reemplazar solo los valores NaN:

1
2
3
df_tictactoe.update(df_first, overwrite=False)

print(df_tictactoe)

Aquí está el estado final de nuestro DataFrame df_tictactoe:

1
2
3
4
  COL 1 COL 2 COL 3
0     X     X     O
1     X     O     X
2     O     X     X

¡No solo actualizamos con éxito los valores, sino que también ganamos el juego Tic-Tac-Toe!

Conclusión

Pandas proporciona herramientas poderosas para fusionar DataFrames. Pero puede ser difícil decidir cuándo usar qué. Si bien la mayoría de las veces la función merge() es suficiente, en algunos casos es posible que desee usar concat() para fusionar filas, o usar join() con sufijos, o deshacerse de los valores faltantes con combinar_primero() y actualizar(). Incluso puedes agregar filas de datos con append().

Utilice la función con la que se sienta más cómodo y que sea mejor para la tarea en cuestión. ¿Cómo te ayudarían estas funciones a manipular datos en Pandas? andas?