0Pricing
Pandas & NumPy Academy · Aula

Alinhamento e reindexação de índices

Alinhe dois DataFrames a um índice comum com reindex(), preencha rótulos ausentes e entenda como as operações aritméticas alinham os índices.

Alinhamento e reindexação de índices é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 3 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.

Como o Pandas alinha índices

Um dos comportamentos mais poderosos — e às vezes surpreendentes — do Pandas é o alinhamento automático de índices. Quando você soma, subtrai ou combina de outra forma duas Series ou dois DataFrames, o Pandas primeiro os alinha pelos rótulos dos índices antes de realizar a operação. As operações são feitas sobre os rótulos correspondentes; rótulos sem correspondência produzem NaN. Isso evita erros silenciosos causados por dados desalinhados e permite combinar com segurança dados de fontes diferentes sem precisar ordená-los ou reorganizá-los manualmente antes.

import pandas as pd

s1 = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
s2 = pd.Series([1, 2, 3], index=['b', 'c', 'd'])

# Alignment in action: a→NaN, d→NaN
result = s1 + s2
print('s1 + s2 with automatic alignment:')
print(result)

NaN causado por índices desalinhados

Quando os rótulos dos índices não correspondem, o Pandas preenche as entradas ausentes com NaN. Isso é intencional: sinaliza que “não havia um valor correspondente em um dos operandos”. Sempre examine o resultado da aritmética entre duas Series ou dois DataFrames para detectar valores NaN inesperados — eles indicam que os índices estão desalinhados. Use fill_value=0 no método aritmético (s1.add(s2, fill_value=0)) para tratar valores alinhados ausentes como zero, em vez de propagar NaN.

import pandas as pd

s1 = pd.Series({'a': 10, 'b': 20, 'c': 30})
s2 = pd.Series({'b': 1, 'c': 2, 'd': 3})

# Default: NaN where labels don't match
print('Default (NaN for unmatched):')
print(s1 + s2)

# fill_value=0: treat missing as zero
print('\nWith fill_value=0:')
print(s1.add(s2, fill_value=0))

Alinhamento aritmético de DataFrames

O alinhamento se aplica tanto às linhas quanto às colunas ao combinar dois DataFrames. O resultado tem a união dos dois conjuntos de índices e dos dois conjuntos de colunas, com NaN onde qualquer um dos DataFrames não tinha um valor. Isso equivale a uma junção externa completa em índices e colunas simultaneamente. Assim, você pode somar com segurança DataFrames de períodos fiscais diferentes — os meses existentes em um, mas não no outro, recebem NaN, que você pode então preencher ou remover.

import pandas as pd

df1 = pd.DataFrame({'revenue': [100, 200], 'cost': [80, 150]}, index=['Jan', 'Feb'])
df2 = pd.DataFrame({'revenue': [120, 210], 'headcount': [5, 6]}, index=['Feb', 'Mar'])

result = df1 + df2
print('Combined DataFrame (union of index and columns):')
print(result)

O método reindex()

df.reindex(new_index) retorna um novo DataFrame adaptado à lista de rótulos new_index. Os rótulos existentes tanto no índice original quanto no novo são preservados; os rótulos presentes em new_index, mas ausentes no original, recebem NaN; os rótulos presentes no original, mas ausentes em new_index, são removidos. Essa é a maneira explícita de alinhar um DataFrame a um conjunto de rótulos de destino antes de realizar operações.

import pandas as pd

s = pd.Series({'a': 10, 'b': 20, 'c': 30})

# Reindex to a new label set
reindexed = s.reindex(['b', 'c', 'd', 'e'])
print('Original:', s.index.tolist())
print('New index: [b, c, d, e]')
print('\nReindexed Series:')
print(reindexed)
# b, c preserved; d, e → NaN; a dropped

Preenchendo valores ausentes após a reindexação

