Come creare un diagramma di Gantt in Python con Matplotlib

In questa guida passo passo, vedremo cos’è un diagramma di Gantt, perché e quando queste visualizzazioni sono utili, come creare un diagramma di Gantt in Python con matplotlib e come personalizzarlo ulteriormente. Lungo il percorso, costruiremo alcuni esempi di diagramma di Gantt in matplotlib.

Cos’è un diagramma di Gantt e perché è utile?

Un diagramma di Gantt è un tipo di grafico a barre utilizzato per illustrare una pianificazione completa di progetto per la programmazione e la gestione. Mostra comunemente elementi come i nomi delle attività del progetto, le loro date di inizio e fine, i team a cui sono assegnate, lo stato di completamento in percentuale o frazione, le prestazioni per team e le tappe fondamentali del progetto.

I nomi delle attività sono disposti sull’asse y del diagramma di Gantt, di solito ordinati per data di inizio in ordine cronologico dall’alto verso il basso. L’asse x invece serve a mostrare i periodi temporali, con la larghezza di ogni barra che corrisponde alla durata di esecuzione di ciascuna attività.

Poiché un diagramma di Gantt è essenzialmente una forma specifica di grafico a barre orizzontali, possiamo crearlo in molte librerie di visualizzazione dati di Python, tra cui matplotlib, Plotly, Bokeh e Altair. In questo tutorial, ci concentreremo sulla creazione di diagrammi di Gantt nella più popolare tra queste – matplotlib.

Se vuoi esplorare modi alternativi per creare un diagramma di Gantt e altri tipi di grafici in Python, dai un’occhiata al corso Introduction to Data Visualization with Plotly in Python. Se hai bisogno di rinfrescare o sviluppare le tue competenze in matplotlib, ti saranno utili questi corsi: Introduction to Data Visualization with Matplotlib e Python for MATLAB Users.

Come creare un diagramma di Gantt in Python con Matplotlib

Usando barh()

Cominciamo costruendo un diagramma di Gantt base in matplotlib usando il metodo barh() di matplotlib.pyplot.

Per prima cosa, dobbiamo importare le librerie necessarie:

import pandas as pd
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import datetime as dtOfferto da

Il passo successivo è creare dei dati di esempio su cui lavorare:

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)Offerto da

Output:

  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.00Offerto da

Per facilitare la costruzione di un diagramma di Gantt per questi dati, dobbiamo calcolare altre quattro colonne che rappresenteranno le seguenti informazioni:

1. Quanti giorni sono passati/passerebbero dall’inizio complessivo del progetto alla data di inizio di ciascuna attività:

df['days_to_start'] = (df['start'] - df['start'].min()).dt.daysOfferto da

1. Quanti giorni sono passati/passerebbero dall’inizio complessivo del progetto alla data di fine di ciascuna attività:

df['days_to_end'] = (df['end'] - df['start'].min()).dt.daysOfferto da

1. La durata di ciascuna attività, includendo sia la data di inizio che quella di fine:

df['task_duration'] = df['days_to_end'] - df['days_to_start'] + 1  # to include also the end dateOfferto da

1. Lo stato di completamento di ciascuna attività convertito da frazione in una quota di giorni allocati a quell’attività:

df['completion_days'] = df['completion_frac'] * df['task_duration']Offerto da

Controlliamo cosa abbiamo ottenuto:

print(df)Offerto da

Output:

  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 Offerto da

Ora siamo pronti a generare un diagramma di Gantt di base in matplotlib:

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

Output:

Il grafico sopra necessita di diversi aggiustamenti per poter estrarre il massimo delle informazioni:

• Aggiungere un titolo significativo e le etichette dell’asse x (date)
• Invertire l’asse y per avere tutte le attività in ordine cronologico dall’alto verso il basso
• Aggiungere una griglia
• Colorare le attività per team
• Mostrare una legenda
• Aggiungere lo stato di completamento delle attività

Metteremo in pratica presto tutte queste migliorie. Prima, però, vediamo come gestire la creazione di un diagramma di Gantt di base.

Usando broken_barh()

Quando alcune attività contengono due o più sotto-attività distribuite su un periodo di tempo, dovremmo usare un altro metodo di matplotlib – broken_barh().

Per avere dei dati di esempio su cui provare questo approccio, facciamo quanto segue:

1. Prendiamo dal dataframe iniziale solo le attività assegnate al team Sales (per ora, ignoriamo la colonna completion_frac).
2. Rinominiamo le colonne start ed end in start_1 ed end_1 rispettivamente (per comodità).
3. Aggiungiamo più sotto-attività ad alcune delle attività disponibili.
4. Per ciascuna sotto-attività, calcoliamo le tre colonne mostrate sopra che rappresentano le seguenti informazioni:
• Quanti giorni sono passati/passerebbero dall’inizio complessivo del progetto alla data di inizio di ciascuna sotto-attività.
• Quanti giorni sono passati/passerebbero dall’inizio complessivo del progetto alla data di fine di ciascuna sotto-attività.
• La durata di ciascuna sotto-attività, includendo sia la data di inizio che quella di fine.

