Skip to content

Matplotlib-Kreisdiagramm: Vollständiger Leitfaden zum Erstellen von Kreisdiagrammen in Python

Soren Atelier
Name
Soren Atelier

Updated on

Das Erstellen wirkungsvoller Datenvisualisierungen ist entscheidend, um Erkenntnisse klar zu kommunizieren. Wenn du Anteile oder Prozentsätze eines Ganzen darstellen musst, sind Kreisdiagramme ein wichtiges Werkzeug in deinem Visualisierungs-Arsenal. Dennoch haben viele Data Analysts Schwierigkeiten, professionell aussehende Kreisdiagramme zu erstellen, die wichtige Segmente korrekt hervorheben, passende Farben verwenden und Prozentsätze präzise anzeigen. Das Standard-Kreisdiagramm in matplotlib wirkt oft schlicht, liefert zu wenig Kontext und betont zentrale Datenpunkte nicht ausreichend.

Diese Visualisierungsprobleme werden noch deutlicher, wenn du vor Stakeholdern präsentierst, die Marktanteilsverteilungen, Budgetaufteilungen oder Umfrageantworten schnell erfassen müssen. Ein schlecht gestaltetes Kreisdiagramm kann eher verwirren als klären und dadurch zu Fehlinterpretationen kritischer Business-Kennzahlen führen.

Matplotlib bietet mit plt.pie() eine umfassende Funktion mit vielen Anpassungsmöglichkeiten, die einfache Kreisdiagramme in professionelle Visualisierungen verwandeln. Dieser Leitfaden zeigt, wie du Kreisdiagramme von einfachen Anteilen bis hin zu komplexen verschachtelten Darstellungen erstellst – mit praxisnahen Beispielen zu Labels, Farben, herausgezogenen Segmenten, Donut-Charts und der Integration mit pandas DataFrames für reale Data-Analysis-Workflows.

