So erstellst du ein Gantt‑Diagramm in Python mit Matplotlib

In dieser Schritt-für-Schritt-Anleitung schauen wir uns an, was ein Gantt‑Diagramm ist, warum und wann sich solche Visualisierungen lohnen, wie du in Python mit matplotlib ein Gantt‑Diagramm erstellst und wie du es weiter anpasst. Unterwegs bauen wir mehrere Gantt‑Diagramm‑Beispiele in matplotlib.

Was ist ein Gantt‑Diagramm und warum ist es nützlich?

Ein Gantt‑Diagramm ist eine spezielle Form eines Balkendiagramms, mit dem sich ein vollständiger Plan für Projektplanung und ‑steuerung abbilden lässt. Üblicherweise zeigt es Aufgabenbezeichnungen, Start- und Enddaten, die zugeordneten Teams, den Fertigstellungsgrad in Prozent oder als Bruchteil, die Performance je Team sowie wichtige Meilensteine.

Die Aufgabennamen stehen entlang der y‑Achse und sind meist nach Startdatum chronologisch von oben nach unten sortiert. Die x‑Achse zeigt Zeiträume; die Breite jedes Balkens entspricht der Dauer der jeweiligen Aufgabe.

Da ein Gantt‑Diagramm im Kern ein horizontales Balkendiagramm ist, können wir es in vielen Python‑Bibliotheken für Datenvisualisierung erstellen, etwa in matplotlib, Plotly, Bokeh und Altair. In diesem Tutorial konzentrieren wir uns auf die Erstellung mit der populärsten Bibliothek – matplotlib.

Wenn du alternative Wege zur Erstellung eines Gantt‑Diagramms und anderer Diagrammtypen in Python kennenlernen möchtest, schau dir den Kurs Introduction to Data Visualization with Plotly in Python an. Möchtest du deine matplotlib‑Kompetenzen auffrischen oder ausbauen, helfen dir diese Kurse: Introduction to Data Visualization with Matplotlib und Python for MATLAB Users.

So erstellst du ein Gantt‑Diagramm in Python mit Matplotlib

Mit barh()

Starten wir mit einem einfachen Gantt‑Diagramm in matplotlib über die Methode barh() von matplotlib.pyplot.

Zuerst laden wir die benötigten Bibliotheken:

import pandas as pd
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import datetime as dtBereitgestellt von

Als Nächstes erstellen wir Beispieldaten:

df = pd.DataFrame({'task': ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L'],
                  'team': ['R&D', 'Accounting', 'Sales', 'Sales', 'IT', 'R&D', 'IT', 'Sales', 'Accounting', 'Accounting', 'Sales', 'IT'],
                  'start': pd.to_datetime(['20 Oct 2022', '24 Oct 2022', '26 Oct 2022', '31 Oct 2022', '3 Nov 2022', '7 Nov 2022', '10 Nov 2022', '14 Nov 2022', '18 Nov 2022', '23 Nov 2022', '28 Nov 2022', '30 Nov 2022']),
                  'end': pd.to_datetime(['31 Oct 2022', '28 Oct 2022', '31 Oct 2022', '8 Nov 2022', '9 Nov 2022', '18 Nov 2022', '17 Nov 2022', '22 Nov 2022', '23 Nov 2022', '1 Dec 2022', '5 Dec 2022', '5 Dec 2022']),
                  'completion_frac': [1, 1, 1, 1, 1, 0.95, 0.7, 0.35, 0.1, 0, 0, 0]})
print(df)Bereitgestellt von

Ausgabe:

  task        team      start        end  completion_frac
0     A         R&D 2022-10-20 2022-10-31             1.00
1     B  Accounting 2022-10-24 2022-10-28             1.00
2     C       Sales 2022-10-26 2022-10-31             1.00
3     D       Sales 2022-10-31 2022-11-08             1.00
4     E          IT 2022-11-03 2022-11-09             1.00
5     F         R&D 2022-11-07 2022-11-18             0.95
6     G          IT 2022-11-10 2022-11-17             0.70
7     H       Sales 2022-11-14 2022-11-22             0.35
8     I  Accounting 2022-11-18 2022-11-23             0.10
9     J  Accounting 2022-11-23 2022-12-01             0.00
10    K       Sales 2022-11-28 2022-12-05             0.00
11    L          IT 2022-11-30 2022-12-05             0.00Bereitgestellt von

Um das Gantt‑Diagramm einfacher zu erstellen, berechnen wir vier zusätzliche Spalten, die Folgendes abbilden:

