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

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 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 devem ser combinados, mas também defina qual tipo de combinaçã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 DataFrames e retorna apenas as linhas nas quais existem chaves correspondentes em ambos. Para compreender esse processo, vamos criar dois DataFrames:

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:

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 DataFrames originais.

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.

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

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

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:

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:

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

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:

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:

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 DataFrames:

Valor1  Valor2
B        2        4
C        3        5