Skip to content

Gráfico de Pizza no Matplotlib: Guia Completo para Criar Gráficos de Pizza em Python

Soren Atelier
Name
Soren Atelier

Updated on

Criar visualizações de dados eficazes é fundamental para comunicar insights com clareza. Quando você precisa mostrar proporções ou percentuais de um todo, os gráficos de pizza se tornam uma ferramenta essencial no seu arsenal de visualização. Ainda assim, muitos analistas de dados têm dificuldade em criar gráficos de pizza com aparência profissional que destaquem corretamente segmentos importantes, usem cores apropriadas e exibam percentuais com precisão. O gráfico de pizza padrão do matplotlib frequentemente parece simples demais, carece de contexto e não consegue enfatizar pontos-chave dos dados.

Esses desafios de visualização ficam ainda mais evidentes ao apresentar para stakeholders que precisam entender rapidamente distribuições de participação de mercado, alocações de orçamento ou a divisão de respostas de uma pesquisa. Um gráfico de pizza mal projetado pode confundir em vez de esclarecer, levando a interpretações equivocadas de métricas críticas do negócio.

O Matplotlib fornece uma função abrangente plt.pie() com extensas opções de personalização que transformam gráficos circulares básicos em visualizações profissionais. Este guia mostra como criar gráficos de pizza desde proporções simples até diagramas aninhados complexos, com exemplos práticos cobrindo rótulos, cores, fatias destacadas (explode), gráficos de rosca e integração com DataFrames do pandas para fluxos de trabalho reais de análise de dados.

📚

    Sintaxe Básica de Gráfico de Pizza no Matplotlib

    A base para criar gráficos de pizza no matplotlib começa com plt.pie(), que exige apenas uma lista ou array de valores representando o tamanho de cada fatia.

    import matplotlib.pyplot as plt
 
# Basic pie chart data
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
 
# Create pie chart
plt.pie(sizes, labels=labels)
plt.title('Market Share Distribution')
plt.show()

    Isso cria um gráfico circular básico em que os tamanhos das fatias são proporcionais aos valores na lista sizes. O Matplotlib calcula automaticamente os percentuais e os ângulos para cada segmento. O gráfico atribui cores a partir do ciclo de cores padrão, o que pode nem sempre atender às necessidades da sua apresentação.

    Para garantir uma aparência circular adequada, e não uma elipse, adicione plt.axis('equal'):

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
 
plt.pie(sizes, labels=labels)
plt.axis('equal')  # Equal aspect ratio ensures circular shape
plt.title('Market Share Distribution')
plt.show()

    Exibindo Percentuais com autopct

    O parâmetro autopct formata e exibe automaticamente valores percentuais em cada fatia, tornando o gráfico mais informativo sem cálculos manuais.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
 
plt.pie(sizes, labels=labels, autopct='%1.1f%%')
plt.axis('equal')
plt.title('Market Share with Percentages')
plt.show()

    A string de formatação '%1.1f%%' exibe percentuais com uma casa decimal. O primeiro % inicia o especificador de formato, 1.1f significa um dígito antes do decimal e um depois, e %% gera um símbolo de porcentagem literal na saída.

    Para percentuais inteiros sem casas decimais, use '%1.0f%%':

    plt.pie(sizes, labels=labels, autopct='%1.0f%%')

    Você também pode passar uma função personalizada para autopct para ter mais controle sobre a exibição do percentual:

    import matplotlib.pyplot as plt
 
sizes = [350, 250, 200, 200]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
 
def make_autopct(values):
    def my_autopct(pct):
        total = sum(values)
        val = int(round(pct * total / 100.0))
        return f'{pct:.1f}%\n({val:d})'
    return my_autopct
 
plt.pie(sizes, labels=labels, autopct=make_autopct(sizes))
plt.axis('equal')
plt.title('Market Share with Counts and Percentages')
plt.show()

    Isso exibe tanto o percentual quanto a contagem real em cada fatia.

    Cores Personalizadas e Colormaps

    O parâmetro colors aceita uma lista de especificações de cores para substituir o ciclo padrão de cores do matplotlib. Você pode usar cores nomeadas, códigos hex ou tuplas RGB.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%')
plt.axis('equal')
plt.title('Market Share with Custom Colors')
plt.show()

    Para seleção de cores orientada por dados, use colormaps do matplotlib:

    import matplotlib.pyplot as plt
import numpy as np
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
 