1. Wie viele Tage seit Projektbeginn bis zum Startdatum jeder Aufgabe vergangen sind bzw. vergehen würden:

df['days_to_start'] = (df['start'] - df['start'].min()).dt.daysBereitgestellt von

1. Wie viele Tage seit Projektbeginn bis zum Enddatum jeder Aufgabe vergangen sind bzw. vergehen würden:

df['days_to_end'] = (df['end'] - df['start'].min()).dt.daysBereitgestellt von

1. Die Dauer jeder Aufgabe, inklusive Start- und Enddatum:

df['task_duration'] = df['days_to_end'] - df['days_to_start'] + 1  # auch das Enddatum einschließenBereitgestellt von

1. Den Fertigstellungsstatus jeder Aufgabe, von einem Bruchteil in einen Anteil der zugewiesenen Tage übersetzt:

df['completion_days'] = df['completion_frac'] * df['task_duration']Bereitgestellt von

Prüfen wir das Ergebnis:

print(df)Bereitgestellt von

Ausgabe:

  task        team      start        end  completion_frac  days_to_start  \
0     A         R&D 2022-10-20 2022-10-31             1.00              0  
1     B  Accounting 2022-10-24 2022-10-28             1.00              4  
2     C       Sales 2022-10-26 2022-10-31             1.00              6  
3     D       Sales 2022-10-31 2022-11-08             1.00             11  
4     E          IT 2022-11-03 2022-11-09             1.00             14  
5     F         R&D 2022-11-07 2022-11-18             0.95             18  
6     G          IT 2022-11-10 2022-11-17             0.70             21  
7     H       Sales 2022-11-14 2022-11-22             0.35             25  
8     I  Accounting 2022-11-18 2022-11-23             0.10             29  
9     J  Accounting 2022-11-23 2022-12-01             0.00             34  
10    K       Sales 2022-11-28 2022-12-05             0.00             39  
11    L          IT 2022-11-30 2022-12-05             0.00             41  

    days_to_end  task_duration  completion_days 
0            11             12            12.00 
1             8              5             5.00 
2            11              6             6.00 
3            19              9             9.00 
4            20              7             7.00 
5            29             12            11.40 
6            28              8             5.60 
7            33              9             3.15 
8            34              6             0.60 
9            42              9             0.00 
10           46              8             0.00 
11           46              6             0.00 Bereitgestellt von

Jetzt können wir ein grundlegendes Gantt‑Diagramm in matplotlib erzeugen:

plt.barh(y=df['task'], width=df['task_duration'], left=df['days_to_start'])
plt.show()Bereitgestellt von

Ausgabe:

Diese Grafik braucht noch einige Anpassungen, damit wir maximalen Informationsgehalt herausholen:

• Aussagekräftigen Titel und x‑Beschriftungen (Daten) hinzufügen
• y‑Achse invertieren, damit die Aufgaben chronologisch von oben nach unten sortiert sind
• Raster hinzufügen
• Aufgaben nach Team einfärben
• Legende anzeigen
• Fertigstellungsstatus ergänzen

Diese Verfeinerungen setzen wir gleich um. Zuvor schauen wir uns jedoch eine Alternative für das grundlegende Diagramm an.

Verwendung von broken_barh()

Wenn einige Aufgaben zwei oder mehr Teilaufgaben über die Zeit verteilt enthalten, sollten wir die Methode broken_barh() nutzen.

Um Beispielsdaten für diesen Ansatz zu haben, machen wir Folgendes:

1. Wir nehmen aus dem ursprünglichen DataFrame nur die Aufgaben des Sales‑Teams (die Spalte completion_frac ignorieren wir zunächst).
2. Wir benennen die Spalten start und end der Einfachheit halber in start_1 und end_1 um.
3. Wir fügen einigen Aufgaben weitere Teilaufgaben hinzu.
4. Für jede Teilaufgabe berechnen wir drei Spalten wie oben beschrieben, nämlich:
• Wie viele Tage seit Gesamtprojektstart bis zum Startdatum der Teilaufgabe vergehen.
• Wie viele Tage seit Gesamtprojektstart bis zum Enddatum der Teilaufgabe vergehen.
• Die Dauer der Teilaufgabe, inklusive Start- und Enddatum.

# 1
df2 = df[df['team']=='Sales'][['task', 'team', 'start', 'end']]

