# Pandas merge(): Método para combinar DataFrames Com o método Pandas `DataFrame.merge()`, você pode combinar diferentes DataFrames. Isso permite mesclar dados de diversas fontes de uma maneira eficiente, possibilitando análises mais abrangentes. ## Sintaxe do Pandas `merge()` O método `merge()` utilizado com os DataFrames no [Python Pandas](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-pandas/) permite a definição de diversos parâmetros, possibilitando que os desenvolvedores especifiquem como os DataFrames devem ser combinados. A sintaxe geral de `merge()` é a seguinte: ```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 O método Pandas `merge()` é semelhante à [operação JOIN no SQL](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/sql-join/). Se você tem experiência com bancos de dados relacionais, como [SQL](https://www.ionos.com/pt-br/digitalguide/servidor/conhecimento/o-que-e-sql/), entenderá mais facilmente o funcionamento do método Pandas `merge()`. No entanto, é importante notar que existem algumas diferenças entre essas duas abordagens. Por exemplo, no Pandas, se ambas as colunas tiverem valores avaliados como *null* (nulo), eles também serão mesclados. ### Quais parâmetros podem ser usados com Pandas `merge`? Os diversos parâmetros aceitos pelo método `merge()` possibilitam que você não só especifique quais [DataFrames do Pandas](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/pandas-dataframe-em-python/) devem ser combinados, mas também defina qual tipo de combinação (*JOIN*) usar, além de outros detalhes.
Parâmetro Descrição Valor padrão
`left` O primeiro DataFrame que será combinado
`right` O segundo DataFrame que será combinado
`how` O tipo de operação de combinação que será realizado (`inner`, `outer`, `left`, `right`) `inner`
`on` As colunas ou níveis de índices usados como chave. Devem estar presentes nos dois DataFrames
`left_on` As colunas ou níveis de índices do primeiro DataFrame (à esquerda) que devem ser usados como chaves
`right_on` As colunas ou níveis de índices do segundo DataFrame (à direita) que devem ser usados como chaves
`left_index` Se `True`, o índice do primeiro DataFrame (à esquerda) deve ser usado como chave `False`
`right_index` Se `True`, o índice do segundo DataFrame (à direita) deve ser usado como chave `False`
`sort` Se `True`, as chaves resultantes do DataFrame são organizadas de forma lexicográfica `False`
`suffixes` Sufixos usados para distinguir colunas com o mesmo nome em ambos os DataFrames `("_x", "_y")`
`copy` Se `False`, uma cópia é evitada `True`
## Como usar o Pandas `merge()` A seguir, veremos alguns exemplos que ajudarão a ilustrar como usar o método Pandas `merge()` de forma eficaz. ### `INNER JOIN` O INNER JOIN combina dois DataFrames e **retorna apenas as linhas nas quais existem chaves correspondentes em ambos**. Para compreender esse processo, vamos criar dois DataFrames: ```python import pandas as pd # Exemplos de DataFrames df1 = pd.DataFrame({ 'Chave': ['A', 'B', 'C'], 'Valor1': [1, 2, 3] }) df2 = pd.DataFrame({ 'Chave': ['B', 'C', 'D'], 'Valor2': [4, 5, 6] }) print(df1) print(df2) ``` Os dois DataFrames terão a seguinte estrutura: ```none Chave Valor1 0 A 1 1 B 2 2 C 3 Chave Valor2 0 B 4 1 C 5 2 D 6 ``` Agora, aplicamos o `INNER JOIN` usando a o método Pandas `merge()`: ```python # INNER JOIN result = pd.merge(df1, df2, how='inner', on='Chave') print(result) ``` O resultado mostra que apenas as linhas que contêm as chaves B e C foram incluídas no DataFrame. Isso ocorre porque essas duas chaves estão presentes nos **dois DataFrames originais**. ```none Chave Valor1 Valor2 0 B 2 4 1 C 3 5 ``` ### `OUTER JOIN` O OUTER JOIN também combina dois DataFrames, mas diferentemente do `INNER JOIN`, retorna **todas as linhas** e preenche os **valores ausentes com `NaN`**. ```python # OUTER JOIN result = pd.merge(df1, df2, how='outer', on='Chave') print(result) ``` O DataFrame abaixo contém **todas as linhas dos dois DataFrames**. O termo `NaN` foi usado para indicar os valores ausentes na chave A, que estava presente apenas em `df1`, e na chave D, encontrada somente em `df2`. ```none Chave 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 As outras variantes padrão de `JOIN` funcionam de forma similar. ### Usar `left_on` e `right_on` Em alguns casos, dois DataFrames podem ter colunas com nomes distintos para as chaves. Nessas situações, você pode usar os parâmetros `left_on` e `right_on` para definir quais colunas deseja usar. Primeiro, vamos criar dois novos DataFrames: ```python df3 = pd.DataFrame({ 'Chave': ['A', 'B', 'C'], 'Valor1': [1, 2, 3] }) df4 = pd.DataFrame({ 'Chave2': ['B', 'C', 'D'], 'Valor2': [4, 5, 6] }) print(df3) print(df4) ``` Os dois DataFrames terão a seguinte estrutura: ```none Chave Valor1 0 A 1 1 B 2 2 C 3 Chave2 Valor2 0 B 4 1 C 5 2 D 6 ``` Podemos utilizar os parâmetros `left_on` e `right_on` para realizar a operação `JOIN` usando chaves com nomes distintos: ```python # JOIN com nomes de colunas diferentes result = pd.merge(df3, df4, how='inner', left_on='Chave', right_on='Chave2') print(result) ``` Ao usar `left_on='Chave'` e `right_on='Chave2'`, as colunas correspondentes serão usadas na junção. ```none Chave Valor1 Chave2 Valor2 0 B 2 B 4 1 C 3 C 5 ``` ### Usar índices como chaves Você também pode usar os **índices dos DataFrames como chaves** ao definir os parâmetros `left_index` e `right_index` como `True`. Primeiro, vamos criar dois DataFrames com í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) ``` Os DataFrames terão a seguinte estrutura: ```none Valor1 A 1 B 2 C 3 Valor2 B 4 C 5 D 6 ``` Agora, podemos executar uma operação `JOIN` usando os índices como chaves: ```python # JOIN com índices result = pd.merge(df5, df6, how='inner', left_index=True, right_index=True) print(result) ``` O resultado será um `JOIN` baseado nos índices dos DataFrames: ```none Valor1 Valor2 B 2 4 C 3 5 ``` This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-pandas-dataframe-merge/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-pandas-dataframe-merge/) for AI/LLM consumption.