reindex() aceita um parâmetro fill_value para substituir novos rótulos por uma constante e um parâmetro method para preenchimento para frente ('ffill') ou para trás ('bfill'). Esses métodos de preenchimento são mais úteis para dados de séries temporais, quando você reindexa uma Series para um intervalo completo de datas e quer preencher os dias ausentes com o último valor conhecido, em vez de NaN.

import pandas as pd

# Sparse daily data with gaps
s = pd.Series(
    [10, 20, 30],
    index=pd.to_datetime(['2024-01-01', '2024-01-03', '2024-01-07'])
)

# Reindex to complete date range
full_range = pd.date_range('2024-01-01', '2024-01-07')
print('Forward fill (carry last known value):')
print(s.reindex(full_range, method='ffill'))

print('\nFill with 0:')
print(s.reindex(full_range, fill_value=0))

Reindexando colunas

reindex também funciona em colunas: df.reindex(columns=['col1', 'col2', 'new_col']). As novas colunas que não existem no DataFrame original são adicionadas com NaN. As colunas existentes que não estão na nova lista são removidas. Isso é útil para impor um esquema canônico de colunas em vários DataFrames provenientes de fontes diferentes e que podem ter conjuntos de colunas inconsistentes.

import pandas as pd

df = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'age': [30, 25],
    'city': ['NY', 'LA']
})

# Enforce a canonical column order and add missing columns
canonical_cols = ['name', 'age', 'email', 'city', 'country']
df_reindexed = df.reindex(columns=canonical_cols)
print(df_reindexed)
# 'email' and 'country' are new → NaN

Usando align() para sincronizar dois objetos

s1.align(s2) retorna dois novos objetos com o mesmo índice (união ou interseção, conforme o parâmetro join), deixando-os prontos para operações elemento a elemento. Isso equivale a reindexar os dois objetos simultaneamente para o mesmo conjunto de rótulos. Use join='inner' para manter apenas os rótulos comuns ou join='outer' (padrão) para manter todos os rótulos de ambos, usando NaN para as incompatibilidades.

import pandas as pd

s1 = pd.Series({'a': 10, 'b': 20, 'c': 30})
s2 = pd.Series({'b': 1, 'c': 2, 'd': 3})

# Align to common labels only (inner join)
s1_aligned, s2_aligned = s1.align(s2, join='inner')
print('Inner-aligned s1:')
print(s1_aligned)
print('Inner-aligned s2:')
print(s2_aligned)

print('\nProduct on common labels:')
print(s1_aligned * s2_aligned)

Alinhamento em merge versus aritmética

O Pandas oferece duas filosofias para combinar DataFrames: merge/join (no estilo SQL, com correspondência explícita de chaves) e aritmética com alinhamento de índices (implícita, baseada em rótulos). Use merge ao combinar tabelas estruturadas com colunas de chaves explícitas. Use o alinhamento aritmético ao realizar cálculos entre DataFrames que naturalmente devem compartilhar um índice — por exemplo, ao subtrair um DataFrame de custos de um DataFrame de receitas, ambos indexados por (região, mês).

import pandas as pd

# Two DataFrames sharing the same index
revenue = pd.Series({'North': 500, 'South': 300, 'East': 450})
costs = pd.Series({'North': 350, 'South': 280, 'West': 400})

# Automatic alignment: 'East' and 'West' don't match → NaN
profit = revenue - costs
print('Profit by region:')
print(profit)

# If you want only common regions
profit_inner = revenue.align(costs, join='inner')[0] - revenue.align(costs, join='inner')[1]
print('\nProfit (common regions only):')
print(profit_inner)

Verificando a igualdade dos índices antes das operações

Antes de realizar operações em dois DataFrames, verifique se os índices correspondem usando (df1.index == df2.index).all(). Se os índices diferirem apenas na ordem, ordene ambos antes de compará-los. Para DataFrames carregados de fontes diferentes, é uma boa prática alinhá-los ou reindexá-los explicitamente antes da aritmética, para evitar a propagação acidental de NaN. Documente quaisquer pressupostos de alinhamento nos comentários ou nos registros do fluxo de trabalho.

