# Cómo unir DataFrames con Pandas merge() en Python La función Pandas `DataFrame.merge()` se utiliza para unir dos DataFrames basándose en claves (keys) comunes. De este modo, puedes combinar datos de diferentes fuentes de manera eficiente para realizar análisis más completos. ## Sintaxis de la función Pandas `merge()` La función de Pandas `DataFrame.merge()` de la [Biblioteca Python Pandas](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/python-pandas/) acepta una amplia variedad de parámetros que afectan la forma en que se combinan los DataFrames. La sintaxis general de la función `merge()` es la siguiente: ```python DataFrame.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None) ``` Nota La función `merge()` de Pandas es similar a la operación [JOIN](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/sql-joins/) en [bases de datos relacionales](https://www.ionos.com/es-us/digitalguide/hosting/cuestiones-tecnicas/bases-de-datos-relacionales/). Si ya estás familiarizado con lenguajes de bases de datos como [SQL](https://www.ionos.com/es-us/digitalguide/servidores/know-how/que-es-sql/) te resultará más fácil comprender la función Pandas DataFrame-`merge()`. Sin embargo, es importante señalar que el comportamiento difiere en algunos aspectos: si ambas columnas clave contienen valores que se evalúan como *null*, estos también se combinarán. ### Parámetros relevantes Con los diferentes parámetros que acepta la función Pandas `merge()`, no solo especificas los [DataFrames](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/dataframes-de-pandas-python/), que deseas combinar, sino también el tipo de unión (también llamada join en inglés) y otros detalles adicionales.
Parámetro Descripción Valor predeterminado
`left` Primer DataFrame que se va a combinar
`right` Segundo DataFrame que se va a combinar
`how` Tipo de unión que se va a realizar (`inner`, `outer`, `left` o `right`) `inner`
`on` Columna o nivel de índice que se utiliza como clave; debe estar presente en ambos DataFrames
`left_on` Columna o nivel de índice del DataFrame izquierdo que se utiliza como clave
`right_on` Columna o nivel de índice del DataFrame derecho que se utiliza como clave
`left_index` Si es `True`, el índice del DataFrame izquierdo se usa como clave `False`
`right_index` Si es `True`, el índice del DataFrame derecho se usa como clave `False`
`sort` Si es `True`, las claves resultantes del DataFrame se ordenan de forma lexicográfica `False`
`suffixes` Sufijos que se utilizan para hacer únicas las columnas con nombres duplicados `("_x", "_y")`
`copy` Si es `False`, no se hace una copia `True`
## Cómo utilizar Pandas `merge()` Te presentamos una serie de ejemplos que te ayudarán a comprender cómo funciona Pandas `merge()`. ### `INNER JOIN` o unión interna Una [INNER JOIN](https://www.ionos.com/es-us/digitalguide/hosting/cuestiones-tecnicas/inner-join/) o unión interna une dos DataFrames de Pandas y **devuelve solo las filas en las que las claves coinciden en ambos DataFrames**. Primero, crearemos dos DataFrames que nos servirán de ejemplo: ```python import pandas as pd # DataFrames de ejemplo df1 = pd.DataFrame({ 'Clave': ['A', 'B', 'C'], 'Valor1': [1, 2, 3] }) df2 = pd.DataFrame({ 'Clave': ['B', 'C', 'D'], 'Valor2': [4, 5, 6] }) print(df1) print(df2) ``` Los dos DataFrames resultantes tendrían el siguiente aspecto: ```none Clave Valor1 0 A 1 1 B 2 2 C 3 Clave Valor2 0 B 4 1 C 5 2 D 6 ``` Ahora puedes realizar una `INNER JOIN` utilizando la función die `merge()`: ```python # INNER JOIN result = pd.merge(df1, df2, how='inner', on='Clave') print(result) ``` La salida muestra que, en este ejemplo, solo las filas con las claves B y C se incluyen en el DataFrame resultante, ya que estas están presentes en **ambos DataFrames originales**. ```none Clave Valor1 Valor2 0 B 2 4 1 C 3 5 ``` ### `OUTER JOIN` o unión externa Una `OUTER JOIN` o unión externa también une dos DataFrames. A diferencia de la unión interna (`INNER JOIN`), con la unión externa se devuelven todas las filas y los **valores faltantes se rellenan con `NaN`**. ```python # OUTER JOIN result = pd.merge(df1, df2, how='outer', on='Clave') print(result) ``` Como era de esperar, en el DataFrame resultante se incluyen **todas las filas de ambos DataFrames**. Para la clave A, que solo está presente en `df1`, y la clave D, que solo está presente en `df2`, los valores faltantes se rellenan con `NaN`. ```none Clave Valor1 Valor2 0 A 1.0 NaN 1 B 2.0 4.0 2 C 3.0 5.0 3 D NaN 6.0 ``` Nota El resto de variantes de `JOIN` que hemos incluido en la tabla anterior funcionan de forma análoga. ### Uso de `left_on` y `right_on` A veces, los dos DataFrames tienen diferentes nombres de columnas clave. En este caso, puedes usar los parámetros `left_on` y `right_on` para especificar qué columnas se deben utilizar. Para esto, primero debes crear dos nuevos DataFrames: ```python df3 = pd.DataFrame({ 'Clave': ['A', 'B', 'C'], 'Valor1': [1, 2, 3] }) df4 = pd.DataFrame({ 'Clave2': ['B', 'C', 'D'], 'Valor2': [4, 5, 6] }) print(df3) print(df4) ``` Los dos DataFrames resultantes tienen el siguiente aspecto: ```none Clave Valor1 0 A 1 1 B 2 2 C 3 Clave2 Valor2 0 B 4 1 C 5 2 D 6 ``` Para realizar la operación `JOIN` con claves diferentes, se especifican los parámetros `left_on` y `right_on`: ```python # Unir con diferentes nombres de columnas clave result = pd.merge(df3, df4, how='inner', left_on='Clave', right_on='Clave2') print(result) ``` Al utilizar explícitamente `left_on='Clave'` y `right_on='Clave2'`, se usan las columnas clave correspondientes para realizar la unión. ```none Clave Valor1 Clave2 Valor2 0 B 2 B 4 1 C 3 C 5 ``` ### Uso de índices como clave También puedes utilizar los **índices de los DataFrames como clave para la unión** configurando los parámetros `left_index` y `right_index` en `True`. Primero, se crean dos nuevos DataFrames con índices: ```python df5 = pd.DataFrame({ 'Valor1': [1, 2, 3] }, index=['A', 'B', 'C']) df6 = pd.DataFrame({ 'Valor2': [4, 5, 6] }, index=['B', 'C', 'D']) print(df5) print(df6) ``` Con el código anterior, se generan los siguientes DataFrames: ```none Valor1 A 1 B 2 C 3 Valor2 B 4 C 5 D 6 ``` Ahora se puede realizar una operación de unión basada en los índices con Pandas merge(): ```python # Unir con índices result = pd.merge(df5, df6, how='inner', left_index=True, right_index=True) print(result) ``` El resultado, tal y como era de esperar, es una unión o `JOIN` basada en los índices de los DataFrames: ```none Valor1 Valor2 B 2 4 C 3 5 ``` This is a markdown version of: [https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/pandas-dataframe-merge-en-python/](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/pandas-dataframe-merge-en-python/) for AI/LLM consumption.