# 2
df2.rename(columns={'start': 'start_1', 'end': 'end_1'}, inplace=True)
df2.reset_index(drop=True, inplace=True)

# 3
df2['start_2'] = pd.to_datetime([None, '10 Nov 2022', '25 Nov 2022', None])
df2['end_2'] = pd.to_datetime([None, '14 Nov 2022', '28 Nov 2022', None])
df2['start_3'] = pd.to_datetime([None, None, '1 Dec 2022', None])
df2['end_3'] = pd.to_datetime([None, None, '5 Dec 2022', None])

# 4
for i in [1, 2, 3]:
    suffix = '_' + str(i)
    df2['days_to_start' + suffix] = (df2['start' + suffix] - df2['start_1'].min()).dt.days
    df2['days_to_end' + suffix] = (df2['end' + suffix] - df2['start_1'].min()).dt.days
    df2['task_duration' + suffix] = df2['days_to_end' + suffix] - df2['days_to_start' + suffix] + 1


print(df2)Bereitgestellt von

Ausgabe:

task   team    start_1      end_1    start_2      end_2    start_3  \
0    C  Sales 2022-10-26 2022-10-31        NaT        NaT        NaT  
1    D  Sales 2022-10-31 2022-11-08 2022-11-10 2022-11-14        NaT  
2    H  Sales 2022-11-14 2022-11-22 2022-11-25 2022-11-28 2022-12-01  
3    K  Sales 2022-11-28 2022-12-05        NaT        NaT        NaT  

      end_3  days_to_start_1  days_to_end_1  task_duration_1  \
0        NaT                0              5                6  
1        NaT                5             13                9  
2 2022-12-05               19             27                9  
3        NaT               33             40                8  

  days_to_start_2  days_to_end_2  task_duration_2  days_to_start_3  \
0              NaN            NaN              NaN              NaN  
1             15.0           19.0              5.0              NaN  
2             30.0           33.0              4.0             36.0  
3              NaN            NaN              NaN              NaN  

  days_to_end_3  task_duration_3 
0            NaN              NaN 
1            NaN              NaN 
2           40.0              5.0 
3            NaN              NaN Bereitgestellt von

Jetzt hat Aufgabe D zwei Teilaufgaben, Aufgabe H drei, und die Aufgaben C und K jeweils eine. Für D und H verwenden wir daher die Methode broken_barh(). Da ihre Syntax etwas weniger intuitiv ist als bei barh(), schauen wir uns die wichtigsten Parameter und ihre Form an. Pflichtparameter von broken_barh() sind:

• xranges – eine Sequenz von Tupeln im Format (xmin, xwidth) für Start und Ausdehnung jedes Balkens. Jeder Balken steht hier für eine Teilaufgabe. Dieser Parameter zeigt also Startdatum und Dauer jeder Teilaufgabe.
• yrange – ein Tupel im Format (ymin, yheight) für y‑Position und Höhe jedes Balkens.

Jetzt plotten wir unser „gebrochenes“ Gantt‑Diagramm. Der Ablauf:

1. Figure mit Subplots erstellen.
2. Über die Zeilen des DataFrames iterieren und prüfen, ob die Aufgabe eine, zwei oder drei Teilaufgaben hat. Dann je nach Fall:
• Eine Teilaufgabe: Einen Balken mit barh() plotten, wie zuvor.
• Zwei Teilaufgaben: Zwei Balken mit broken_barh() plotten.
• Drei Teilaufgaben: Drei Balken mit broken_barh() plotten.
3. Grundlegende Anpassungen vornehmen: y‑Ticks setzen und beschriften.

# 1
fig, ax = plt.subplots()

# 2
for index, row in df2.iterrows():
    if row['start_2'] is None:
        ax.barh(y=df2['task'], width=df2['task_duration_1'], left=df2['days_to_start_1'])
    elif row['start_2'] is not None and row['start_3'] is None:
        ax.broken_barh(xranges=[(row['days_to_start_1'], row['task_duration_1']), (row['days_to_start_2'], row['task_duration_2'])], yrange=(index + 1, 0.5))
    else:
        ax.broken_barh(xranges=[(row['days_to_start_1'], row['task_duration_1']), (row['days_to_start_2'], row['task_duration_2']), (row['days_to_start_3'], row['task_duration_3'])], yrange=(index + 1, 0.5))

# 3
ax.set_yticks([1.25, 2.25, 3.25, 4.25])
ax.set_yticklabels(df2['task'])

plt.show()Bereitgestellt von

