Pandas & NumPy Academy · Aula

pivot_table: tabulação cruzada

Crie tabelas dinâmicas no estilo do Excel com pd.pivot_table, definindo index, columns, values e aggfunc.

Aula 1 de 413 etapas

pivot_table: tabulação cruzada é 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 é uma tabela dinâmica?

Uma tabela dinâmica é uma tabulação cruzada que resume os dados por duas dimensões categóricas — uma forma as linhas e a outra forma as colunas — com um valor agregado em cada célula. Se você já criou uma tabela dinâmica no Excel, reconhecerá o conceito imediatamente. O Pandas fornece pd.pivot_table() (e a versão como método de DataFrame) para criar esses resumos inteiramente em Python.

Chamada básica de pivot_table

Os quatro parâmetros principais de pd.pivot_table() são: values (a coluna a ser agregada), index (a coluna que se tornará as linhas), columns (a coluna que se tornará as colunas) e aggfunc (a função de agregação, cujo padrão é 'mean'). O resultado é um DataFrame em que cada célula contém o valor agregado para aquela combinação de linha e coluna.

import pandas as pd

df = pd.DataFrame({
    'region':  ['East', 'West', 'East', 'West', 'East', 'West'],
    'product': ['A',    'A',    'B',    'B',    'A',    'B'],
    'revenue': [200,    340,    150,    290,    310,    410]
})

table = pd.pivot_table(df,
                       values='revenue',
                       index='region',
                       columns='product',
                       aggfunc='sum')
print(table)
# product    A    B
# region
# East     510  150
# West     340  700

Escolhendo a aggfunc

O parâmetro aggfunc aceita qualquer nome de função de agregação do NumPy/Pandas em forma de string, uma função chamável ou uma lista de funções chamáveis. Opções comuns: 'sum' para totais, 'mean' para médias, 'count' para frequências e 'min'/'max' para extremos. Quando você passa uma lista, cada agregação recebe seu próprio nível no MultiIndex das colunas.

# Using mean (default)
table_mean = pd.pivot_table(df, values='revenue',
                            index='region', columns='product',
                            aggfunc='mean')
print(table_mean.round(1))
# product      A      B
# region
# East     255.0  150.0
# West     340.0  350.0

# Using count
table_count = pd.pivot_table(df, values='revenue',
                             index='region', columns='product',
                             aggfunc='count')
print(table_count)

Lidando com células ausentes com fill_value

Quando uma combinação de rótulos de linha e coluna não tem dados, a célula contém NaN por padrão. Passe fill_value para substituir essas células ausentes por um valor padrão significativo, como 0 para contagens ou receita. Isso torna a tabela mais fácil de ler e evita que operações aritméticas posteriores produzam silenciosamente resultados NaN.

df2 = pd.DataFrame({
    'region':  ['East', 'West', 'East'],
    'product': ['A',    'A',    'B'],
    'revenue': [200,    340,    150]
})

# West-B combination has no data -> NaN by default
table = pd.pivot_table(df2, values='revenue', index='region',
                       columns='product', aggfunc='sum', fill_value=0)
print(table)
# product    A    B
# region
# East     200  150
# West     340    0  <- filled with 0 instead of NaN

Adicionando subtotais com margins

Passe margins=True para adicionar totais de linhas e colunas à tabela dinâmica. O Pandas acrescenta uma linha 'All' na parte inferior e uma coluna 'All' à direita, contendo os valores agregados de todas as categorias. Você pode renomear o rótulo da margem com margins_name. Isso corresponde à linha "Total geral" das tabelas dinâmicas do Excel.

table = pd.pivot_table(df, values='revenue', index='region',
                       columns='product', aggfunc='sum',
                       fill_value=0, margins=True, margins_name='Total')
print(table)
# product    A     B  Total
# region
# East     510   150    660
# West     340   700   1040
# Total    850   850   1700

Vários valores em pivot_table

O parâmetro values pode ser uma lista de nomes de colunas para agregar várias métricas de uma só vez. O resultado tem um MultiIndex nas colunas, cujo nível externo é a coluna de valores e o nível interno é a categoria. Isso permite criar uma tabela de resumo abrangente em uma única chamada, em vez de criar e mesclar várias tabelas dinâmicas separadas.

df['units'] = [10, 15, 8, 12, 14, 18]

table = pd.pivot_table(df,
                       values=['revenue', 'units'],
                       index='region',
                       columns='product',
                       aggfunc='sum')
print(table)
# Columns: (revenue, A), (revenue, B), (units, A), (units, B)
print(table.columns.tolist())

Índices e colunas hierárquicos

Quando você passa uma lista para index ou columns, a tabela dinâmica tem um MultiIndex no eixo correspondente. Isso permite criar resumos mais detalhados — por exemplo, dividindo a receita por região e trimestre nas linhas e por produto nas colunas. Acesse os subníveis com .loc e tuplas de índices como de costume.