# 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)Offerto da

Output:

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 Offerto da

Nota che ora l’attività D ha due sotto-attività, l’attività H ne ha tre e le attività C e K ne hanno una ciascuna. Pertanto, le attività D e H sono quelle per cui applicheremo il metodo broken_barh(). Poiché la sintassi di questo metodo è un po’ meno intuitiva di quella di barh(), diamo un’occhiata ai suoi parametri principali e al loro formato. I parametri obbligatori di broken_barh() sono:

• xranges – una sequenza di tuple nel formato (xmin, xwidth) per indicare l’inizio e l’estensione di ciascuna barra. Qui, ogni barra rappresenta una sotto-attività. Quindi, questo parametro mostra la data di inizio e la durata di ciascuna sotto-attività.
• yrange – una tupla nel formato (ymin, yheight) per indicare la posizione y e l’altezza di ciascuna barra.

Ora, tracciamo il nostro diagramma di Gantt "spezzato". L’algoritmo è il seguente:

1. Crea una figura con sottotrame.
2. Itera sulle righe del dataframe e controlla se l’attività ha una, due o tre sotto-attività. In base a ciò, procedi così:
• Una sotto-attività: traccia una barra usando il metodo barh() come fatto in precedenza.
• Due sotto-attività: traccia due barre usando il metodo broken_barh().
• Tre sotto-attività: traccia tre barre usando il metodo broken_barh().
3. Aggiungi gli aggiustamenti di base: imposta e etichetta i tick dell’asse y.

# 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()Offerto da

Output:

Nel codice sopra, possiamo in realtà usare il metodo broken_barh() per tracciare le barre anche per le attività con una sola sotto-attività. In questo caso, dobbiamo sostituire questa riga di codice:

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

con questa:

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

Questo approccio renderebbe anche il nostro codice più uniforme e leggibile.

Come personalizzare un diagramma di Gantt in Matplotlib

Torniamo al nostro dataframe iniziale:

print(df)Offerto da

Output:

  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 Offerto da

e al nostro primo diagramma di Gantt:

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

Output:

In particolare, vogliamo aggiungere alcune personalizzazioni a questo grafico per renderlo più informativo.

Per approfondire la personalizzazione dei grafici con matplotlib, considera queste risorse: Matplotlib Tutorial: Python Plotting e Matplotlib Cheat Sheet: Plotting in Python.

Regolazioni di base del diagramma di Gantt

Queste includono:

• Aggiungere un titolo al grafico
• Regolare e personalizzare gli assi
• Aggiungere una griglia

Aggiungere un titolo al grafico

Avere un titolo significativo è fondamentale per qualsiasi grafico, incluso un diagramma di Gantt. Supponiamo che il nostro progetto si chiami 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()Offerto da

Output:

Regolare e personalizzare gli assi e aggiungere una griglia

In questo passaggio, estenderemo il codice precedente ed eseguiremo le seguenti azioni:

1. Creare una figura con sottotrame per poter lavorare con l’oggetto ax.
2. Invertire l’asse y per avere tutte le attività in ordine cronologico dall’alto verso il basso.
3. Determinare le posizioni ottimali dei tick sull’asse x.
• Diciamo che vogliamo posizionare i tick dell’asse x ogni lunedì, tenendo presente che Project X è iniziato di giovedì.
• Optiamo solo per tick principali per evitare di appesantire il grafico.
4. Determinare le giuste etichette dei tick sull’asse x e un formato appropriato.
• Anche qui, teniamo presente che Project X è iniziato di giovedì e dobbiamo etichettare solo i lunedì.
• Poiché Project X è interamente nel 2022, non serve specificare l’anno per ogni data.
• È importante assicurarsi che il numero di tick sull’asse x sia uguale a quello delle relative etichette.
5. Aggiungere i tick e le etichette dell’asse x.
6. Aggiungere una griglia verticale.

# 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()Offerto da

Output:

Se ti serve più pratica con Python per scrivere e leggere qualsiasi codice Python con facilità, il nostro corso Intermediate Python è un buon punto di riferimento.

Colorare le attività per team

Ora, attribuiamo un colore a ciascuna barra (che rappresenta una specifica attività) in base al team a cui è assegnata. A questo scopo, faremo quanto segue:

1. Creare un dizionario con i nomi dei team come chiavi e i colori base di matplotlib come valori.
2. Creare una figura con sottotrame.
3. Iterare sulle righe del dataframe, creare una barra per ogni riga e aggiungere il colore corrispondente al team.
4. Aggiungere tutti gli aggiustamenti di base applicati in precedenza.

