Criando um MultiIndex
Crie um índice hierárquico de linhas com pd.MultiIndex.from_tuples ou set_index em várias colunas e inspecione seus níveis.
Criando um MultiIndex é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 1 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 MultiIndex
Um MultiIndex (também chamado de índice hierárquico) permite que um DataFrame ou Series do Pandas tenha múltiplos níveis de rótulos de linhas. Pense nele como uma chave composta em um banco de dados: em vez de identificar uma linha por um único rótulo, você a identifica por uma tupla, como (país, cidade) ou (ano, trimestre). MultiIndexes são essenciais para representar dados em painel, séries temporais transversais e qualquer conjunto de dados com uma estrutura natural de agrupamento em dois níveis.
import pandas as pd
# A simple example: sales by country and city
data = {
'sales': [100, 200, 150, 300, 80, 120]
}
index = pd.MultiIndex.from_tuples(
[('USA', 'New York'), ('USA', 'Chicago'),
('UK', 'London'), ('UK', 'Manchester'),
('DE', 'Berlin'), ('DE', 'Munich')],
names=['country', 'city']
)
df = pd.DataFrame(data, index=index)
print(df)Criando um MultiIndex com from_tuples
pd.MultiIndex.from_tuples(list_of_tuples, names=) é a maneira mais explícita de criar um MultiIndex. Cada tupla se torna um rótulo de linha, e seus elementos se tornam os níveis. O parâmetro names atribui um rótulo a cada nível (por exemplo, ['year', 'quarter']). Esse método é útil quando você tem uma lista pré-construída de chaves compostas que deseja usar como índice de linhas.
import pandas as pd
# Multi-level time index: year x quarter
tuples = [
(2022, 'Q1'), (2022, 'Q2'), (2022, 'Q3'), (2022, 'Q4'),
(2023, 'Q1'), (2023, 'Q2'), (2023, 'Q3'), (2023, 'Q4')
]
mi = pd.MultiIndex.from_tuples(tuples, names=['year', 'quarter'])
revenue = [120, 135, 145, 160, 130, 148, 162, 175]
df = pd.Series(revenue, index=mi, name='revenue_M')
print(df)Criando um MultiIndex com from_product
pd.MultiIndex.from_product(iterables, names=) cria um MultiIndex a partir do produto cartesiano de várias listas — todas as combinações de elementos das listas de entrada. Esse é o método mais conveniente quando todas as combinações de níveis devem existir nos seus dados. Por exemplo, todas as combinações de 3 anos × 4 trimestres × 5 regiões criam automaticamente um painel equilibrado com 60 linhas.
import pandas as pd
import numpy as np
years = [2021, 2022, 2023]
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
# Cartesian product: 3 years x 4 quarters = 12 combinations
mi = pd.MultiIndex.from_product([years, quarters], names=['year', 'quarter'])
print('Number of index entries:', len(mi))
print('First 6 entries:', mi[:6].tolist())
# Create a DataFrame with this index
df = pd.DataFrame({'revenue': np.random.randint(100, 200, 12)}, index=mi)
print('\n', df.head())Criando um MultiIndex com set_index
A maneira mais comum de criar um MultiIndex na prática é começar com um DataFrame regular que tenha colunas de agrupamento e, em seguida, chamar df.set_index([col1, col2]). Isso promove essas colunas, transformando-as de colunas de dados em níveis de índice. O resultado é o mesmo que se você tivesse criado o índice do zero com from_tuples, mas requer apenas uma linha a partir de dados tabulares.
import pandas as pd
# Start with a flat DataFrame
df_flat = pd.DataFrame({
'country': ['USA', 'USA', 'UK', 'UK', 'DE', 'DE'],
'year': [2022, 2023, 2022, 2023, 2022, 2023],
'gdp_bn': [25000, 26000, 3100, 3200, 4200, 4350]
})
# Promote two columns to a MultiIndex
df = df_flat.set_index(['country', 'year'])
print(df)
print('\nIndex type:', type(df.index).__name__)
print('Index names:', df.index.names)Inspecionando os níveis de um MultiIndex
Um MultiIndex armazena seus dados em níveis (os valores exclusivos de cada nível) e códigos (ponteiros inteiros para os vetores de níveis). Inspecione os níveis com df.index.levels ou df.index.get_level_values(level). Use df.index.nlevels para verificar quantos níveis existem. O atributo names lista o nome atribuído a cada nível — defina esses nomes com df.index.set_names(['level0', 'level1']).
import pandas as pd
df_flat = pd.DataFrame({
'country': ['USA', 'USA', 'UK', 'UK'],
'year': [2022, 2023, 2022, 2023],
'gdp': [25000, 26000, 3100, 3200]
})
df = df_flat.set_index(['country', 'year'])
print('Number of levels:', df.index.nlevels)
print('Level names:', df.index.names)
print('Level 0 values:', df.index.get_level_values(0).tolist())
print('Level 1 values:', df.index.get_level_values(1).tolist())
print('Unique level 0:', df.index.get_level_values('country').unique().tolist())MultiIndex nas colunas
Um MultiIndex também pode ser aplicado às colunas, criando uma hierarquia de rótulos de coluna. Isso é comum quando você armazena várias métricas para cada categoria em um layout no estilo tabela dinâmica — por exemplo, (receita, T1), (receita, T2), (custo, T1), (custo, T2). Acesse as colunas com um MultiIndex da mesma forma que acessa as linhas — usando tuplas. Crie um MultiIndex de colunas com pd.MultiIndex.from_product e atribua-o a df.columns.
import pandas as pd
import numpy as np
# Create a DataFrame with MultiIndex columns
metrics = ['revenue', 'cost']
quarters = ['Q1', 'Q2', 'Q3', 'Q4']
col_index = pd.MultiIndex.from_product([metrics, quarters], names=['metric', 'quarter'])
data = np.random.randint(50, 200, size=(3, 8))
df = pd.DataFrame(data, columns=col_index, index=['USA', 'UK', 'DE'])
df.index.name = 'country'
print(df)MultiIndex após a agregação com GroupBy
Quando você chama groupby([col1, col2]).agg(...), o DataFrame resultante tem um MultiIndex nas linhas (as duas chaves de groupby tornam-se os dois níveis do índice) e potencialmente um MultiIndex nas colunas (se você agregar várias métricas). Essa é a maneira mais comum de encontrar um MultiIndex na análise cotidiana de dados — entender como navegá-lo é essencial para trabalhar com resultados de groupby.
import pandas as pd
import seaborn as sns
tips = sns.load_dataset('tips')
# Two-key groupby creates a MultiIndex on rows
result = tips.groupby(['day', 'time'])['total_bill'].agg(['mean', 'count'])
print(result)
print('\nIndex type:', type(result.index).__name__)
print('Index names:', result.index.names)Trocando e reordenando níveis
Use df.swaplevel() para trocar dois níveis do índice e df.reorder_levels([...]) para alterar a ordem de todos os níveis. A reordenação é útil quando você quer fazer uma seleção começando por um nível interno ou quando dois DataFrames têm seus níveis de índice em ordens diferentes e precisam ser alinhados antes da mesclagem. Depois de reordenar, sempre chame sort_index() para restaurar a ordem lexicográfica e permitir uma seleção eficiente.
import pandas as pd
import seaborn as sns
tips = sns.load_dataset('tips')
result = tips.groupby(['day', 'time'])['total_bill'].mean()
print('Original levels:', result.index.names)
# Swap so time is the outer level
swapped = result.swaplevel().sort_index()
print('\nSwapped levels:', swapped.index.names)
print(swapped.head())Verificando e ordenando um MultiIndex
A seleção em um MultiIndex só é eficiente quando o índice está ordenado lexicograficamente. Verifique se o índice está ordenado com df.index.is_monotonic_increasing. Se o resultado for False, ordene-o com df.sort_index(). Um MultiIndex não ordenado aciona um PerformanceWarning durante operações de seleção e pode retornar resultados incorretos em alguns casos extremos — sempre ordene o índice depois de criar ou modificar um MultiIndex.
import pandas as pd
# Create an unsorted MultiIndex deliberately
tuples = [('B', 2), ('A', 1), ('B', 1), ('A', 2)]
mi = pd.MultiIndex.from_tuples(tuples, names=['letter', 'num'])
df = pd.DataFrame({'value': [10, 20, 30, 40]}, index=mi)
print('Is sorted:', df.index.is_monotonic_increasing)
print('Before sorting:')
print(df)
df_sorted = df.sort_index()
print('\nAfter sorting:')
print(df_sorted)
print('Is sorted:', df_sorted.index.is_monotonic_increasing)Redefinindo um MultiIndex para colunas
Chame df.reset_index() para converter todos os níveis do índice novamente em colunas regulares, deixando o DataFrame com um RangeIndex inteiro simples. Esse é um padrão comum após agregações com groupby: calcule o resumo agrupado com um MultiIndex e, em seguida, redefina o índice para obter um DataFrame plano, adequado para outras operações do Pandas, combinações ou exportação para CSV. Use reset_index(level='name') para redefinir apenas um nível de um índice de dois níveis.
import pandas as pd
import seaborn as sns
tips = sns.load_dataset('tips')
result = tips.groupby(['day', 'time'])['total_bill'].mean()
print('MultiIndex result:')
print(result.head(4))
# Flatten back to a regular DataFrame
flat = result.reset_index()
print('\nFlattened DataFrame:')
print(flat.head(4))
print('Index type:', type(flat.index).__name__)Quando usar um MultiIndex
Use um MultiIndex quando seus dados tiverem uma estrutura hierárquica natural: séries temporais com granularidade inferior a um dia (data + hora), dados em painel (entidade + período) ou agrupamentos aninhados (país + região + cidade). Evite MultiIndexes para chaves de agrupamento simples em duas colunas, quando um DataFrame plano com colunas separadas for igualmente legível. Se você perceber que está chamando reset_index() constantemente apenas para acessar os dados, isso é um sinal de que o MultiIndex não está agregando valor ao seu fluxo de trabalho.
Verificação rápida
Teste sua compreensão sobre a criação de MultiIndex nesta lição.
Recapitulação da lição
Nesta lição, você aprendeu que: MultiIndexes fornecem rótulos hierárquicos de linhas (ou colunas) usando tuplas, criados com from_tuples, from_product ou set_index em várias colunas, e devem estar sempre ordenados para permitir o fatiamento eficiente. Em seguida, veremos como selecionar dados de um MultiIndex usando .loc, tuplas, fatias e o auxiliar IndexSlice.
Perguntas Frequentes
A aula “Criando um MultiIndex” é grátis?
Sim — o texto completo de “Criando um MultiIndex” é 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 “Criando um MultiIndex”?
Crie um índice hierárquico de linhas com pd.MultiIndex.from_tuples ou set_index em várias colunas e inspecione seus níveis. 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 1 de 4.
Quanto tempo leva a aula “Criando um MultiIndex”?
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
- Criando um MultiIndex
- Selecionando dados de um MultiIndex
- Alinhamento e reindexação de índices
- Benefícios de desempenho de índices ordenados