Como fazer um gráfico de Gantt em Python com Matplotlib

Neste passo a passo, vamos falar sobre o que é um gráfico de Gantt, por que e quando esse tipo de visualização é útil, como fazer um gráfico de Gantt em Python com matplotlib e como personalizá-lo. No caminho, vamos construir alguns exemplos de gráficos de Gantt em matplotlib.

O que é um gráfico de Gantt e por que ele é útil?

Um gráfico de Gantt é um tipo de gráfico de barras usado para ilustrar um cronograma completo de planejamento e gestão de projetos. Ele costuma exibir itens como nomes das tarefas do projeto, datas de início e término, times responsáveis por cada tarefa, status de conclusão em percentual ou fração, desempenho por time e marcos importantes do projeto.

Os nomes das tarefas ficam no eixo y do gráfico de Gantt, geralmente ordenados por data de início em ordem cronológica de cima para baixo. Já o eixo x representa períodos de tempo, e a largura de cada barra corresponde à duração de execução de cada tarefa.

Como um gráfico de Gantt é, essencialmente, uma forma específica de gráfico de barras horizontal, podemos criá-lo em várias bibliotecas de visualização de dados do Python, incluindo matplotlib, Plotly, Bokeh e Altair. Neste tutorial, vamos focar em criar gráficos de Gantt na mais popular delas – o matplotlib.

Se você quiser explorar outras maneiras de criar um gráfico de Gantt e outros tipos de gráficos em Python, confira o curso Introduction to Data Visualization with Plotly in Python. Se precisar revisar ou desenvolver suas habilidades em matplotlib, estes cursos vão ajudar: Introduction to Data Visualization with Matplotlib e Python for MATLAB Users.

Como fazer um gráfico de Gantt em Python com Matplotlib

Usando barh()

Vamos começar criando um gráfico de Gantt básico no matplotlib usando o método barh() de matplotlib.pyplot.

Primeiro, precisamos importar as bibliotecas necessárias:

import pandas as pd
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import datetime as dtTecnologia

Em seguida, vamos criar dados de exemplo para trabalhar:

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

Saída:

  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.00Tecnologia

Para facilitar a construção do gráfico de Gantt com esses dados, precisamos calcular mais quatro colunas que representarão as seguintes informações:

1. Quantos dias se passaram/passariam desde o início geral do projeto até a data de início de cada tarefa:

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

1. Quantos dias se passaram/passariam desde o início geral do projeto até a data de término de cada tarefa:

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

1. A duração de cada tarefa, incluindo as datas de início e de término:

df['task_duration'] = df['days_to_end'] - df['days_to_start'] + 1  # para incluir também a data de términoTecnologia

1. O status de conclusão de cada tarefa convertido de fração para uma quantidade de dias alocados à tarefa:

df['completion_days'] = df['completion_frac'] * df['task_duration']Tecnologia

Vamos conferir o que obtivemos:

print(df)Tecnologia

Saída:

  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 Tecnologia

Agora, estamos prontos para gerar um gráfico de Gantt básico no matplotlib:

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

Saída:

Esse gráfico ainda precisa de alguns ajustes para extrair o máximo de informação:

• Adicionar um título relevante e rótulos no eixo x (datas)
• Inverter o eixo y para ter as tarefas em ordem cronológica de cima para baixo
• Adicionar uma grade
• Colorir as tarefas por time
• Exibir uma legenda
• Adicionar o status de conclusão das tarefas

Vamos implementar tudo isso já já. Antes, porém, vamos ver outra forma de construir um gráfico de Gantt básico.

Usando broken_barh()

Quando algumas tarefas têm duas ou mais subtarefas distribuídas ao longo do tempo, devemos usar outro método do matplotlib – broken_barh().

Para ter dados de exemplo e testar essa abordagem, vamos fazer o seguinte:

1. Pegar do nosso dataframe inicial apenas as tarefas atribuídas ao time de Sales (por enquanto, vamos ignorar a coluna completion_frac).
2. Renomear as colunas start e end para start_1 e end_1, respectivamente (por conveniência).
3. Adicionar mais subtarefas a algumas das tarefas disponíveis.
4. Para cada subtarefa, calcular as três colunas mostradas acima representando:
• Quantos dias se passaram/passariam desde o início geral do projeto até a data de início de cada subtarefa.
• Quantos dias se passaram/passariam desde o início geral do projeto até a data de término de cada subtarefa.
• A duração de cada subtarefa, incluindo as datas de início e de término.

