0Pricing
Pandas & NumPy Academy · Aula

Fazendo junções pelo índice

Use DataFrame.join() e defina left_index/right_index=True em merge() para combinar DataFrames alinhados pelo índice.

Fazendo junções pelo índice é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 4 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.

Joins baseados em índice

Até agora, você mesclou DataFrames comparando valores em colunas comuns. Porém, às vezes, a informação que você deseja usar na comparação é armazenada no índice do DataFrame, e não em uma coluna. O Pandas oferece suporte a joins baseados em índice por meio de DataFrame.join() e de pd.merge() com os parâmetros left_index=True ou right_index=True.

Método DataFrame.join()

DataFrame.join(other) é um método auxiliar que, por padrão, faz o join usando o índice de ambos os DataFrames. Ele equivale a uma chamada de pd.merge() com left_index=True, right_index=True. O tipo de join padrão é 'left', diferentemente de pd.merge(), cujo padrão é 'inner'. Ambos os DataFrames precisam compartilhar rótulos de índice significativos para que o join produza resultados corretos.

import pandas as pd

profiles = pd.DataFrame(
    {'age': [25, 30, 22]},
    index=['alice', 'bob', 'carol']
)

scores = pd.DataFrame(
    {'score': [88, 95, 70]},
    index=['alice', 'carol', 'dave']
)

# join: left join on index (default)
result = profiles.join(scores)
print(result)
#        age  score
# alice   25   88.0
# bob     30    NaN   <- bob has no score
# carol   22   95.0

Controlando o tipo de join em join()

Passe o parâmetro how para join() para controlar quais linhas serão preservadas, assim como em pd.merge(). As opções são 'left' (padrão), 'right', 'inner' e 'outer'. Por exemplo, how='inner' mantém apenas os índices que aparecem em ambos os DataFrames, removendo a linha de alice caso ela não tenha um índice correspondente na tabela da direita.

# Inner join on index: only rows present in BOTH indices
print(profiles.join(scores, how='inner'))
#        age  score
# alice   25     88
# carol   22     70

# Outer join: all indices from both
print(profiles.join(scores, how='outer'))
#        age  score
# alice  25.0   88.0
# bob    30.0    NaN
# carol  22.0   70.0
# dave    NaN   95.0

Unindo vários DataFrames de uma só vez

Uma grande vantagem de join() em relação a pd.merge() é que ele aceita uma lista de DataFrames, unindo todos eles ao DataFrame que faz a chamada em uma única operação. Todos os DataFrames devem estar alinhados pelos índices. Isso é muito conveniente quando você tem várias tabelas de atributos indexadas pela mesma chave, como o ID do usuário ou a data, e quer reuni-las em um único DataFrame amplo.

emails = pd.DataFrame({'email': ['a@x.com', 'b@x.com', 'c@x.com']},
                      index=['alice', 'bob', 'carol'])
city  = pd.DataFrame({'city': ['NY', 'LA', 'SF']},
                     index=['alice', 'bob', 'carol'])

# Join multiple DataFrames at once
result = profiles.join([emails, city])
print(result)
#        age    email city
# alice   25  a@x.com   NY
# bob     30  b@x.com   LA
# carol   22  c@x.com   SF

Unindo por uma coluna em uma tabela e pelo índice em outra

pd.merge() permite combinar correspondências baseadas em colunas e em índices com left_on/right_index ou left_index/right_on. Isso é útil quando um DataFrame armazena a chave em uma coluna, mas o outro a utiliza como índice. Não é possível obter esse resultado usando apenas join().

# orders has customer_id as a column; customers is indexed by customer_id
customers_indexed = pd.DataFrame(
    {'name': ['Alice', 'Bob', 'Carol']},
    index=[101, 102, 103]
)
orders = pd.DataFrame({
    'order_id': [1, 2, 3],
    'customer_id': [101, 102, 101]
})

result = pd.merge(orders, customers_indexed,
                  left_on='customer_id', right_index=True)
print(result)
#    order_id  customer_id   name
# 0         1          101  Alice
# 2         3          101  Alice
# 1         2          102    Bob

Usando left_index e right_index em merge()

Quando ambos os DataFrames têm a chave como índice, use pd.merge(left, right, left_index=True, right_index=True). Isso equivale a join(), mas com o tipo de junção padrão 'inner' e parâmetros mais explícitos. Você também passa a ter acesso a todos os outros parâmetros de pd.merge(), como suffixes e indicator.

# Both DataFrames indexed by user_id
demog = pd.DataFrame({'age': [25, 30]}, index=[1, 2])
behav = pd.DataFrame({'clicks': [10, 5]}, index=[1, 2])

# Equivalent joins
result1 = demog.join(behav)  # left join
result2 = pd.merge(demog, behav, left_index=True, right_index=True)  # inner join

print(result1)
print(result2)

Por que usar junções baseadas em índices?