# Generate colors from a colormap
cmap = plt.cm.Set3
colors = cmap(np.linspace(0, 1, len(sizes)))
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%')
plt.axis('equal')
plt.title('Market Share with Colormap')
plt.show()

    Colormaps populares para gráficos de pizza incluem Set1, Set2, Set3, Pastel1, Pastel2 e tab10.

    Destacando Fatias com Explode

    O parâmetro explode separa fatias específicas a partir do centro para enfatizar pontos importantes. Cada valor na tupla explode representa o deslocamento radial da fatia correspondente.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
explode = (0.1, 0, 0, 0)  # Explode the first slice
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        explode=explode)
plt.axis('equal')
plt.title('Market Share with Exploded Slice')
plt.show()

    O valor 0.1 move a primeira fatia para fora em 10% do raio. Você pode destacar múltiplas fatias:

    explode = (0.1, 0.05, 0, 0)  # Explode first two slices
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        explode=explode)

    Adicionando Sombra e Ângulo Inicial

    O parâmetro shadow adiciona uma sombra projetada para um efeito tridimensional, enquanto startangle rotaciona todo o gráfico para posicionar as fatias em ângulos específicos.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
explode = (0.1, 0, 0, 0)
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        explode=explode, shadow=True, startangle=90)
plt.axis('equal')
plt.title('Market Share with Shadow and Rotation')
plt.show()

    O startangle=90 rotaciona o gráfico para que a primeira fatia comece em 90 graus (topo do círculo) em vez do padrão 0 graus (lado direito). Isso é útil para posicionar fatias importantes no topo, para melhor visibilidade.

    Criando Gráficos de Rosca (Donut)

    Gráficos de rosca são gráficos de pizza com um centro vazado, criados usando o parâmetro wedgeprops para definir a largura de cada setor.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
# Create donut chart
wedgeprops = {'width': 0.4}
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        wedgeprops=wedgeprops)
plt.axis('equal')
plt.title('Market Share Donut Chart')
plt.show()

    O valor width de 0.4 cria um anel com 40% do raio total. Um valor menor cria um anel mais fino, enquanto valores próximos de 1.0 se aproximam de um gráfico de pizza completo.

    Você pode adicionar texto no centro do gráfico de rosca:

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
wedgeprops = {'width': 0.4, 'edgecolor': 'white', 'linewidth': 2}
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        wedgeprops=wedgeprops)
plt.axis('equal')
 
# Add center text
plt.text(0, 0, 'Total\nSales', ha='center', va='center',
         fontsize=14, fontweight='bold')
plt.title('Market Share Donut Chart')
plt.show()

    Gráficos de Pizza Aninhados e Concêntricos

    Crie visualizações complexas plotando múltiplos gráficos de pizza com raios diferentes para mostrar relações hierárquicas nos dados.

    import matplotlib.pyplot as plt
import numpy as np
 
# Outer ring data
outer_sizes = [35, 25, 20, 20]
outer_labels = ['Product A', 'Product B', 'Product C', 'Product D']
outer_colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
# Inner ring data (subcategories)
inner_sizes = [15, 20, 12, 13, 10, 10, 8, 12]
inner_labels = ['A1', 'A2', 'B1', 'B2', 'C1', 'C2', 'D1', 'D2']
inner_colors = ['#ffcccc', '#ff6666', '#99ccff', '#3399ff',
                '#ccffcc', '#66ff66', '#ffe6cc', '#ffb366']
 
fig, ax = plt.subplots()
 
# Outer pie
ax.pie(outer_sizes, labels=outer_labels, colors=outer_colors,
       autopct='%1.1f%%', radius=1.2, wedgeprops={'width': 0.4})
 
# Inner pie
ax.pie(inner_sizes, labels=inner_labels, colors=inner_colors,
       autopct='%1.0f%%', radius=0.8, wedgeprops={'width': 0.4})
 
ax.axis('equal')
plt.title('Nested Pie Chart: Products and Subcategories')
plt.show()

    Isso cria dois gráficos de rosca concêntricos, onde o anel interno mostra subcategorias dos segmentos do anel externo.

    Adicionando Legendas

    Para gráficos com muitas fatias ou quando os rótulos deixam a visualização poluída, mova os rótulos para uma legenda usando a função legend().

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 15, 5]
labels = ['Product A', 'Product B', 'Product C', 'Product D', 'Others']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99', '#ff99cc']
 