# 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)Tecnologia

Saída:

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 Tecnologia

Repare que agora a tarefa D tem duas subtarefas, a tarefa H tem três subtarefas e as tarefas C e K têm uma subtarefa cada. Portanto, D e H são as tarefas para as quais vamos aplicar o método broken_barh(). Como a sintaxe desse método é um pouco menos intuitiva que a do barh(), vamos ver seus principais parâmetros e formatos. Os parâmetros obrigatórios de broken_barh() são:

• xranges – uma sequência de tuplas no formato (xmin, xwidth) para indicar o início e a extensão de cada barra. Aqui, cada barra representa uma subtarefa. Ou seja, esse parâmetro exibe a data de início e a duração de cada subtarefa.
• yrange – uma tupla no formato (ymin, yheight) para indicar a posição em y e a altura de cada barra.

Agora, vamos plotar nosso gráfico de Gantt "quebrado". O passo a passo é:

1. Criar uma figura com subplots.
2. Iterar pelas linhas do dataframe e verificar se a tarefa tem uma, duas ou três subtarefas. Com base nisso, fazer o seguinte:
• Uma subtarefa: plotar uma barra usando o método barh(), como fizemos antes.
• Duas subtarefas: plotar duas barras usando broken_barh().
• Três subtarefas: plotar três barras usando broken_barh().
3. Adicionar ajustes básicos: definir e rotular os ticks do eixo 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()Tecnologia

Saída:

No código acima, também podemos usar o método broken_barh() para plotar as barras das tarefas com apenas uma subtarefa. Nesse caso, basta substituir esta linha:

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

por esta:

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

Essa abordagem também deixa o código mais uniforme e legível.

Como personalizar um gráfico de Gantt no Matplotlib

Vamos voltar ao nosso dataframe inicial:

print(df)Tecnologia

Saída:

  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 Tecnologia

e ao nosso primeiro gráfico de Gantt:

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

Saída:

Em particular, queremos adicionar algumas personalizações para tornar o gráfico mais informativo.

Para se aprofundar na personalização de gráficos com matplotlib, confira: Matplotlib Tutorial: Python Plotting e a Matplotlib Cheat Sheet: Plotting in Python.

Ajustes básicos no gráfico de Gantt

Incluem:

• Adicionar um título ao gráfico
• Ajustar e personalizar os eixos
• Adicionar uma grade

Adicionando um título

Ter um título claro é essencial para qualquer gráfico, inclusive um gráfico de Gantt. Vamos assumir que nosso projeto se chama Projeto 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()Tecnologia

Saída:

Ajustando e personalizando os eixos e adicionando uma grade

Nesta etapa, vamos partir do código anterior e fazer o seguinte:

1. Criar uma figura com subplots para trabalhar com o objeto ax.
2. Inverter o eixo y para ter todas as tarefas em ordem cronológica de cima para baixo.
3. Definir as posições ideais dos ticks do eixo x.
• Digamos que queremos posicionar os ticks do eixo x em todas as segundas-feiras, lembrando que o Projeto X começou em uma quinta-feira.
• Vamos manter apenas os major ticks para evitar poluição visual.
4. Definir os rótulos corretos dos ticks do eixo x e seu formato.
• De novo, lembrando que o Projeto X começou em uma quinta-feira e que precisamos rotular apenas as segundas-feiras.
• Como o Projeto X está todo em 2022, não precisamos indicar o ano em cada data.
• É importante garantir que a quantidade de ticks no eixo x seja igual à de seus rótulos.
5. Adicionar os ticks e rótulos do eixo x.
6. Adicionar uma grade vertical.

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

Saída:

Se você precisa de mais prática para ler e escrever qualquer código em Python com tranquilidade, o curso Intermediate Python é um ótimo ponto de partida.

Colorindo tarefas por time

Agora, vamos colorir cada barra (que representa uma tarefa) de acordo com o time responsável. Para isso, vamos:

1. Criar um dicionário com os nomes dos times como chaves e cores básicas do matplotlib como valores.
2. Criar uma figura com subplots.
3. Iterar pelas linhas do dataframe, criar uma barra para cada linha e aplicar a cor correspondente ao time.
4. Adicionar todos os ajustes básicos que aplicamos antes.

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

Saída:

Adicionando uma legenda

Falta no gráfico acima uma legenda que mostre qual cor corresponde a qual time. Para resolver, vamos criar patches – objetos 2D do matplotlib preenchidos com uma cor definida. Usaremos a classe matplotlib.patches.Patch para gerar uma lista de patches, um para cada time, com a cor apropriada:

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