import pandas as pd

df1 = pd.DataFrame({'sales': [100, 200, 300]}, index=['Q1', 'Q2', 'Q3'])
df2 = pd.DataFrame({'cost': [80, 160, 240]}, index=['Q1', 'Q2', 'Q3'])

# Check index equality
if (df1.index == df2.index).all():
    print('Indices match — safe to combine.')
    combined = pd.concat([df1, df2], axis=1)
    combined['profit'] = combined['sales'] - combined['cost']
    print(combined)
else:
    print('Indices differ — align before combining!')

Padrão prático: padronizando formatos

Um padrão comum ao carregar dados de vários arquivos ou chamadas de API é que cada lote abranja um subconjunto diferente de chaves. Antes de concatenar ou agregar, reindexe todos os lotes para o espaço completo de chaves conhecido usando fill_value=0. Isso garante que todos os lotes tenham o mesmo formato (o mesmo índice e as mesmas colunas) antes das operações, evitando incompatibilidades silenciosas de formato que causam resultados agregados incorretos.

import pandas as pd

# Two sales batches with different product sets
batch1 = pd.Series({'laptop': 50, 'phone': 80, 'tablet': 30})
batch2 = pd.Series({'phone': 90, 'tablet': 40, 'headphones': 60})

# Full product catalogue
all_products = ['laptop', 'phone', 'tablet', 'headphones']

# Standardise both to the full catalogue
b1 = batch1.reindex(all_products, fill_value=0)
b2 = batch2.reindex(all_products, fill_value=0)

total = b1 + b2
print('Total sales per product:')
print(total)

Casos extremos de alinhamento de índices

Dois casos extremos importantes: Rótulos duplicados — se ambas as Series tiverem rótulos de índice duplicados, o alinhamento produzirá uma expansão semelhante a um produto cartesiano, com muitos valores NaN (o Pandas não presume quais duplicatas correspondem umas às outras). Garanta sempre que os índices sejam exclusivos antes do alinhamento aritmético. Índices inteiros versus índices de objetos — um RangeIndex(0,5) e um Int64Index([0,1,2,3,4]) podem não se alinhar perfeitamente após operações, pois um é inferido e o outro é explícito. Use reset_index(drop=True) para normalizar.

import pandas as pd

# Duplicate label alignment — produces unexpected expansion
s1 = pd.Series([1, 2, 3], index=['a', 'a', 'b'])
s2 = pd.Series([10, 20], index=['a', 'b'])

result = s1 + s2
print('Result with duplicate indices (unexpected expansion):')
print(result)
print('\nAlways ensure unique indices before arithmetic!')

Verificação rápida

Teste sua compreensão sobre alinhamento e reindexação de índices nesta lição.

Recapitulação da lição

Nesta lição, você aprendeu que o Pandas realiza alinhamento automático de índices em operações aritméticas, produzindo NaN para rótulos sem correspondência; reindex() adapta um DataFrame a um conjunto de rótulos de destino, com opções de preenchimento para rótulos ausentes; e align() sincroniza dois objetos para o mesmo índice simultaneamente. A seguir, exploraremos os benefícios de desempenho dos índices ordenados e como medi-los com timeit.

Perguntas Frequentes

A aula “Alinhamento e reindexação de índices” é grátis?

Sim — o texto completo de “Alinhamento e reindexação de índices” é 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 “Alinhamento e reindexação de índices”?

Alinhe dois DataFrames a um índice comum com reindex(), preencha rótulos ausentes e entenda como as operações aritméticas alinham os índices. 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 3 de 4.

Quanto tempo leva a aula “Alinhamento e reindexação de índices”?

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. Criando um MultiIndex
  2. Selecionando dados de um MultiIndex
  3. Alinhamento e reindexação de índices
  4. Benefícios de desempenho de índices ordenados
← Voltar para Pandas & NumPy Academy