plt.pie(sizes, colors=colors, autopct='%1.1f%%', startangle=90)
plt.axis('equal')
plt.legend(labels, loc='upper left', bbox_to_anchor=(1, 0, 0.5, 1))
plt.title('Market Share Distribution')
plt.tight_layout()
plt.show()

    O parâmetro bbox_to_anchor posiciona a legenda fora da área do gráfico. A função tight_layout() ajusta a área do plot para evitar que a legenda seja cortada.

    Para entradas de legenda personalizadas com percentuais:

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 15, 5]
labels = ['Product A', 'Product B', 'Product C', 'Product D', 'Others']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99', '#ff99cc']
 
wedges, texts, autotexts = plt.pie(sizes, colors=colors, autopct='%1.1f%%',
                                     startangle=90)
plt.axis('equal')
 
# Create legend with labels and percentages
legend_labels = [f'{label} ({size}%)' for label, size in zip(labels, sizes)]
plt.legend(wedges, legend_labels, loc='upper left',
           bbox_to_anchor=(1, 0, 0.5, 1))
plt.title('Market Share Distribution')
plt.tight_layout()
plt.show()

    Referência de Parâmetros do Gráfico de Pizza

    ParameterTypeDescriptionExample
    xarray-likeSlice sizes (required)[30, 25, 20, 25]
    labelslist of strText labels for each slice['A', 'B', 'C', 'D']
    colorslistColors for each slice['red', 'blue', 'green']
    autopctstr or functionFormat string or function for percentages'%1.1f%%'
    explodetupleRadial offset for each slice(0.1, 0, 0, 0)
    shadowboolAdd drop shadowTrue or False
    startanglefloatRotation angle in degrees90
    radiusfloatPie chart radius1.0 (default)
    wedgepropsdictProperties for wedge patches{'width': 0.4}
    textpropsdictProperties for text labels{'fontsize': 12}
    labeldistancefloatDistance of labels from center1.1 (default)
    pctdistancefloatDistance of percentage text from center0.6 (default)
    counterclockboolDirection of slicesTrue (default)
    frameboolDraw axis frameFalse (default)

    Personalizando Propriedades de Texto

    O parâmetro textprops controla a aparência de todos os elementos textuais no gráfico de pizza, incluindo rótulos e percentuais.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
textprops = {'fontsize': 14, 'fontweight': 'bold', 'color': 'darkblue'}
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        textprops=textprops)
plt.axis('equal')
plt.title('Market Share with Custom Text', fontsize=16, fontweight='bold')
plt.show()

    Para controle separado de rótulos e texto de percentual, acesse os objetos de texto retornados:

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
wedges, texts, autotexts = plt.pie(sizes, labels=labels, colors=colors,
                                     autopct='%1.1f%%')
 
# Customize label text
for text in texts:
    text.set_fontsize(12)
    text.set_fontweight('bold')
 
# Customize percentage text
for autotext in autotexts:
    autotext.set_color('white')
    autotext.set_fontsize(10)
    autotext.set_fontweight('bold')
 
plt.axis('equal')
plt.title('Market Share with Styled Text')
plt.show()

    Trabalhando com DataFrames do Pandas

    Em análises reais, é comum trabalhar com DataFrames do pandas. Você pode criar gráficos de pizza diretamente a partir de colunas do DataFrame.

    import matplotlib.pyplot as plt
import pandas as pd
 
# Sample DataFrame
data = {
    'Product': ['Product A', 'Product B', 'Product C', 'Product D'],
    'Sales': [350000, 250000, 200000, 200000]
}
df = pd.DataFrame(data)
 
# Create pie chart from DataFrame
plt.pie(df['Sales'], labels=df['Product'], autopct='%1.1f%%',
        startangle=90)
plt.axis('equal')
plt.title('Sales Distribution by Product')
plt.show()

    Para dados agrupados, use agregação do pandas antes de plotar:

    import matplotlib.pyplot as plt
import pandas as pd
 
# Sample DataFrame with categories
data = {
    'Region': ['North', 'South', 'East', 'West', 'North', 'South', 'East', 'West'],
    'Product': ['A', 'A', 'A', 'A', 'B', 'B', 'B', 'B'],
    'Sales': [120000, 80000, 95000, 105000, 90000, 110000, 85000, 95000]
}
df = pd.DataFrame(data)
 
# Group by region and sum sales
region_sales = df.groupby('Region')['Sales'].sum()
 