df['quarter'] = ['Q1', 'Q1', 'Q2', 'Q2', 'Q1', 'Q2']

table = pd.pivot_table(df, values='revenue',
                       index=['region', 'quarter'],
                       columns='product',
                       aggfunc='sum', fill_value=0)
print(table)
# product         A    B
# region quarter
# East   Q1     510    0
#        Q2       0  150
# West   Q1     340    0
#        Q2       0  700

Achando o resultado

Depois de criar uma tabela dinâmica, o índice é a coluna de agrupamento e o MultiIndex das colunas (quando vários valores são usados) pode ser difícil de manipular. Um padrão comum de limpeza é chamar reset_index() para achatar o índice das linhas e, em seguida, reduzir o MultiIndex das colunas a um único nível, unindo os níveis com um sublinhado usando uma compreensão de lista.

table = pd.pivot_table(df, values=['revenue', 'units'],
                       index='region', columns='product', aggfunc='sum')

# Flatten MultiIndex columns
table.columns = ['_'.join(str(c) for c in col) for col in table.columns]
table = table.reset_index()
print(table.columns.tolist())
# ['region', 'revenue_A', 'revenue_B', 'units_A', 'units_B']

pivot_table versus groupby().agg()

Tanto pivot_table quanto groupby().agg() produzem estatísticas de resumo. A diferença está no formato do resultado: groupby().agg() retorna um DataFrame em formato longo, com uma linha para cada combinação de grupos, enquanto pivot_table retorna uma tabela em formato amplo, na qual uma dimensão se transforma em colunas. Para painéis e relatórios, o formato amplo das tabelas dinâmicas costuma ser mais legível; para aprendizado de máquina ou análise estatística posteriores, o formato longo é preferível.

# Long format (groupby)
long = df.groupby(['region', 'product'])['revenue'].sum().reset_index()
print(long)
# region product  revenue
# East        A      510
# East        B      150

# Wide format (pivot_table)
wide = pd.pivot_table(df, 'revenue', 'region', 'product', 'sum', fill_value=0)
print(wide)
# product    A    B
# region
# East     510  150

Ordenando e estilizando a tabela dinâmica

Uma tabela dinâmica é um DataFrame comum, portanto você pode ordená-la, calcular colunas derivadas e formatá-la exatamente como qualquer outro DataFrame do Pandas. Por exemplo, ordene por uma coluna de produto específica em ordem decrescente para classificar as regiões pelo desempenho desse produto ou adicione uma coluna de porcentagem dividindo cada célula pelo total da linha.

table = pd.pivot_table(df, 'revenue', 'region', 'product', 'sum', fill_value=0)

# Sort by product A revenue descending
table_sorted = table.sort_values('A', ascending=False)
print(table_sorted)

# Add percentage of row total
table['A_pct'] = (table['A'] / table.sum(axis=1) * 100).round(1)
print(table)

Uso prático: tabela para painel de vendas

As tabelas dinâmicas são uma ferramenta essencial para criar relatórios gerenciais e painéis. Um fluxo de trabalho típico é: carregar os dados brutos de transações, criar uma tabela dinâmica com os meses nas colunas e as categorias de produtos nas linhas, adicionar os totais das margens e exportar para o Excel. Todo o fluxo, dos dados brutos até uma tabela pronta para a diretoria, requer apenas algumas chamadas do Pandas.

# Simulated monthly product revenue pivot
result = pd.pivot_table(
    df,
    values='revenue',
    index='product',
    columns='region',
    aggfunc='sum',
    fill_value=0,
    margins=True,
    margins_name='Grand Total'
)
print(result)
# Export to Excel
# result.to_excel('sales_pivot.xlsx')

Verificação rápida

Teste sua compreensão sobre pd.pivot_table nesta lição.

Recapitulação da lição

Nesta lição, você aprendeu que: pd.pivot_table() cria resumos em tabulação cruzada, com uma dimensão nas linhas e outra nas colunas; fill_value trata as células ausentes e margins=True adiciona totais; é possível agregar vários valores de uma só vez; e as tabelas dinâmicas produzem resultados em formato amplo, ideais para relatórios. A seguir, exploraremos a operação inversa: melt() para converter dados amplos novamente em formato longo.

Grátis para começar

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 “pivot_table: tabulação cruzada” é grátis?

Sim — o texto completo de “pivot_table: tabulação cruzada” é 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 “pivot_table: tabulação cruzada”?

Crie tabelas dinâmicas no estilo do Excel com pd.pivot_table, definindo index, columns, values e aggfunc. 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 “pivot_table: tabulação cruzada”?

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. pivot_table: tabulação cruzada
  2. melt: do formato largo ao longo
  3. stack e unstack com MultiIndex
  4. crosstab para tabelas de frequência
← Voltar para Pandas & NumPy Academy