Ausgabe:

Im obigen Code könnten wir broken_barh() auch für Aufgaben mit nur einer Teilaufgabe verwenden. Dazu ersetzen wir diese Zeile:

ax.barh(y=df2['task'], width=df2['task_duration_1'], left=df2['days_to_start_1'])Bereitgestellt von

durch diese:

ax.broken_barh(xranges=[(row['days_to_start_1'], row['task_duration_1'])], yrange=(index + 1, 0.5))Bereitgestellt von

So wird der Code einheitlicher und besser lesbar.

So passt du ein Gantt‑Diagramm in Matplotlib an

Zurück zu unserem ersten DataFrame:

print(df)Bereitgestellt von

Ausgabe:

  task        team      start        end  completion_frac  days_to_start  \
0     A         R&D 2022-10-20 2022-10-31             1.00              0  
1     B  Accounting 2022-10-24 2022-10-28             1.00              4  
2     C       Sales 2022-10-26 2022-10-31             1.00              6  
3     D       Sales 2022-10-31 2022-11-08             1.00             11  
4     E          IT 2022-11-03 2022-11-09             1.00             14  
5     F         R&D 2022-11-07 2022-11-18             0.95             18  
6     G          IT 2022-11-10 2022-11-17             0.70             21  
7     H       Sales 2022-11-14 2022-11-22             0.35             25  
8     I  Accounting 2022-11-18 2022-11-23             0.10             29  
9     J  Accounting 2022-11-23 2022-12-01             0.00             34  
10    K       Sales 2022-11-28 2022-12-05             0.00             39  
11    L          IT 2022-11-30 2022-12-05             0.00             41  

    days_to_end  task_duration  completion_days 
0            11             12            12.00 
1             8              5             5.00 
2            11              6             6.00 
3            19              9             9.00 
4            20              7             7.00 
5            29             12            11.40 
6            28              8             5.60 
7            33              9             3.15 
8            34              6             0.60 
9            42              9             0.00 
10           46              8             0.00 
11           46              6             0.00 Bereitgestellt von

und unserem ersten Gantt‑Diagramm:

plt.barh(y=df['task'], width=df['task_duration'], left=df['days_to_start'])
plt.show()Bereitgestellt von

Ausgabe:

Jetzt wollen wir das Diagramm gezielt anpassen, um mehr Erkenntnisse herauszuholen.

Wenn du tiefer in das Anpassen von Plots mit matplotlib einsteigen willst, empfehlen wir: Matplotlib Tutorial: Python Plotting und das Matplotlib Cheat Sheet: Plotting in Python.

Grundlegende Anpassungen am Gantt‑Diagramm

Dazu zählen:

• Einen Plot‑Titel hinzufügen
• Achsen anpassen und formatieren
• Ein Raster hinzufügen

Plot‑Titel hinzufügen

Ein aussagekräftiger Titel ist Pflicht – auch beim Gantt‑Diagramm. Nehmen wir an, unser Projekt heißt Project X:

plt.barh(y=df['task'], width=df['task_duration'], left=df['days_to_start'])
plt.title('Project Management Schedule of Project X', fontsize=15)
plt.show()Bereitgestellt von

Ausgabe:

Achsen anpassen und formatieren und Raster hinzufügen

Aufbauend auf dem vorherigen Code führen wir Folgendes aus:

1. Figure mit Subplots erstellen, um mit dem ax‑Objekt zu arbeiten.
2. y‑Achse invertieren, damit die Aufgaben chronologisch von oben nach unten erscheinen.
3. Geeignete Positionen für die x‑Ticks bestimmen.
• Angenommen, wir möchten x‑Ticks jeweils montags setzen, wobei Project X an einem Donnerstag startete.
• Wir verwenden nur Major Ticks, um das Diagramm nicht zu überladen.
4. Passende x‑Tick‑Labels samt Format festlegen.
• Wieder bedenken wir: Start war an einem Donnerstag, gelabelt werden nur Montage.
• Da Project X vollständig in 2022 liegt, müssen wir das Jahr nicht bei jedem Datum angeben.
• Wichtig: Anzahl der x‑Ticks muss der Anzahl der Labels entsprechen.
5. x‑Ticks und Labels setzen.
6. Vertikales Raster hinzufügen.

# 1
fig, ax = plt.subplots()

plt.barh(y=df['task'], width=df['task_duration'], left=df['days_to_start'] + 1)
plt.title('Project Management Schedule of Project X', fontsize=15)