As junções baseadas em índices são preferíveis quando seus DataFrames são naturalmente indexados por um identificador significativo, como o ID de um usuário, o SKU de um produto ou uma data. Usar o índice nas junções evita sobrecarregar o DataFrame com colunas de chave redundantes e pode ser mais rápido, pois o Pandas mantém estruturas de índice ordenadas para buscas O(log n). Elas são especialmente comuns em dados de séries temporais, nos quais o DatetimeIndex é a chave natural da junção.

# Time series example: join temperature and humidity by date index
import numpy as np
dates = pd.date_range('2024-01-01', periods=5)
temp = pd.DataFrame({'temp_c': [10, 12, 9, 11, 13]}, index=dates)
humid = pd.DataFrame({'humidity': [65, 70, 60, 75, 68]}, index=dates)

weather = temp.join(humid)
print(weather.head())

Lidando com nomes de colunas sobrepostos

Quando ambos os DataFrames têm colunas com o mesmo nome (exceto a chave), join() gera um ValueError por padrão, a menos que você forneça os parâmetros lsuffix e rsuffix. Esses parâmetros funcionam como suffixes em pd.merge(), acrescentando uma string aos nomes das colunas sobrepostas dos DataFrames da esquerda e da direita, respectivamente.

df_a = pd.DataFrame({'value': [1, 2]}, index=['x', 'y'])
df_b = pd.DataFrame({'value': [10, 20]}, index=['x', 'y'])

# Without suffixes: raises ValueError
# result = df_a.join(df_b)

# With suffixes: disambiguate column names
result = df_a.join(df_b, lsuffix='_left', rsuffix='_right')
print(result)
#    value_left  value_right
# x           1           10
# y           2           20

set_index antes da junção

Um fluxo de trabalho comum é definir uma coluna como índice antes da junção, para que você possa usar a sintaxe de join(). Depois da junção, reset_index() traz a chave de volta como uma coluna comum. Esse padrão é intuitivo: promover a chave a índice, fazer a junção e rebaixar a chave de volta, deixando clara a intenção para quem ler seu código no futuro.

orders_col = pd.DataFrame({'order_id': [1,2,3], 'customer_id': [10,20,10], 'amount': [100,200,150]})
cust_col = pd.DataFrame({'customer_id': [10,20], 'name': ['Alice','Bob']})

result = (
    orders_col.set_index('customer_id')
    .join(cust_col.set_index('customer_id'), how='left')
    .reset_index()
)
print(result)

Alinhando uma Series ao índice de um DataFrame

Uma Series também tem um índice, e você pode adicioná-la como uma nova coluna a um DataFrame usando uma atribuição — o Pandas alinha automaticamente os valores da Series aos rótulos de índice correspondentes. Essa é uma forma leve de junção baseada em índice, útil quando você quer adicionar uma única coluna de uma Series sem chamar merge() ou join().

df = pd.DataFrame({'sales': [100, 200, 150]}, index=['A', 'B', 'C'])
tax_rate = pd.Series({'A': 0.1, 'B': 0.2, 'C': 0.15})

# Index alignment: Series aligns to DataFrame index automatically
df['tax'] = df['sales'] * tax_rate
print(df)
#    sales   tax
# A    100  10.0
# B    200  40.0
# C    150  22.5

Desempenho de junções por índice

Fazer uma junção usando um índice ordenado é mais rápido do que fazê-la usando uma coluna comum, pois o Pandas utiliza uma busca binária no índice ordenado. Se você fizer várias junções usando a mesma chave, defina essa chave como índice uma única vez, no início do seu fluxo de processamento. Isso é especialmente importante em fluxos de trabalho com séries temporais, nos quais você faz junções por um DatetimeIndex milhares de vezes em muitos arquivos.

# Sort index before repeated joins for speed
left = left.sort_index()
right = right.sort_index()

# Both sorted -> Pandas uses merge path with binary search
result = left.join(right, how='inner')

# Check if index is sorted
print('Left sorted:', left.index.is_monotonic_increasing)
print('Right sorted:', right.index.is_monotonic_increasing)

Verificação rápida

Teste sua compreensão sobre junções baseadas em índices nesta lição.

Recapitulação da lição

Nesta lição, você aprendeu que: DataFrame.join() faz a junção pelo índice por padrão, usando uma junção à esquerda; pd.merge() com left_index=True/right_index=True oferece mais controle; é possível unir vários DataFrames de uma só vez passando uma lista para join(); e usar um índice ordenado melhora o desempenho da junção. A seguir, exploraremos como remodelar DataFrames com pivot_table.

Perguntas Frequentes

A aula “Fazendo junções pelo índice” é grátis?

Sim — o texto completo de “Fazendo junções pelo índice” é 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 “Fazendo junções pelo índice”?

Use DataFrame.join() e defina left_index/right_index=True em merge() para combinar DataFrames alinhados pelo índice. 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 4 de 4.

Quanto tempo leva a aula “Fazendo junções pelo índice”?

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

  1. pd.concat para empilhar DataFrames
  2. pd.merge: junções internas e externas
  3. Junções à esquerda e à direita
  4. Fazendo junções pelo índice
← Voltar para Pandas & NumPy Academy