📚

    Grundlegende Syntax für Matplotlib-Kreisdiagramme

    Die Basis zum Erstellen von Kreisdiagrammen in matplotlib ist plt.pie(). Dafür brauchst du nur eine Liste oder ein Array von Werten, die die Größe jedes Segments repräsentieren.

    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()

    Damit entsteht ein einfaches Kreisdiagramm, bei dem die Segmentgrößen proportional zu den Werten in der sizes-Liste sind. Matplotlib berechnet Prozentsätze und Winkel für jedes Segment automatisch. Die Farben stammen aus dem Standard-Farbzyklus, der nicht immer zu deinen Präsentationsanforderungen passt.

    Für eine wirklich runde Darstellung (statt einer Ellipse) füge plt.axis('equal') hinzu:

    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()

    Prozentsätze mit autopct anzeigen

    Der Parameter autopct formatiert und zeigt Prozentwerte automatisch auf jedem Segment an. Dadurch wird das Diagramm informativer – ohne manuelle Berechnungen.

    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()

    Der Format-String '%1.1f%%' zeigt Prozentsätze mit einer Nachkommastelle. Das erste % startet den Format-Spezifizierer, 1.1f bedeutet eine Ziffer vor dem Dezimalpunkt und eine danach, und %% erzeugt ein wörtliches Prozentzeichen in der Ausgabe.

    Für ganzzahlige Prozente ohne Nachkommastellen verwende '%1.0f%%':

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

    Du kannst auch eine eigene Funktion an autopct übergeben, um die Prozentanzeige stärker zu kontrollieren:

    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()

    So werden sowohl der prozentuale Anteil als auch die absolute Anzahl pro Segment angezeigt.

    Benutzerdefinierte Farben und Colormaps

    Der Parameter colors akzeptiert eine Liste von Farbangaben, um den Standard-Farbzyklus von matplotlib zu überschreiben. Du kannst benannte Farben, Hex-Codes oder RGB-Tupel verwenden.

    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()

    Für eine datengetriebene Farbauswahl nutze matplotlib-Colormaps:

    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()

    Beliebte Colormaps für Kreisdiagramme sind Set1, Set2, Set3, Pastel1, Pastel2 und tab10.

    Segmente zum Hervorheben „explodieren“

    Mit dem Parameter explode kannst du bestimmte Segmente vom Zentrum absetzen, um wichtige Datenpunkte hervorzuheben. Jeder Wert im explode-Tuple gibt den radialen Versatz für das entsprechende Segment an.

    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()

    Der Wert 0.1 bewegt das erste Segment um 10 % des Radius nach außen. Du kannst auch mehrere Segmente explodieren:

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

    Schatten und Startwinkel hinzufügen

    Der Parameter shadow fügt einen Drop-Shadow für einen 3D-Effekt hinzu, während startangle das gesamte Diagramm dreht, um Segmente gezielt zu positionieren.

    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()

    startangle=90 dreht das Diagramm so, dass das erste Segment bei 90 Grad (oben im Kreis) beginnt – statt bei 0 Grad (rechte Seite). Das ist praktisch, um wichtige Segmente oben besser sichtbar zu platzieren.

    Donut-Charts erstellen

    Donut-Charts sind Kreisdiagramme mit einer Öffnung in der Mitte. Du erstellst sie mit wedgeprops, indem du die Breite (width) der Segmente setzt.

    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()

    Ein width-Wert von 0.4 erzeugt einen Ring, der 40 % des gesamten Radius ausmacht. Kleinere Werte ergeben einen dünneren Ring, Werte nahe 1.0 nähern sich einem vollen Pie-Chart an.

    Du kannst Text in der Mitte des Donut-Charts platzieren:

    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()

    Verschachtelte und konzentrische Kreisdiagramme

    Du kannst komplexere Visualisierungen erstellen, indem du mehrere Kreisdiagramme mit unterschiedlichen Radien zeichnest, um hierarchische Beziehungen in Daten darzustellen.

    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()

    So entstehen zwei konzentrische Donut-Charts, wobei der innere Ring Unterkategorien der Segmente im äußeren Ring zeigt.

    Legenden hinzufügen

    Wenn ein Diagramm viele Segmente hat oder Labels die Visualisierung überladen, kannst du Beschriftungen in eine Legende auslagern – mit 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()

    bbox_to_anchor positioniert die Legende außerhalb des Diagrammbereichs. tight_layout() passt den Plot so an, dass die Legende nicht abgeschnitten wird.

    Für benutzerdefinierte Legendeneinträge inklusive Prozentangaben:

    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()

    Referenz: Parameter für Pie Charts

    ParameterTypBeschreibungBeispiel
    xarray-likeSegmentgrößen (erforderlich)[30, 25, 20, 25]
    labelslist of strText-Labels für jedes Segment['A', 'B', 'C', 'D']
    colorslistFarben für jedes Segment['red', 'blue', 'green']
    autopctstr or functionFormat-String oder Funktion für Prozentwerte'%1.1f%%'
    explodetupleRadialer Versatz je Segment(0.1, 0, 0, 0)
    shadowboolDrop-Shadow hinzufügenTrue oder False
    startanglefloatRotationswinkel in Grad90
    radiusfloatRadius des Kreisdiagramms1.0 (Standard)
    wedgepropsdictEigenschaften der Segment-Patches{'width': 0.4}
    textpropsdictEigenschaften der Text-Labels{'fontsize': 12}
    labeldistancefloatAbstand der Labels vom Zentrum1.1 (Standard)
    pctdistancefloatAbstand des Prozenttexts vom Zentrum0.6 (Standard)
    counterclockboolDrehrichtung der SegmenteTrue (Standard)
    frameboolAchsenrahmen zeichnenFalse (Standard)

    Texteigenschaften anpassen

    Mit textprops steuerst du das Erscheinungsbild aller Textelemente im Kreisdiagramm – inklusive Labels und Prozentwerte.

    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()

    Wenn du Labels und Prozenttexte getrennt steuern möchtest, greife auf die zurückgegebenen Textobjekte zu:

    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()

    Arbeiten mit Pandas DataFrames

    In realen Analyse-Workflows arbeitest du häufig mit pandas DataFrames. Du kannst Kreisdiagramme direkt aus DataFrame-Spalten erstellen.

    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()

    Für gruppierte Daten nutze vor dem Plotten eine Aggregation in pandas:

    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()

    Kreisdiagramme in Dateien speichern

    Speichere Kreisdiagramme in verschiedene Bildformate mit plt.savefig() – vor dem Aufruf von 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()

    bbox_inches='tight' entfernt überflüssigen Weißraum um das Diagramm. dpi steuert die Auflösung für Rasterformate wie PNG.

    Praxisbeispiel: Budgetaufteilung

    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()

    Praxisbeispiel: Umfrageergebnisse

    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()

    Praxisbeispiel: Marktanteilsanalyse

    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()

    Kreisdiagramme mit anderen Visualisierungen kombinieren

    Erstelle umfassende Dashboards, indem du Kreisdiagramme mit Balkendiagrammen, Liniendiagrammen oder Tabellen kombinierst.

    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()

    Wann Pie Charts vs. Bar Charts verwenden

    Kreisdiagramme funktionieren am besten in bestimmten Szenarien – Balkendiagramme liefern jedoch oft klarere Vergleiche.

    Verwende Kreisdiagramme, wenn:

    • Teile eines Ganzen gezeigt werden sollen (Prozentsätze müssen 100 % ergeben)
    • 5 oder weniger Kategorien dargestellt werden
    • ein oder zwei dominante Segmente betont werden sollen
    • exakte Proportionen weniger wichtig sind als die grobe Zusammensetzung
    • du High-Level-Zusammenfassungen für das Management erstellst

    Verwende Balkendiagramme, wenn:

    • Werte über Kategorien hinweg verglichen werden
    • mehr als 5 Kategorien dargestellt werden
    • präzise Wertvergleiche wichtig sind
    • Werte kein sinnvolles „Ganzes“ ergeben
    • Trends über die Zeit dargestellt werden
    • Stakeholder ähnlich große Segmente direkt vergleichen müssen

    Vergleichsbeispiel:

    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()

    Das Balkendiagramm macht kleine Unterschiede zwischen Kategorien deutlich besser sichtbar als das Kreisdiagramm.

    Interaktive Kreisdiagramme mit PyGWalker

    Für explorative Datenanalyse mit interaktiven Visualisierungen transformiert PyGWalker (opens in a new tab) pandas DataFrames in interaktive, Tableau-ähnliche Oberflächen, in denen du Kreisdiagramme per Drag-and-drop erstellen kannst.

    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)

    PyGWalker ermöglicht Business-Analysten ohne Programmierkenntnisse, Kreisdiagramme und andere Visualisierungen interaktiv zu erstellen, Daten dynamisch zu filtern und Ergebnisse für Präsentationen zu exportieren. Das Tool übernimmt komplexe Aggregationen und liefert integrierte statistische Zusammenfassungen – hilfreich für schnelles Prototyping, bevor du produktive Visualisierungen mit matplotlib finalisierst.

    Erweiterte Anpassung: Kantenfarben und Linienstile

    Erzeuge eine klare visuelle Trennung zwischen Segmenten, indem du Kantenfarben und Linienstärken über wedgeprops festlegst.

    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()

    Für einen subtilen Effekt verwende weiße Kanten:

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

    Kleine Segmente und überlappende Labels handhaben

    Bei vielen kleinen Segmenten können sich Labels überlappen. Lösungen sind u. a. eine Legende, eine größere Figure oder angepasste Label-Positionierung.

    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()

    Alternativ kannst du nur Prozentwerte im Diagramm anzeigen und die Kategorienamen in eine Legende auslagern, um visuelles Rauschen zu reduzieren.

    Proportionale Donut-Charts mit mehreren Ringen erstellen

    Baue komplexe hierarchische Visualisierungen, die Aufschlüsselungen über mehrere Ebenen hinweg zeigen.

    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()

    Damit entsteht ein zweistufiges Donut-Diagramm, bei dem der innere Ring Team-Budgets zeigt, die zu den Department-Segmenten im äußeren Ring gehören.

    FAQ

    Wie erstelle ich ein einfaches Kreisdiagramm in matplotlib?

    Verwende plt.pie() mit einer Liste von Werten und optionalen Labels. Ergänze plt.axis('equal'), um eine kreisrunde Form statt einer Ellipse sicherzustellen. Die grundlegende Syntax ist plt.pie(sizes, labels=labels) gefolgt von plt.show(), um das Diagramm anzuzeigen.

    Was macht der Parameter autopct bei matplotlib-Kreisdiagrammen?

    Der Parameter autopct zeigt automatisch Prozentwerte auf jedem Segment an. Verwende Format-Strings wie '%1.1f%%' für eine Nachkommastelle oder '%1.0f%%' für ganze Zahlen. Du kannst auch eine eigene Funktion übergeben, um gleichzeitig Prozentwerte und absolute Werte darzustellen.

    Wie erstelle ich ein Donut-Chart in matplotlib?

    Erstelle ein Donut-Chart, indem du wedgeprops mit einem width-Wert kleiner als 1 setzt. Zum Beispiel erzeugt wedgeprops={'width': 0.4} einen Donut mit einem Ring von 40 % des Radius. Kombiniere das mit plt.text(), um Labels in der hohlen Mitte hinzuzufügen.

    Wie „explode“ ich bestimmte Segmente in einem Kreisdiagramm?

    Verwende den Parameter explode mit einem Tuple von Offset-Werten für jedes Segment. Beispielsweise verschiebt explode=(0.1, 0, 0, 0) das erste Segment um 10 % des Radius nach außen, während die übrigen Segmente an Ort und Stelle bleiben. Größere Werte erzeugen stärkere Abstände.

    Wann sollte ich Kreisdiagramme statt Balkendiagrammen verwenden?

    Nutze Kreisdiagramme, wenn du Teile eines Ganzen mit 5 oder weniger Kategorien darstellen willst, bei denen die Prozentsätze 100 % ergeben müssen. Nutze Balkendiagramme, wenn du Werte über Kategorien hinweg vergleichen möchtest, mehr als 5 Elemente darstellst oder präzise Wertvergleiche wichtiger sind als Proportionen. Balkendiagramme machen es leichter, ähnlich große Segmente zu vergleichen.

    Wie passe ich Farben in matplotlib-Kreisdiagrammen an?

    Übergib eine Farbliste an den Parameter colors (benannte Farben, Hex-Codes oder RGB-Tupel). Für datengetriebene Farben nutze matplotlib-Colormaps wie plt.cm.Set3 zusammen mit np.linspace(), um Farbarrays zu erzeugen. Beliebte Colormaps für Pie Charts sind Set1, Set2, Set3 und Pastel1.

    Wie füge ich eine Legende zu einem Kreisdiagramm hinzu statt Segment-Labels?

    Rufe plt.legend() mit der Labels-Liste auf und positioniere sie mit loc und bbox_to_anchor. Zum Beispiel platziert plt.legend(labels, loc='upper left', bbox_to_anchor=(1, 0, 0.5, 1)) die Legende außerhalb des Diagramms auf der rechten Seite. Verwende plt.tight_layout(), um Abschneiden zu vermeiden.

    Fazit

    Matplotlib-Kreisdiagramme sind eine leistungsstarke Möglichkeit, proportionale Daten zu visualisieren – wenn sie passend eingesetzt werden. Dieser Leitfaden hat das gesamte Spektrum abgedeckt: von einfachen Kreisdiagrammen bis zu fortgeschrittenen verschachtelten Donut-Visualisierungen, mit praxisnahen Beispielen zu Labels, Farben, herausgezogenen Segmenten, Prozentanzeigen und der Integration mit DataFrames. Die Parameter-Referenztabelle dient als schneller Nachschlagepunkt für Anpassungsoptionen, und die Praxisbeispiele zeigen, wie du diese Techniken auf Budgetanalysen, Umfrageergebnisse und Marktanteils-Reporting anwendest.

    Behalte im Kopf: Kreisdiagramme funktionieren am besten mit wenigen Kategorien und klaren Anteilen, während Balkendiagramme detaillierte Vergleiche besser unterstützen. Für interaktive Exploration während der Analyse bietet PyGWalker eine codefreie Alternative für schnelles Prototyping, bevor du produktive Visualisierungen finalisierst. Wenn du diese matplotlib-Techniken mit durchdachten Designentscheidungen (Pie vs. Bar) kombinierst, kannst du klare, informative Visualisierungen erstellen, die Insights für jedes Publikum effektiv vermitteln.

    📚