Een Gantt-diagram maken in Python met Matplotlib

In deze stapsgewijze gids bespreken we wat een Gantt-diagram is, waarom en wanneer zulke visualisaties nuttig zijn, hoe je een Gantt-diagram maakt in Python met matplotlib, en hoe je het verder kunt aanpassen. Onderweg bouwen we enkele voorbeelden van Gantt-diagrammen in matplotlib.

Wat is een Gantt-diagram en waarom is het nuttig?

Een Gantt-diagram is een soort staafdiagram dat wordt gebruikt om een volledige projectplanning en -beheer te illustreren. Het toont doorgaans zaken als taken in een project, hun begin- en einddatums, de teams waaraan die taken zijn toegewezen, de voortgang van taken in percentage of fractie, prestaties per team en belangrijke mijlpalen van het project.

De taaknamen staan langs de y-as van het Gantt-diagram, meestal gesorteerd op begindatum in chronologische volgorde van boven naar beneden. De x-as staat voor de tijdsperioden, waarbij de breedte van elke balk overeenkomt met de duur van de uitvoering van elke taak.

Omdat een Gantt-diagram in essentie een specifieke vorm van een horizontaal staafdiagram is, kunnen we het maken in veel Python-bibliotheken voor datavisualisatie, waaronder matplotlib, Plotly, Bokeh en Altair. In deze tutorial focussen we op het maken van Gantt-diagrammen in de populairste daarvan – matplotlib.

Wil je alternatieve manieren verkennen om een Gantt-diagram en andere soorten grafieken in Python te maken? Bekijk dan de cursus Introduction to Data Visualization with Plotly in Python. Als je je matplotlib-vaardigheden wilt opfrissen of verder ontwikkelen, zijn deze cursussen nuttig: Introduction to Data Visualization with Matplotlib en Python for MATLAB Users.

Hoe maak je een Gantt-diagram in Python met Matplotlib

Met barh()

Laten we beginnen met het bouwen van een basis-Gantt-diagram in matplotlib met de barh() -methode van matplotlib.pyplot.

Eerst downloaden we de benodigde bibliotheken:

import pandas as pd
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import datetime as dtMogelijk gemaakt door

De volgende stap is het creëren van voorbeelddata om mee te werken:

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)Mogelijk gemaakt door

Uitvoer:

  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.00Mogelijk gemaakt door

Om het bouwen van een Gantt-diagram voor deze data te vergemakkelijken, moeten we vier extra kolommen berekenen die de volgende informatie weergeven:

1. Hoeveel dagen zijn verstreken/gaan verstrijken vanaf de start van het totale project tot de begindatum van elke taak:

df['days_to_start'] = (df['start'] - df['start'].min()).dt.daysMogelijk gemaakt door

1. Hoeveel dagen zijn verstreken/gaan verstrijken vanaf de start van het totale project tot de einddatum van elke taak:

df['days_to_end'] = (df['end'] - df['start'].min()).dt.daysMogelijk gemaakt door

1. De duur van elke taak, inclusief zowel de begin- als de einddatum:

df['task_duration'] = df['days_to_end'] - df['days_to_start'] + 1  # to include also the end dateMogelijk gemaakt door

1. De voortgang van elke taak vertaald van een fractie naar een aantal dagen dat aan die taak is besteed:

df['completion_days'] = df['completion_frac'] * df['task_duration']Mogelijk gemaakt door

Laten we controleren wat we hebben verkregen:

print(df)Mogelijk gemaakt door

Uitvoer:

  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 Mogelijk gemaakt door

Nu zijn we klaar om een basis-Gantt-diagram in matplotlib te genereren:

plt.barh(y=df['task'], width=df['task_duration'], left=df['days_to_start'])
plt.show()Mogelijk gemaakt door

Uitvoer:

Bovenstaande grafiek heeft de nodige aanpassingen nodig om er maximaal informatie uit te halen:

• Een zinvolle titel en x-labels (datums) toevoegen
• De y-as omkeren zodat alle taken in chronologische volgorde van boven naar beneden staan
• Een raster toevoegen
• Taken kleuren per team
• Een legenda tonen
• De voortgang van taken toevoegen

We gaan al deze verfijningen zo implementeren. Maar eerst bekijken we hoe je een basis-Gantt-diagram maakt.

Met broken_barh()

Wanneer sommige taken twee of meer subtaken bevatten die over een periode zijn verspreid, moeten we een andere matplotlib-methode gebruiken – broken_barh().

Om voorbeelddata te hebben om deze aanpak op te proberen, doen we het volgende:

1. Neem uit onze initiële dataframe alleen de taken die zijn toegewezen aan het Sales-team (negeer voor nu de kolom completion_frac).
2. Hernoem de kolommen start en end naar respectievelijk start_1 en end_1 (voor het gemak).
3. Voeg meer subtaken toe aan sommige van de beschikbare taken.
4. Bereken voor elke subtaak de drie kolommen zoals hierboven getoond die de volgende informatie weergeven:
• Hoeveel dagen zijn verstreken/gaan verstrijken vanaf de start van het totale project tot de begindatum van elke subtaak.
• Hoeveel dagen zijn verstreken/gaan verstrijken vanaf de start van het totale project tot de einddatum van elke subtaak.
• De duur van elke subtaak, inclusief zowel de begin- als de einddatum.

# 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)Mogelijk gemaakt door

Uitvoer:

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 Mogelijk gemaakt door

Let op: taak D heeft nu twee subtaken, taak H heeft drie subtaken en de taken C en K hebben elk één subtaak. Daarom passen we de methode broken_barh() toe op de taken D en H. Omdat de syntaxis van deze methode wat minder intuïtief is dan die van barh(), bekijken we de belangrijkste parameters en hun formaat. De verplichte parameters van de methode broken_barh() zijn:

• xranges – een reeks tuples met het formaat (xmin, xwidth) om het begin en de uitbreiding van elke balk aan te geven. Hier staat elke balk voor een subtaak. Deze parameter toont dus de begindatum en de duur van elke subtaak.
• yrange – een tuple met het formaat (ymin, yheight) om de y-positie en de hoogte van elke balk aan te geven.

Laten we nu ons "gebroken" Gantt-diagram plotten. Het stappenplan is als volgt:

1. Maak een figuur met subplots.
2. Loop door de rijen van de dataframe en controleer of de taak één, twee of drie subtaken heeft. Doe vervolgens het volgende:
• Eén subtaak: plot een balk met de methode barh() zoals we eerder deden.
• Twee subtaken: plot twee balken met de methode broken_barh().
• Drie subtaken: plot drie balken met de methode broken_barh().
3. Voeg basisaanpassingen toe: stel de ticks van de y-as in en label ze.

# 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()Mogelijk gemaakt door

Uitvoer:

In bovenstaande code kunnen we de methode broken_barh() ook gebruiken om de balken te plotten voor taken met slechts één subtaak. In dat geval vervangen we deze regel code:

ax.barh(y=df2['task'], width=df2['task_duration_1'], left=df2['days_to_start_1'])Mogelijk gemaakt door

door deze:

ax.broken_barh(xranges=[(row['days_to_start_1'], row['task_duration_1'])], yrange=(index + 1, 0.5))Mogelijk gemaakt door

Deze aanpak maakt onze code ook consistenter en beter leesbaar.

Hoe pas je een Gantt-diagram in Matplotlib aan

Laten we teruggaan naar onze initiële dataframe:

print(df)Mogelijk gemaakt door

Uitvoer:

  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 Mogelijk gemaakt door

en ons eerste Gantt-diagram:

plt.barh(y=df['task'], width=df['task_duration'], left=df['days_to_start'])
plt.show()Mogelijk gemaakt door

Uitvoer:

We willen aan deze grafiek wat aanpassingen toevoegen om hem informatiever te maken.

Wil je dieper duiken in het aanpassen van grafieken met matplotlib? Bekijk dan: Matplotlib Tutorial: Python Plotting en Matplotlib Cheat Sheet: Plotting in Python.