# 2
plt.gca().invert_yaxis()

# 3
xticks = np.arange(5, df['days_to_end'].max() + 2, 7)

# 4
xticklabels = pd.date_range(start=df['start'].min() + dt.timedelta(days=4), end=df['end'].max()).strftime("%d/%m")
# 5
ax.set_xticks(xticks)
ax.set_xticklabels(xticklabels[::7])

# 6
ax.xaxis.grid(True, alpha=0.5)

plt.show()Bereitgestellt von

Ausgabe:

Wenn du mehr Übung in Python brauchst, um Code leichter zu lesen und zu schreiben, ist unser Kurs Intermediate Python ein guter Startpunkt.

Aufgaben nach Team einfärben

Jetzt färben wir jeden Balken (jede Aufgabe) entsprechend dem zuständigen Team ein. Dazu gehen wir so vor:

1. Ein Dictionary erstellen, dessen Keys die Teamnamen sind und dessen Values Basisfarben aus matplotlib sind.
2. Figure mit Subplots erstellen.
3. Über die Zeilen des DataFrames iterieren, für jede Zeile einen Balken erzeugen und mit der Teamfarbe einfärben.
4. Alle zuvor verwendeten Grundanpassungen ergänzen.

# 1
team_colors = {'R&D': 'c', 'Accounting': 'm', 'Sales': 'y', 'IT': 'b'}

# 2
fig, ax = plt.subplots()

# 3
for index, row in df.iterrows():
    plt.barh(y=row['task'], width=row['task_duration'], left=row['days_to_start'] + 1, color=team_colors[row['team']])

# 4
plt.title('Project Management Schedule of Project X', fontsize=15)
plt.gca().invert_yaxis()
ax.set_xticks(xticks)
ax.set_xticklabels(xticklabels[::7])
ax.xaxis.grid(True, alpha=0.5)
plt.show()Bereitgestellt von

Ausgabe:

Eine Legende hinzufügen

In der obigen Version fehlt noch eine Legende, die zeigt, welche Farbe zu welchem Team gehört. Dafür erstellen wir Patches – 2D‑Objekte in matplotlib mit vordefinierter Füllfarbe. Wir nutzen die Klasse matplotlib.patches.Patch und erzeugen eine Liste von Patches, je Team eines, passend eingefärbt:

patches = []
for team in team_colors:
    patches.append(matplotlib.patches.Patch(color=team_colors[team]))Bereitgestellt von

Jetzt fügen wir die Legende dem Chart hinzu:

fig, ax = plt.subplots()
for index, row in df.iterrows():
    plt.barh(y=row['task'], width=row['task_duration'], left=row['days_to_start'] + 1, color=team_colors[row['team']])
plt.title('Project Management Schedule of Project X', fontsize=15)
plt.gca().invert_yaxis()
ax.set_xticks(xticks)
ax.set_xticklabels(xticklabels[::7])
ax.xaxis.grid(True, alpha=0.5)

# Legende hinzufügen
ax.legend(handles=patches, labels=team_colors.keys(), fontsize=11)

plt.show()Bereitgestellt von

Ausgabe:

So ist das Gantt‑Diagramm deutlich aussagekräftiger.

Weitere Techniken, um Ästhetik und Lesbarkeit von Plots zu verbessern, findest du im Kurs Improving Your Data Visualizations in Python.

Fertigstellungsstatus hinzufügen

Bisher haben wir die zu Beginn berechnete Spalte completion_days noch nicht genutzt. Jetzt verwenden wir sie, um den Status jeder Aufgabe sichtbar zu machen.

Technisch fügen wir zu jedem bestehenden Balken einen zweiten darüber liegenden hinzu. Der untere Balken zeigt die gesamte, zugewiesene Dauer der Aufgabe in Tagen, der obere den aktuellen Fertigstellungsstand in Tagen.

Beide Balken haben pro Aufgabe dieselbe Teamfarbe, aber der untere ist heller als der obere, damit der Unterschied klar erkennbar ist.

Anders gesagt: Wenn ein Team bei einer Aufgabe über Plan liegt, wirken beide Balken zusammen so, als hätte das Team bereits mehr Tage daran gearbeitet als vorgesehen (die Aufgabe wird voraussichtlich vor der Deadline fertig).

Umgekehrt zeigt eine Unterperformance, dass weniger Tage als geplant aufgelaufen sind (die Aufgabe wird voraussichtlich nach der Deadline fertig).

fig, ax = plt.subplots()