plt.pie(region_sales.values, labels=region_sales.index, autopct='%1.1f%%',
        startangle=90)
plt.axis('equal')
plt.title('Total Sales by Region')
plt.show()

    Salvando Gráficos de Pizza em Arquivos

    Salve gráficos de pizza em vários formatos de imagem usando plt.savefig() antes de chamar plt.show().

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%')
plt.axis('equal')
plt.title('Market Share Distribution')
 
# Save as PNG with high DPI
plt.savefig('market_share.png', dpi=300, bbox_inches='tight')
 
# Save as PDF for vector graphics
plt.savefig('market_share.pdf', bbox_inches='tight')
 
# Save as SVG for web use
plt.savefig('market_share.svg', bbox_inches='tight')
 
plt.show()

    O parâmetro bbox_inches='tight' remove espaços em branco extras ao redor do gráfico. O parâmetro dpi controla a resolução para formatos raster como PNG.

    Exemplo do Mundo Real: Divisão de Orçamento

    import matplotlib.pyplot as plt
import pandas as pd
 
# Annual budget data
budget_data = {
    'Category': ['Salaries', 'Marketing', 'Operations', 'R&D', 'Infrastructure'],
    'Amount': [450000, 180000, 120000, 150000, 100000]
}
df = pd.DataFrame(budget_data)
 
# Calculate total budget
total_budget = df['Amount'].sum()
 
# Define colors
colors = ['#ff6b6b', '#4ecdc4', '#45b7d1', '#f9ca24', '#6c5ce7']
 
# Create pie chart
fig, ax = plt.subplots(figsize=(10, 7))
 
wedges, texts, autotexts = ax.pie(df['Amount'], labels=df['Category'],
                                    colors=colors, autopct='%1.1f%%',
                                    startangle=90, explode=(0.05, 0, 0, 0, 0))
 
# Customize text
for text in texts:
    text.set_fontsize(12)
    text.set_fontweight('bold')
 
for autotext in autotexts:
    autotext.set_color('white')
    autotext.set_fontsize(10)
    autotext.set_fontweight('bold')
 
ax.axis('equal')
plt.title(f'Annual Budget Breakdown\nTotal: ${total_budget:,}',
          fontsize=16, fontweight='bold', pad=20)
 
plt.tight_layout()
plt.savefig('budget_breakdown.png', dpi=300, bbox_inches='tight')
plt.show()

    Exemplo do Mundo Real: Resultados de Pesquisa

    import matplotlib.pyplot as plt
import numpy as np
 
# Survey response data
responses = {
    'Very Satisfied': 145,
    'Satisfied': 230,
    'Neutral': 85,
    'Dissatisfied': 30,
    'Very Dissatisfied': 10
}
 
labels = list(responses.keys())
sizes = list(responses.values())
total_responses = sum(sizes)
 
# Color scheme from red to green
colors = ['#2ecc71', '#3498db', '#95a5a6', '#e67e22', '#e74c3c']
 
fig, ax = plt.subplots(figsize=(10, 7))
 
wedges, texts, autotexts = ax.pie(sizes, labels=labels, colors=colors,
                                    autopct=lambda pct: f'{pct:.1f}%\n({int(pct * total_responses / 100)})',
                                    startangle=90, wedgeprops={'edgecolor': 'white', 'linewidth': 2})
 
for text in texts:
    text.set_fontsize(11)
 
for autotext in autotexts:
    autotext.set_color('white')
    autotext.set_fontsize(9)
    autotext.set_fontweight('bold')
 
ax.axis('equal')
plt.title(f'Customer Satisfaction Survey Results\nTotal Responses: {total_responses}',
          fontsize=16, fontweight='bold', pad=20)
 
plt.tight_layout()
plt.show()

    Exemplo do Mundo Real: Análise de Participação de Mercado

    import matplotlib.pyplot as plt
import pandas as pd
 
# Market share data for multiple quarters
data = {
    'Company': ['Company A', 'Company B', 'Company C', 'Company D', 'Others'],
    'Q1_Share': [28, 24, 18, 15, 15],
    'Q2_Share': [30, 22, 19, 14, 15],
    'Q3_Share': [32, 21, 18, 15, 14],
    'Q4_Share': [35, 20, 17, 16, 12]
}
df = pd.DataFrame(data)
 