Basisaanpassingen voor een Gantt-diagram

Deze omvatten:

• Een titel toevoegen
• De assen afstellen en aanpassen
• Een raster toevoegen

Een titel toevoegen

Een zinvolle titel is essentieel voor elke grafiek, ook voor een Gantt-diagram. Laten we aannemen dat ons project Project X heet:

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()Mogelijk gemaakt door

Uitvoer:

De assen afstellen en aanpassen en een raster toevoegen

In deze stap bouwen we voort op de vorige code en voeren we het volgende uit:

1. Maak een figuur met subplots zodat we met het ax-object kunnen werken.
2. Keer de y-as om zodat alle taken in chronologische volgorde van boven naar beneden staan.
3. Bepaal de optimale posities van de x-ticks.
• Stel dat we de x-ticks op elke maandag willen plaatsen, met in gedachten dat Project X op donderdag begon.
• We kiezen alleen voor hoofd-ticks om de grafiek niet te laten vervuilen.
4. Bepaal de juiste x-ticklabels en een passend formaat ervoor.
• Wederom houden we in gedachten dat Project X op donderdag begon en we alleen maandagen hoeven te labelen.
• Omdat Project X volledig in 2022 valt, hoeven we het jaartal niet voor elke datum te vermelden.
• Het is belangrijk dat het aantal x-ticks gelijk is aan het aantal x-ticklabels.
5. Voeg de x-ticks en x-ticklabels toe.
6. Voeg een verticale rasterlijn toe.

# 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()Mogelijk gemaakt door

Uitvoer:

Heb je meer oefening in Python nodig om vlot code te lezen en schrijven? Onze cursus Intermediate Python is een goed startpunt.

Taken kleuren per team

Laten we nu elke balk (die een specifieke taak vertegenwoordigt) kleurcoderen volgens het team waaraan deze taak is toegewezen. Hiervoor doen we het volgende:

1. Maak een woordenboek met de teamnamen als sleutels en basiskleuren van matplotlib als waarden.
2. Maak een figuur met subplots.
3. Loop door de rijen van de dataframe, maak voor elke rij een balk en voeg de kleur toe die bij het team hoort.
4. Voeg alle basisaanpassingen toe die we eerder toepasten.

# 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()Mogelijk gemaakt door

Uitvoer:

Een legenda toevoegen

Wat nog ontbreekt in het bovenstaande Gantt-diagram is een legenda die laat zien welke kleur bij welk team hoort. Om dit op te lossen, maken we patches – 2D-artistobjecten van matplotlib die gevuld zijn met een vooraf gedefinieerde kleur. We gebruiken de klasse matplotlib.patches.Patch om een lijst met patches te genereren, één voor elk team, met de bijbehorende kleur:

patches = []
for team in team_colors:
    patches.append(matplotlib.patches.Patch(color=team_colors[team]))Mogelijk gemaakt door

Nu zijn we klaar om een legenda aan onze grafiek toe te voegen:

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)

# Adding a legend
ax.legend(handles=patches, labels=team_colors.keys(), fontsize=11)

plt.show()Mogelijk gemaakt door

Uitvoer:

Het bovenstaande Gantt-diagram is al een stuk informatiever.

Je vindt meer technieken om de esthetiek en leesbaarheid van grafieken te verbeteren in de cursus Improving Your Data Visualizations in Python.

Voortgang toevoegen

Tot nu toe hebben we de completion_days-kolom die we aan het begin van deze tutorial berekenden, nog niet gebruikt. Die gaan we nu inzetten om ons Gantt-diagram informatiever te maken door te tonen in welk stadium van voltooiing elke taak zich bevindt.

Technisch gezien voegen we een extra balk toe boven op elke reeds gemaakte balk. De onderste balk staat voor de totale duur van elke taak in gereserveerde dagen, terwijl de bovenste overeenkomt met de voortgang van die taak in gereserveerde dagen. 

