Pandas merge(): Método para combinar Da­ta­Fra­mes

Com o método Pandas DataFrame.merge(), você pode combinar di­fe­ren­tes Da­ta­Fra­mes. Isso permite mesclar dados de diversas fontes de uma maneira eficiente, pos­si­bi­li­tando análises mais abran­gen­tes.

Sintaxe do Pandas merge()

O método merge() utilizado com os Da­ta­Fra­mes no Python Pandas permite a definição de diversos pa­râ­me­tros, pos­si­bi­li­tando que os de­sen­vol­ve­do­res es­pe­ci­fi­quem como os Da­ta­Fra­mes devem ser com­bi­na­dos. A sintaxe geral de merge() é a seguinte:

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)

Quais pa­râ­me­tros podem ser usados com Pandas merge?

Os diversos pa­râ­me­tros aceitos pelo método merge() pos­si­bi­li­tam que você não só es­pe­ci­fi­que quais Da­ta­Fra­mes do Pandas devem ser com­bi­na­dos, mas também defina qual tipo de com­bi­na­ção (JOIN) usar, além de outros detalhes.

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 Da­ta­Fra­mes e retorna apenas as linhas nas quais existem chaves cor­res­pon­den­tes em ambos. Para com­pre­en­der esse processo, vamos criar dois Da­ta­Fra­mes:

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 Da­ta­Fra­mes terão a seguinte estrutura:

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():

# 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 Da­ta­Fra­mes originais.

Chave    Valor1    Valor2
0     B                     2                     4
1     C                     3                     5

OUTER JOIN

O OUTER JOIN também combina dois Da­ta­Fra­mes, mas di­fe­ren­te­mente do INNER JOIN, retorna todas as linhas e preenche os valores ausentes com NaN.

# OUTER JOIN
result = pd.merge(df1, df2, how='outer', on='Chave')
print(result)

O DataFrame abaixo contém todas as linhas dos dois Da­ta­Fra­mes. O termo NaN foi usado para indicar os valores ausentes na chave A, que estava presente apenas em df1, e na chave D, en­con­trada somente em df2.

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

Usar left_on e right_on

Em alguns casos, dois Da­ta­Fra­mes podem ter colunas com nomes distintos para as chaves. Nessas situações, você pode usar os pa­râ­me­tros left_on e right_on para definir quais colunas deseja usar. Primeiro, vamos criar dois novos Da­ta­Fra­mes:

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 Da­ta­Fra­mes terão a seguinte estrutura:

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 pa­râ­me­tros left_on e right_on para realizar a operação JOIN usando chaves com nomes distintos:

# 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 cor­res­pon­den­tes serão usadas na junção.

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 Da­ta­Fra­mes como chaves ao definir os pa­râ­me­tros left_index e right_index como True. Primeiro, vamos criar dois Da­ta­Fra­mes com índices:

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 Da­ta­Fra­mes terão a seguinte estrutura:

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:

# 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 Da­ta­Fra­mes:

Valor1  Valor2
B        2        4
C        3        5