# Create subplots for each quarter
fig, axes = plt.subplots(2, 2, figsize=(14, 12))
quarters = ['Q1_Share', 'Q2_Share', 'Q3_Share', 'Q4_Share']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99', '#ff99cc']
 
for idx, (ax, quarter) in enumerate(zip(axes.flat, quarters)):
    wedges, texts, autotexts = ax.pie(df[quarter], labels=df['Company'],
                                        colors=colors, autopct='%1.1f%%',
                                        startangle=90)
 
    for text in texts:
        text.set_fontsize(10)
 
    for autotext in autotexts:
        autotext.set_color('white')
        autotext.set_fontsize(9)
        autotext.set_fontweight('bold')
 
    ax.set_title(f'Market Share {quarter.replace("_Share", "")}',
                 fontsize=12, fontweight='bold')
 
plt.suptitle('Quarterly Market Share Analysis', fontsize=16, fontweight='bold', y=0.995)
plt.tight_layout()
plt.savefig('market_share_analysis.png', dpi=300, bbox_inches='tight')
plt.show()

    Combinando Gráficos de Pizza com Outras Visualizações

    Crie dashboards completos combinando gráficos de pizza com gráficos de barras, linhas ou tabelas.

    import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
 
# Sample data
categories = ['Product A', 'Product B', 'Product C', 'Product D']
current_sales = [350000, 250000, 200000, 200000]
previous_sales = [320000, 280000, 180000, 220000]
 
# Create figure with subplots
fig = plt.figure(figsize=(14, 6))
 
# Pie chart showing current market share
ax1 = plt.subplot(1, 2, 1)
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
ax1.pie(current_sales, labels=categories, colors=colors, autopct='%1.1f%%',
        startangle=90)
ax1.set_title('Current Market Share', fontsize=14, fontweight='bold')
 
# Bar chart showing comparison
ax2 = plt.subplot(1, 2, 2)
x = np.arange(len(categories))
width = 0.35
 
bars1 = ax2.bar(x - width/2, previous_sales, width, label='Previous Period',
                color='#95a5a6', alpha=0.8)
bars2 = ax2.bar(x + width/2, current_sales, width, label='Current Period',
                color='#3498db', alpha=0.8)
 
ax2.set_xlabel('Products', fontsize=12, fontweight='bold')
ax2.set_ylabel('Sales ($)', fontsize=12, fontweight='bold')
ax2.set_title('Sales Comparison', fontsize=14, fontweight='bold')
ax2.set_xticks(x)
ax2.set_xticklabels(categories)
ax2.legend()
ax2.grid(axis='y', alpha=0.3)
 
plt.tight_layout()
plt.savefig('combined_visualization.png', dpi=300, bbox_inches='tight')
plt.show()

    Quando Usar Gráficos de Pizza vs Gráficos de Barras

    Gráficos de pizza funcionam melhor em cenários específicos, mas gráficos de barras geralmente oferecem comparações mais claras.

    Use gráficos de pizza quando:

    • Você está mostrando partes de um todo (os percentuais devem somar 100%)
    • Há 5 ou menos categorias
    • Você quer enfatizar um ou dois segmentos dominantes
    • As proporções exatas são menos importantes do que a composição geral
    • Você está criando resumos executivos de alto nível

    Use gráficos de barras quando:

    • Você precisa comparar valores entre categorias
    • Há mais de 5 categorias
    • Você precisa de comparações precisas de valores
    • Os valores não somam um todo significativo
    • Você está mostrando tendências ao longo do tempo
    • Stakeholders precisam comparar segmentos de tamanhos semelhantes

    Exemplo de comparação:

    import matplotlib.pyplot as plt
 
data = {'Category A': 23, 'Category B': 19, 'Category C': 18,
        'Category D': 17, 'Category E': 13, 'Category F': 10}
 
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
 
# Pie chart
ax1.pie(data.values(), labels=data.keys(), autopct='%1.1f%%', startangle=90)
ax1.set_title('Pie Chart: Harder to Compare Similar Values', fontweight='bold')
 
# Bar chart
ax2.bar(data.keys(), data.values(), color='#3498db')
ax2.set_ylabel('Value', fontweight='bold')
ax2.set_title('Bar Chart: Easier to Compare Similar Values', fontweight='bold')
ax2.grid(axis='y', alpha=0.3)
 