Voor elke taak hebben beide balken dezelfde kleur als het bijbehorende team, maar de onderste balk is lichter dan de bovenste, zodat het verschil zichtbaar is.

Met andere woorden, als een team bovengemiddeld presteert op een taak, lijkt de combinatie van deze twee balken te tonen dat het team al meer dagen aan die taak heeft gewerkt dan verwacht (wat betekent dat de taak waarschijnlijk voor de deadline wordt afgerond). 

In het omgekeerde geval, als een team ondermaats presteert op een taak, laat de combinatie van de overeenkomstige balken zien dat het team minder dagen aan die taak heeft gewerkt dan verwacht (wat betekent dat de taak waarschijnlijk na de deadline wordt afgerond).

fig, ax = plt.subplots()

for index, row in df.iterrows():

    # Adding a lower bar - for the overall task duration
    plt.barh(y=row['task'], width=row['task_duration'], left=row['days_to_start'] + 1, color=team_colors[row['team']], alpha=0.4)

    # Adding an upper bar - for the status of completion
    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()Mogelijk gemaakt door

Uitvoer:

Uit de bovenstaande grafiek zien we dat de teams niet in hetzelfde tempo taken afronden, wat vaak voorkomt in echte projecten. Om meer informatie uit deze grafiek te halen, nemen we aan dat de huidige datum 17 november 2022 is en markeren we deze datum op onze grafiek:

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)

# Marking the current date on the chart
ax.axvline(x=29, color='r', linestyle='dashed')
ax.text(x=29.5, y=11.5, s='17/11', color='r')

plt.show()Mogelijk gemaakt door

Uitvoer:

We kunnen de volgende observaties doen over de huidige status van Project X:

• Het R&D-team presteert bovengemiddeld op taak F en zal die waarschijnlijk voor de deadline afronden.
• Het IT-team heeft vertraging bij taak G en heeft mogelijk ondersteuning nodig.
• Het Sales-team presteert volgens schema op taak H.
• Het Accounting-team is met taak I eerder dan gepland begonnen.

Dit soort observaties kan teamleiders en de projectmanager helpen om de projectplanning bij te sturen en tijdig de nodige resources toe te wijzen om vertragingen in opleveringen te voorkomen.

Andere mogelijke aanpassingen

We kunnen meer details toevoegen aan ons Gantt-diagram in matplotlib. Bijvoorbeeld:

• Het percentage van taakvoortgang op elke balk toevoegen.
• Sommige taken onderverdelen in subtaken (we hebben eerder in deze tutorial al besproken hoe je dit technisch doet).
• Gecorreleerde taken annoteren.
• Cruciale mijlpalen en deadlines markeren.
• Weekenden en feestdagen markeren.
• De balken sorteren op team of taaktype.
• Kleine ticks op de x-as toevoegen om de informatiedichtheid te vergroten.
• De algehele opmaak en lay-out van de grafiek verbeteren.

Het is echter belangrijk om ons Gantt-diagram overzichtelijk te houden en te voorkomen dat het te druk wordt. Net als bij andere vormen van datavisualisatie moeten we de juiste balans bewaren tussen de informatiedichtheid van de grafiek en de leesbaarheid ervan, evenals de leesbaarheid van de code die voor de grafiek is gebruikt.

Ga aan de slag met je eigen Gantt-diagram in Python met Matplotlib

Samenvattend hebben we in deze tutorial het volgende onderzocht:

• wat een Gantt-diagram is
• welke informatie het weergeeft
• wanneer het wordt gebruikt
• de verschillende manieren en nuances van het maken van Gantt-diagrammen met matplotlib
• hoe je een Gantt-diagram maakt in Python met matplotlib 
• hoe je het verder aanpast om het informatiever te maken
• hoe je het eindresultaat interpreteert. 

Daarnaast hebben we verschillende voorbeelden van Gantt-diagrammen bekeken en het stapsgewijze proces om ze te bouwen.

Voor een meer geïntegreerde aanpak om te leren hoe je overtuigende en informatieve grafieken in Python maakt, bekijk onze skill track Data Visualization with Python.