for index, row in df.iterrows():

    # Unterer Balken – Gesamtdauer der Aufgabe
    plt.barh(y=row['task'], width=row['task_duration'], left=row['days_to_start'] + 1, color=team_colors[row['team']], alpha=0.4)

    # Oberer Balken – Fertigstellungsstatus
    plt.barh(y=row['task'], width=row['completion_days'], left=row['days_to_start'] + 1, color=team_colors[row['team']])

plt.title('Project Management Schedule of Project X', fontsize=15)
plt.gca().invert_yaxis()
ax.set_xticks(xticks)
ax.set_xticklabels(xticklabels[::7])
ax.xaxis.grid(True, alpha=0.5)
ax.legend(handles=patches, labels=team_colors.keys(), fontsize=11)
plt.show()Bereitgestellt von

Ausgabe:

Wir sehen: Die Teams kommen unterschiedlich schnell voran – typisch für reale Projekte. Um noch mehr Kontext zu bekommen, nehmen wir an, heute ist der 17. November 2022, und markieren dieses Datum im Diagramm:

fig, ax = plt.subplots()
for index, row in df.iterrows():
    plt.barh(y=row['task'], width=row['task_duration'], left=row['days_to_start'] + 1, color=team_colors[row['team']], alpha=0.4)
    plt.barh(y=row['task'], width=row['completion_days'], left=row['days_to_start'] + 1, color=team_colors[row['team']])

plt.title('Project Management Schedule of Project X', fontsize=15)
plt.gca().invert_yaxis()
ax.set_xticks(xticks)
ax.set_xticklabels(xticklabels[::7])
ax.xaxis.grid(True, alpha=0.5)
ax.legend(handles=patches, labels=team_colors.keys(), fontsize=11)

# Aktuelles Datum im Diagramm markieren
ax.axvline(x=29, color='r', linestyle='dashed')
ax.text(x=29.5, y=11.5, s='17/11', color='r')

plt.show()Bereitgestellt von

Ausgabe:

Daraus lassen sich folgende Beobachtungen zum Status von Project X ableiten:

• R&D liegt bei Aufgabe F über Plan und wird sie voraussichtlich vor der Deadline abschließen.
• IT liegt bei Aufgabe G in Verzug und braucht wahrscheinlich Unterstützung.
• Sales arbeitet bei Aufgabe H im Plan.
• Accounting hat Aufgabe I früher als geplant gestartet.

Solche Erkenntnisse helfen Teamleads und Projektleitung, den Zeitplan anzupassen und Ressourcen rechtzeitig umzuverteilen, um Verzögerungen bei Deliverables zu vermeiden.

Weitere mögliche Anpassungen

Wir können unser Gantt‑Diagramm in matplotlib weiter anreichern, zum Beispiel:

• Prozentuale Fertigstellung direkt auf den Balken anzeigen.
• Einige Aufgaben in Teilaufgaben aufspalten (technisch bereits oben gezeigt).
• Abhängige Aufgaben annotieren.
• Wichtige Meilensteine und Deadlines markieren.
• Wochenenden und Feiertage hervorheben.
• Balken nach Team oder Aufgabentyp sortieren.
• Minor Ticks auf der x‑Achse für mehr Detailtiefe hinzufügen.
• Formatierung und Layout insgesamt verfeinern.

Wichtig ist jedoch, das Diagramm übersichtlich zu halten. Wie bei jeder Visualisierung gilt es, ein gutes Gleichgewicht zwischen Informationsdichte, Lesbarkeit des Plots und Verständlichkeit des Codes zu finden.

Erstelle dein eigenes Gantt‑Diagramm in Python mit Matplotlib

Zusammengefasst haben wir in diesem Tutorial behandelt:

• was ein Gantt‑Diagramm ist
• welche Informationen es zeigt
• wann es eingesetzt wird
• verschiedene Wege und Feinheiten, Gantt‑Diagramme mit matplotlib zu erstellen
• wie du in Python mit matplotlib ein Gantt‑Diagramm erstellst
• wie du es weiter anpasst, um mehr Insights zu gewinnen
• wie du das Endergebnis interpretierst.

Außerdem haben wir uns verschiedene Gantt‑Beispiele und den Schritt‑für‑Schritt‑Prozess zu ihrer Erstellung angesehen.

Für einen integrierten Lernpfad rund um überzeugende und informative Diagramme in Python, wirf einen Blick auf unseren Data Visualization with Python Skill Track.