# 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()Offerto da

Output:

Aggiungere una legenda

Una cosa che manca nell’esempio di diagramma di Gantt sopra è una legenda che mostri quale colore corrisponde a quale team. Per risolvere, creiamo delle patch – oggetti 2D di matplotlib riempiti con un colore predefinito. Useremo la classe matplotlib.patches.Patch per generare un elenco di patch, una per ciascun team, colorate di conseguenza:

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

Ora siamo pronti ad aggiungere una legenda al nostro grafico:

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

Output:

Il diagramma di Gantt sopra appare molto più informativo.

Troverai altre tecniche per migliorare l’estetica e la leggibilità dei grafici nel corso Improving Your Data Visualizations in Python.

Aggiungere lo stato di completamento

Finora, non abbiamo usato la completion_days column che abbiamo calcolato all’inizio di questo tutorial. La useremo ora per rendere il nostro diagramma di Gantt più informativo mostrando a che punto di completamento si trova ciascuna attività.

Tecnicamente, aggiungeremo un’altra barra sopra ciascuna barra già costruita. La barra inferiore rappresenterà la durata complessiva di ciascuna attività in giorni allocati, mentre quella superiore corrisponderà allo stato di completamento di tale attività in giorni allocati. 

Per ciascuna attività, entrambe le barre avranno lo stesso colore del relativo team, ma la barra inferiore sarà più chiara di quella superiore per evidenziare la differenza tra le due.

In altre parole, se un team sta overperformando su un’attività, la combinazione di queste due barre mostrerà come se il team avesse già lavorato più giorni su quell’attività di quanto previsto (il che significa che probabilmente l’attività verrà completata prima della scadenza). 

Nel caso opposto, se un team sta underperformando su un’attività, la combinazione delle barre mostrerà come se il team avesse lavorato meno giorni su quell’attività di quanto previsto (il che significa che probabilmente l’attività verrà completata dopo la scadenza).

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

Output:

Dal grafico sopra, possiamo vedere che i team non avanzano allo stesso ritmo nel completare le attività, cosa comune in molti progetti reali. Per ottenere più informazioni da questo grafico, supponiamo che la data attuale sia il 17 novembre 2022 e segniamola sul nostro grafico:

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

Output:

Possiamo fare le seguenti osservazioni sullo stato attuale di Project X:

• Il team R&D sta overperformando sull’attività F e probabilmente la completerà prima della scadenza.
• Il team IT è in ritardo sull’attività G e probabilmente ha bisogno di supporto.
• Il team Sales sta procedendo secondo la pianificazione sull’attività H.
• Il team Accounting ha iniziato l’attività I in anticipo rispetto alla pianificazione del progetto.

Osservazioni di questo tipo possono aiutare i team leader e il project manager ad adeguare di conseguenza la pianificazione del progetto e allocare tempestivamente le risorse necessarie per evitare ritardi nelle consegne.

Altri possibili aggiustamenti

Possiamo aggiungere ulteriori dettagli al nostro diagramma di Gantt in matplotlib. Ad esempio:

• Aggiungere la percentuale di completamento su ciascuna barra.
• Suddividere alcune attività in sotto-attività (abbiamo già visto come farlo tecnicamente in precedenza in questo tutorial).
• Annotare attività correlate.
• Segnare tappe fondamentali e scadenze cruciali.
• Evidenziare weekend e festività.
• Ordinare le barre per team o tipo di attività.
• Aggiungere tick minori sull’asse x per aumentare la granularità delle informazioni.
• Migliorare la formattazione e il layout complessivi del grafico.

È importante, tuttavia, mantenere pulito il nostro diagramma di Gantt ed evitare di sovraccaricarlo con troppi dettagli. Come per qualsiasi altra visualizzazione di dati, dobbiamo mantenere il giusto equilibrio tra la capacità informativa del grafico e la sua leggibilità, così come la leggibilità del codice usato per costruirlo.

Inizia a creare il tuo diagramma di Gantt in Python con Matplotlib

Per riassumere, in questo tutorial abbiamo esplorato:

• cos’è un diagramma di Gantt
• quali informazioni mostra
• quando si usa
• i diversi modi e le sfumature per creare diagrammi di Gantt con matplotlib
• come creare un diagramma di Gantt in Python con matplotlib 
• come regolarlo ulteriormente per renderlo più informativo
• come interpretare il risultato finale. 

Inoltre, abbiamo visto vari esempi di diagrammi di Gantt e il processo passo passo per costruirli.

Per un approccio più integrato all’apprendimento di come creare grafici efficaci e informativi in Python, dai un’occhiata al nostro skill track Data Visualization with Python.