pd.merge: junções internas e externas
Combine dois DataFrames por uma coluna de chave compartilhada usando junções internas e externas e entenda quais linhas são mantidas ou removidas.
pd.merge: junções internas e externas é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
O que é um join?
Um join combina dois DataFrames comparando linhas com base em uma coluna-chave compartilhada — o mesmo conceito da cláusula JOIN do SQL. O Pandas implementa joins por meio de pd.merge(). Diferentemente de pd.concat(), que simplesmente empilha dados, pd.merge() alinha de forma inteligente as linhas de duas tabelas diferentes com base em valores correspondentes em uma ou mais colunas.
A coluna-chave compartilhada
Para que uma mesclagem funcione, ambos os DataFrames precisam ter pelo menos uma coluna com valores compartilhados — a coluna-chave. Por exemplo, uma tabela orders tem uma coluna customer_id, e uma tabela customers também tem uma coluna customer_id. Mesclar usando customer_id acrescenta os detalhes do cliente a cada linha de pedido. Especifique a chave com o parâmetro on quando ambos os DataFrames compartilharem o mesmo nome de coluna.
import pandas as pd
orders = pd.DataFrame({
'order_id': [1, 2, 3, 4],
'customer_id': [101, 102, 101, 103],
'amount': [250, 80, 320, 150]
})
customers = pd.DataFrame({
'customer_id': [101, 102, 104],
'name': ['Alice', 'Bob', 'Diana']
})Join interno: interseção das duas tabelas
Um join interno (o padrão) mantém apenas as linhas cujo valor da chave existe em ambos os DataFrames. As linhas de qualquer uma das tabelas que não tiverem uma chave correspondente na outra tabela são descartadas silenciosamente. No exemplo dos pedidos, os clientes 103 e 104 não têm correspondência na outra tabela; por isso, suas linhas são excluídas do resultado do join interno.
# Inner join (default): only matching rows from both
result = pd.merge(orders, customers, on='customer_id', how='inner')
print(result)
# order_id customer_id amount name
# 0 1 101 250 Alice
# 1 3 101 320 Alice
# 2 2 102 80 Bob
# Order 4 (customer 103) dropped - no match in customers
# Diana (customer 104) dropped - no match in ordersJoin externo: união das duas tabelas
Um join externo (how='outer') mantém todas as linhas de ambos os DataFrames. Quando uma linha não tem uma chave correspondente na outra tabela, as colunas ausentes são preenchidas com NaN. Isso é útil quando você deseja obter uma visão completa dos dois conjuntos de dados, preservando os registros que não encontraram correspondência.
result = pd.merge(orders, customers, on='customer_id', how='outer')
print(result)
# order_id customer_id amount name
# 0 1.0 101 250.0 Alice
# 1 3.0 101 320.0 Alice
# 2 2.0 102 80.0 Bob
# 3 4.0 103 150.0 NaN <- order with unknown customer
# 4 NaN 104 NaN Diana <- customer with no ordersMesclando colunas com nomes diferentes
Quando a coluna-chave tem um nome diferente em cada DataFrame, use left_on e right_on em vez de on. O Pandas compara as linhas em que left_on no DataFrame esquerdo é igual a right_on no DataFrame direito. Ambas as colunas-chave aparecem no resultado; você pode remover a redundante depois.
products = pd.DataFrame({
'prod_id': [10, 20, 30],
'name': ['Widget', 'Gadget', 'Doohickey']
})
order_lines = pd.DataFrame({
'item_id': [10, 10, 20],
'qty': [3, 1, 5]
})
result = pd.merge(order_lines, products,
left_on='item_id', right_on='prod_id')
print(result.drop(columns='prod_id'))
# item_id qty name
# 0 10 3 Widget
# 1 10 1 Widget
# 2 20 5 GadgetMesclando várias colunas
Para comparar linhas usando uma combinação de colunas (uma chave composta), passe uma lista para on. Isso é comum quando uma única coluna não é suficiente para uma correspondência exclusiva, como ao mesclar usando year e region. Todas as colunas listadas devem corresponder simultaneamente para que uma linha seja incluída no resultado.
targets = pd.DataFrame({
'year': [2023, 2023, 2024],
'region': ['East', 'West', 'East'],
'target': [100, 150, 120]
})
actuals = pd.DataFrame({
'year': [2023, 2024, 2024],
'region': ['East', 'East', 'West'],
'actual': [95, 115, 80]
})
result = pd.merge(targets, actuals, on=['year', 'region'], how='inner')
print(result)
# year region target actual
# 0 2023 East 100 95
# 1 2024 East 120 115Tratando nomes de colunas sobrepostos
Quando ambos os DataFrames têm uma coluna com o mesmo nome (exceto a chave), o Pandas acrescenta sufixos para diferenciá-las. Os padrões são _x (esquerda) e _y (direita). Você pode personalizá-los com o parâmetro suffixes para produzir nomes mais significativos e evitar confusão no resultado.
df_a = pd.DataFrame({'id': [1, 2], 'value': [10, 20]})
df_b = pd.DataFrame({'id': [1, 2], 'value': [100, 200]})
# Default suffixes
print(pd.merge(df_a, df_b, on='id'))
# id value_x value_y
# Custom suffixes
print(pd.merge(df_a, df_b, on='id', suffixes=('_budget', '_actual')))
# id value_budget value_actualVerificando duplicatas inesperadas
Um problema comum em uma mesclagem é a multiplicação inesperada de linhas. Se a coluna-chave tiver valores duplicados nos dois DataFrames, a mesclagem produzirá um produto cartesiano de todas as linhas correspondentes. Sempre verifique a quantidade de linhas após uma mesclagem: se for maior do que o esperado, investigue as duplicatas na coluna-chave com df.duplicated(subset=['key']).sum().
# Both tables have duplicate keys -> cartesian product
left = pd.DataFrame({'id': [1, 1], 'val_l': ['a', 'b']})
right = pd.DataFrame({'id': [1, 1], 'val_r': ['x', 'y']})
result = pd.merge(left, right, on='id')
print(len(result)) # 4 rows! (2x2 cartesian product)
print(result)
# id val_l val_r
# 0 1 a x
# 1 1 a y
# 2 1 b x
# 3 1 b yParâmetro validate para segurança
Passe o parâmetro validate para impor restrições de relacionamento na mesclagem e gerar um erro caso sejam violadas. 'one_to_one' exige chaves exclusivas em ambas as tabelas; 'one_to_many' exige chaves exclusivas apenas na tabela esquerda; e 'many_to_one', apenas na tabela direita. Essa é uma excelente prática de programação defensiva, pois identifica problemas de qualidade dos dados antecipadamente.
# Safe merge: validate that customer_id is unique in customers
try:
result = pd.merge(orders, customers,
on='customer_id',
how='inner',
validate='many_to_one')
print('Merge OK, shape:', result.shape)
except Exception as e:
print('Merge error:', e)Verificando a cobertura com indicator
Passe indicator=True para adicionar uma coluna _merge ao resultado, indicando a origem de cada linha: 'left_only', 'right_only' ou 'both'. Isso é útil após um join externo para identificar quais registros encontraram correspondência e quais não encontraram, ajudando você a auditar a qualidade dos dados antes de remover a coluna indicadora.
result = pd.merge(orders, customers, on='customer_id',
how='outer', indicator=True)
print(result['_merge'].value_counts())
# both 3
# left_only 1 <- orders with no customer record
# right_only 1 <- customers with no orders
# Find unmatched orders
print(result[result['_merge'] == 'left_only'])Resumo: interno vs. externo
Para resumir os dois tipos de join: o join interno fornece a interseção — apenas as linhas com chaves correspondentes em ambos os DataFrames. O join externo fornece a união — todas as linhas dos dois DataFrames, com NaN onde não houver correspondência. Para completar: o join à esquerda preserva todas as linhas do DataFrame esquerdo, e o join à direita preserva todas as linhas do DataFrame direito. Esses tipos serão abordados na próxima lição.
# Quick reference
# how='inner' -> intersection: only matched rows
# how='outer' -> union: all rows from both, NaN for no match
# how='left' -> all left rows + matched right rows
# how='right' -> all right rows + matched left rows
# Most common: inner (default) for enrichment, left for preserving recordsVerificação rápida
Teste sua compreensão dos joins interno e externo de pd.merge nesta lição.
Recapitulação da lição
Nesta lição, você aprendeu: pd.merge() com how='inner' mantém apenas as linhas correspondentes de ambos os DataFrames, enquanto how='outer' mantém todas as linhas, usando NaN para as que não têm correspondência; on especifica a chave compartilhada, enquanto left_on/right_on tratam nomes de colunas diferentes; e o parâmetro indicator ajuda a auditar quais linhas encontraram correspondência. Em seguida, exploraremos os joins à esquerda e à direita para preservar todas as linhas de um dos lados.
Aprenda Python com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “pd.merge: junções internas e externas” é grátis?
Sim — o texto completo de “pd.merge: junções internas e externas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
O que vou aprender em “pd.merge: junções internas e externas”?
Combine dois DataFrames por uma coluna de chave compartilhada usando junções internas e externas e entenda quais linhas são mantidas ou removidas. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Pandas & NumPy Academy?
Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “pd.merge: junções internas e externas”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Pandas & NumPy Academy?
Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- pd.concat para empilhar DataFrames
- pd.merge: junções internas e externas
- Junções à esquerda e à direita
- Fazendo junções pelo índice