Agora, podemos adicionar a legenda ao gráfico:

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)

# Adicionando uma legenda
ax.legend(handles=patches, labels=team_colors.keys(), fontsize=11)

plt.show()Tecnologia

Saída:

O gráfico de Gantt acima ficou bem mais informativo.

Você vai encontrar mais técnicas para melhorar a estética e a legibilidade dos gráficos no curso Improving Your Data Visualizations in Python.

Adicionando o status de conclusão

Até agora, não usamos a coluna completion_days que calculamos no início do tutorial. Vamos usá-la agora para deixar o gráfico mais claro, mostrando em que estágio de conclusão cada tarefa está.

Tecnicamente, vamos adicionar outra barra por cima de cada barra já construída. A barra inferior representa a duração total da tarefa em dias alocados, enquanto a superior corresponde ao status de conclusão dessa tarefa em dias alocados. 

Para cada tarefa, as duas barras terão a mesma cor do time correspondente, mas a barra inferior será mais clara que a superior para destacar a diferença entre elas.

Em outras palavras, se um time estiver acima do ritmo em uma tarefa, a combinação das duas barras vai parecer que o time já trabalhou mais dias do que o esperado (indicando que a tarefa provavelmente será concluída antes do prazo). 

No caso oposto, se um time estiver abaixo do ritmo, a combinação das barras vai mostrar que o time trabalhou menos dias que o esperado (indicando que a tarefa provavelmente será concluída após o prazo).

fig, ax = plt.subplots()

for index, row in df.iterrows():

    # Barra inferior - duração total da tarefa
    plt.barh(y=row['task'], width=row['task_duration'], left=row['days_to_start'] + 1, color=team_colors[row['team']], alpha=0.4)

    # Barra superior - status de conclusão
    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()Tecnologia

Saída:

No gráfico acima, dá para ver que os times não avançam no mesmo ritmo — algo comum em projetos reais. Para extrair mais informação, vamos supor que a data atual é 17 de novembro de 2022 e marcá-la no gráfico:

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)

# Marcando a data atual no gráfico
ax.axvline(x=29, color='r', linestyle='dashed')
ax.text(x=29.5, y=11.5, s='17/11', color='r')

plt.show()Tecnologia

Saída:

Podemos fazer as seguintes observações sobre o status atual do Projeto X:

• O time de R&D está acima do ritmo na tarefa F e provavelmente a concluirá antes do prazo.
• O time de IT está atrasado na tarefa G e provavelmente precisa de suporte.
• O time de Sales está seguindo o cronograma na tarefa H.
• O time de Accounting começou a tarefa I adiantado em relação ao cronograma do projeto.

Essas observações ajudam líderes de time e o gerente do projeto a ajustar o cronograma e alocar recursos a tempo para evitar atrasos nas entregas.

Outros possíveis ajustes

Podemos adicionar mais detalhes ao nosso gráfico de Gantt no matplotlib. Por exemplo:

• Adicionar o percentual de conclusão em cada barra.
• Subdividir algumas tarefas em subtarefas (já vimos como fazer isso tecnicamente mais acima).
• Anotar tarefas correlacionadas.
• Destacar marcos e prazos críticos.
• Realçar fins de semana e feriados.
• Ordenar as barras por time ou tipo de tarefa.
• Adicionar minor ticks no eixo x para aumentar a granularidade de informação.
• Melhorar a formatação geral e o layout do gráfico.

É importante, no entanto, manter o gráfico de Gantt limpo e evitar excesso de detalhes. Como em qualquer visualização de dados, precisamos equilibrar a quantidade de informação com a legibilidade do gráfico e também do código usado para construí-lo.

Comece a criar seu próprio gráfico de Gantt em Python com Matplotlib

Para resumir, neste tutorial, exploramos:

• o que é um gráfico de Gantt
• que tipo de informação ele exibe
• quando ele é usado
• as diferentes formas e nuances de criar gráficos de Gantt com matplotlib
• como fazer um gráfico de Gantt em Python com matplotlib 
• como ajustá-lo para deixá-lo mais informativo
• como interpretar o resultado final. 

Além disso, vimos vários exemplos de gráficos de Gantt e o passo a passo para construí-los.

Para uma abordagem mais integrada de como criar gráficos impactantes e informativos em Python, confira nossa trilha de habilidades Data Visualization with Python.