plt.tight_layout()
plt.show()

    O gráfico de barras torna pequenas diferenças entre categorias muito mais aparentes do que o gráfico de pizza.

    Gráficos de Pizza Interativos com PyGWalker

    Para análise exploratória de dados que exige visualizações interativas, PyGWalker (opens in a new tab) transforma DataFrames do pandas em interfaces interativas no estilo Tableau, com criação de gráficos de pizza via drag-and-drop.

    import pandas as pd
import pygwalker as pyg
 
# Sample DataFrame
data = {
    'Product': ['Product A', 'Product B', 'Product C', 'Product D', 'Product E'],
    'Sales': [350000, 250000, 200000, 200000, 150000],
    'Region': ['North', 'South', 'East', 'West', 'North']
}
df = pd.DataFrame(data)
 
# Launch interactive visualization interface
walker = pyg.walk(df)

    O PyGWalker permite que analistas de negócio, mesmo sem experiência em programação, criem gráficos de pizza e outras visualizações de forma interativa, filtrem dados dinamicamente e exportem resultados para apresentações. A ferramenta lida com agregações complexas e fornece resumos estatísticos embutidos, tornando-se valiosa para prototipagem rápida antes de finalizar visualizações de produção com matplotlib.

    Personalização Avançada: Cores de Borda e Estilos de Linha

    Adicione separação visual entre as fatias usando cores de borda e espessuras de linha via o parâmetro wedgeprops.

    import matplotlib.pyplot as plt
 
sizes = [35, 25, 20, 20]
labels = ['Product A', 'Product B', 'Product C', 'Product D']
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99']
 
wedgeprops = {
    'edgecolor': 'black',
    'linewidth': 2,
    'linestyle': '-',
    'antialiased': True
}
 
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%',
        startangle=90, wedgeprops=wedgeprops)
plt.axis('equal')
plt.title('Market Share with Edge Styling')
plt.show()

    Para um efeito mais sutil, use bordas brancas:

    wedgeprops = {'edgecolor': 'white', 'linewidth': 3}

    Lidando com Fatias Pequenas e Sobreposição de Rótulos

    Ao lidar com muitas fatias pequenas, os rótulos podem se sobrepor. Soluções incluem usar uma legenda, aumentar o tamanho da figura ou ajustar o posicionamento dos rótulos.

    import matplotlib.pyplot as plt
 
# Data with several small slices
sizes = [30, 25, 15, 10, 8, 5, 4, 3]
labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
colors = plt.cm.Set3(range(len(sizes)))
 
fig, ax = plt.subplots(figsize=(10, 8))
 
wedges, texts, autotexts = ax.pie(sizes, colors=colors, autopct='%1.1f%%',
                                    startangle=90, pctdistance=0.85)
 
# Remove labels from pie and use legend
for text in texts:
    text.set_text('')
 
ax.legend(wedges, labels, title="Categories", loc="center left",
          bbox_to_anchor=(1, 0, 0.5, 1))
ax.axis('equal')
ax.set_title('Distribution with Many Categories', fontsize=14, fontweight='bold')
 
plt.tight_layout()
plt.show()

    Como alternativa, exiba apenas os percentuais no gráfico e use uma legenda para os nomes das categorias, reduzindo a poluição visual.

    Criando Gráficos de Rosca Proporcionais com Múltiplos Anéis

    Construa visualizações hierárquicas complexas mostrando divisões por categoria em múltiplos níveis.

    import matplotlib.pyplot as plt
import numpy as np
 
# Department budget data
departments = ['Engineering', 'Sales', 'Marketing', 'Operations']
dept_budgets = [400000, 300000, 200000, 100000]
 
# Team breakdown within departments
teams = ['Backend', 'Frontend', 'Mobile',
         'Field Sales', 'Inside Sales',
         'Digital', 'Content',
         'Logistics', 'Support']
team_budgets = [200000, 150000, 50000,
                180000, 120000,
                120000, 80000,
                60000, 40000]
 
fig, ax = plt.subplots(figsize=(12, 8))
 
# Outer ring (departments)
dept_colors = ['#e74c3c', '#3498db', '#2ecc71', '#f39c12']
outer_pie = ax.pie(dept_budgets, labels=departments, colors=dept_colors,
                    autopct='%1.1f%%', radius=1.3, wedgeprops={'width': 0.35})
 
# Inner ring (teams)
team_colors = ['#c0392b', '#e74c3c', '#ec7063',
               '#2980b9', '#3498db',
               '#27ae60', '#2ecc71',
               '#d68910', '#f39c12']
inner_pie = ax.pie(team_budgets, labels=teams, colors=team_colors,
                    autopct='%1.0f%%', radius=0.95,
                    wedgeprops={'width': 0.35}, labeldistance=0.7,
                    textprops={'fontsize': 9})
 
ax.axis('equal')
plt.title('Organizational Budget Breakdown\nDepartments and Teams',
          fontsize=16, fontweight='bold', pad=20)
plt.tight_layout()
plt.show()

    Isso cria um gráfico de rosca em dois níveis, onde o anel interno mostra orçamentos de equipes que correspondem aos segmentos de departamento no anel externo.

    FAQ

    Como crio um gráfico de pizza básico no matplotlib?

    Use plt.pie() com uma lista de valores e rótulos opcionais. Inclua plt.axis('equal') para garantir um formato circular, e não uma elipse. A sintaxe básica é plt.pie(sizes, labels=labels) seguida de plt.show() para exibir o gráfico.

    O que o parâmetro autopct faz em gráficos de pizza do matplotlib?

    O parâmetro autopct exibe automaticamente valores percentuais em cada fatia. Use strings de formato como '%1.1f%%' para percentuais com uma casa decimal, ou '%1.0f%%' para números inteiros. Você também pode passar uma função personalizada para exibir percentuais e valores reais ao mesmo tempo.

    Como crio um gráfico de rosca (donut) no matplotlib?

    Crie um gráfico de rosca definindo o parâmetro wedgeprops com um valor de width menor que 1. Por exemplo, wedgeprops={'width': 0.4} cria uma rosca com um anel equivalente a 40% do raio. Combine isso com plt.text() para adicionar rótulos no centro vazado.

    Como destaco (explode) fatias específicas em um gráfico de pizza?

    Use o parâmetro explode com uma tupla de valores de deslocamento para cada fatia. Por exemplo, explode=(0.1, 0, 0, 0) move a primeira fatia para fora em 10% do raio, mantendo as demais no lugar. Valores maiores criam separações maiores.

    Quando devo usar gráficos de pizza em vez de gráficos de barras?

    Use gráficos de pizza ao mostrar partes de um todo com 5 ou menos categorias, em que os percentuais devem somar 100%. Use gráficos de barras ao comparar valores entre categorias, exibir mais de 5 itens ou quando comparações precisas forem mais importantes do que proporções. Gráficos de barras facilitam a comparação de segmentos de tamanho semelhante.

    Como personalizo as cores em gráficos de pizza do matplotlib?

    Passe uma lista de cores para o parâmetro colors usando nomes de cores, códigos hex ou tuplas RGB. Para cores orientadas por dados, use colormaps do matplotlib como plt.cm.Set3 combinados com np.linspace() para gerar arrays de cores. Colormaps populares incluem Set1, Set2, Set3 e Pastel1.

    Como adiciono uma legenda em um gráfico de pizza em vez de rótulos nas fatias?

    Chame plt.legend() com a lista de rótulos e posicione-a usando os parâmetros loc e bbox_to_anchor. Por exemplo, plt.legend(labels, loc='upper left', bbox_to_anchor=(1, 0, 0.5, 1)) coloca a legenda fora do gráfico, no lado direito. Use plt.tight_layout() para evitar cortes.

    Conclusão

    Os gráficos de pizza do matplotlib oferecem uma forma poderosa de visualizar dados proporcionais quando usados de maneira adequada. Este guia cobriu todo o espectro — de gráficos circulares básicos a visualizações avançadas de rosca aninhada — com exemplos práticos demonstrando rótulos, cores, fatias destacadas, exibição de percentuais e integração com DataFrames. A tabela de referência de parâmetros serve como consulta rápida para opções de personalização, enquanto os exemplos do mundo real mostram como aplicar essas técnicas à análise de orçamento, resultados de pesquisas e relatórios de participação de mercado.

    Lembre-se de que gráficos de pizza funcionam melhor com poucas categorias e proporções bem definidas, enquanto gráficos de barras são mais adequados para comparações detalhadas. Para exploração interativa durante a análise, o PyGWalker oferece uma alternativa sem código para prototipagem rápida antes de finalizar visualizações de produção. Ao combinar essas técnicas do matplotlib com escolhas de design conscientes sobre quando usar pizza versus barras, você pode criar visualizações claras e informativas que comuniquem insights de forma eficaz para qualquer público.

    📚