Matplotlib ile Python’da Gantt Grafiği Nasıl Yapılır

Bu adım adım rehberde Gantt grafiğinin ne olduğunu, bu tür görselleştirmelerin neden ve ne zaman yararlı olduğunu, matplotlib ile Python’da Gantt grafiğinin nasıl yapılacağını ve nasıl özelleştirilebileceğini ele alacağız. Yol boyunca, matplotlib’de bazı Gantt grafiği örnekleri de oluşturacağız.

Gantt Grafiği Nedir ve Neden Faydalıdır?

Gantt grafiği, kapsamlı bir proje planlama ve yönetim takvimini görselleştirmek için kullanılan bir çubuk grafik türüdür. Genellikle proje görev adları, bu görevlerin başlangıç ve bitiş tarihleri, görevlerin atandığı ekipler, görevin tamamlanma durumu (yüzde veya kesir cinsinden), ekip performansı ve projenin önemli kilometre taşları gibi öğeleri gösterir.

Görev adları Gantt grafiğinin y ekseni boyunca, genellikle başlangıç tarihlerine göre yukarıdan aşağıya kronolojik sırayla düzenlenir. X ekseni ise zaman aralıklarını gösterir; her çubuğun genişliği, ilgili görevin uygulanma süresine karşılık gelir.

Gantt grafiği esasen yatay bir çubuk grafiğinin özel bir biçimi olduğundan, matplotlib, Plotly, Bokeh ve Altair dahil olmak üzere birçok Python veri görselleştirme kütüphanesinde oluşturulabilir. Bu derste en popüler olanına – matplotlib’e – odaklanacağız.

Python’da Gantt grafiği ve diğer türde grafikler oluşturmanın alternatif yollarını keşfetmek isterseniz, Introduction to Data Visualization with Plotly in Python kursuna göz atabilirsiniz. Matplotlib becerilerinizi tazelemeniz veya geliştirmeniz gerekiyorsa şu kurslar faydalı olacaktır: Introduction to Data Visualization with Matplotlib ve Python for MATLAB Users.

Matplotlib ile Python’da Gantt Grafiği Nasıl Yapılır

barh() kullanarak

Önce, matplotlib.pyplot’ın barh() yöntemini kullanarak temel bir matplotlib Gantt grafiği oluşturalım.

İlk olarak gerekli kütüphaneleri indirmemiz gerekiyor:

import pandas as pd
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import datetime as dtAltyapı:

Bir sonraki adım, üzerinde çalışmak için örnek veriler oluşturmaktır:

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)Altyapı:

Çıktı:

  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.00Altyapı:

Bu veriler için bir Gantt grafiği oluşturmayı kolaylaştırmak üzere, aşağıdaki bilgileri temsil edecek dört sütun daha hesaplamamız gerekiyor:

1. Her görev için genel proje başlangıcından başlangıç tarihine kadar geçen/geçecek gün sayısı:

df['days_to_start'] = (df['start'] - df['start'].min()).dt.daysAltyapı:

1. Her görev için genel proje başlangıcından bitiş tarihine kadar geçen/geçecek gün sayısı:

df['days_to_end'] = (df['end'] - df['start'].min()).dt.daysAltyapı:

1. Başlangıç ve bitiş tarihlerini de kapsayan her görevin süresi:

df['task_duration'] = df['days_to_end'] - df['days_to_start'] + 1  # to include also the end dateAltyapı:

1. Her görevin tamamlanma durumunun, bir kesirden o göreve ayrılan gün sayısına çevrilmiş hali:

df['completion_days'] = df['completion_frac'] * df['task_duration']Altyapı:

Ne elde ettiğimizi kontrol edelim:

print(df)Altyapı:

Çıktı:

  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 Altyapı:

Artık matplotlib’te temel bir Gantt grafiği oluşturmaya hazırız:

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

Çıktı:

Yukarıdaki grafikten en fazla bilgiyi alabilmemiz için epeyce ayar gerekiyor:

• Anlamlı bir başlık ve x-etiketleri (tarihler) ekleme
• Y eksenini ters çevirerek tüm görevleri yukarıdan aşağıya kronolojik sıraya koyma
• Izgara ekleme
• Görevleri ekibe göre renklendirme
• Açıklama kutusu (legend) gösterme
• Görev tamamlanma durumunu ekleme

Bu iyileştirmelerin hepsini birazdan uygulayacağız. Ancak önce temel bir Gantt grafiği oluşturmanın diğer bir yoluna bakalım.

broken_barh() kullanarak

Bazı görevler zaman içinde iki veya daha fazla alt göreve yayılıyorsa başka bir matplotlib yöntemi – broken_barh() – kullanmalıyız.

Bu yaklaşımı denemek için bir miktar örnek veri elde etmek adına şunları yapalım:

1. İlk veri çerçevemizden yalnızca Satış ekibine atanan görevleri alın (şimdilik completion_frac sütununu yok sayalım).
2. start ve end sütunlarının adlarını sırasıyla start_1 ve end_1 olarak değiştirin (kolaylık için).
3. Bazı mevcut görevlere daha fazla alt görev ekleyin.
4. Her alt görev için, yukarıda gösterildiği gibi aşağıdaki bilgileri temsil eden üç sütunu hesaplayın:
• Her alt görevin başlangıç tarihine genel proje başlangıcından kaç gün geçti/geçecek.
• Her alt görevin bitiş tarihine genel proje başlangıcından kaç gün geçti/geçecek.
• Başlangıç ve bitiş tarihlerini de kapsayan her alt görevin süresi.

# 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)Altyapı:

Çıktı:

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 Altyapı:

Artık D görevinin iki, H görevinin üç alt görevi, C ve K görevlerinin ise birer alt görevi olduğunu unutmayın. Dolayısıyla broken_barh() yöntemini D ve H görevleri için uygulayacağız. Bu yöntemin sözdizimi barh()’a kıyasla biraz daha az sezgiseldir; bu yüzden ana parametrelerine ve biçimlerine bakalım. broken_barh() yönteminin zorunlu parametreleri şunlardır:

• xranges – her biri (xmin, xwidth) biçiminde olan demetler dizisi; her çubuğun başlangıcını ve uzunluğunu belirtir. Burada her çubuk bir alt görevi temsil eder. Bu parametre, her alt görevin başlangıç tarihini ve süresini gösterir.
• yrange – (ymin, yheight) biçiminde bir demet; her çubuk için y konumunu ve yüksekliğini belirtir.

Şimdi “kırık” Gantt grafiğimizi çizelim. Algoritma şöyledir:

1. Alt grafikli bir figür oluşturun.
2. Veri çerçevesinin satırlarını yineleyin ve görevin bir, iki veya üç alt görevi olup olmadığını kontrol edin. Buna bağlı olarak şunları yapın:
• Bir alt görev: daha önce yaptığımız gibi barh() yöntemiyle bir çubuk çizin.
• İki alt görev: broken_barh() yöntemiyle iki çubuk çizin.
• Üç alt görev: broken_barh() yöntemiyle üç çubuk çizin.
3. Temel ayarları ekleyin: y ekseninin işaretlerini belirleyin ve etiketleyin.

# 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()Altyapı:

Çıktı:

Yukarıdaki kodda, yalnızca bir alt görevi olan görevlerin çubuklarını çizmek için de aslında broken_barh() yöntemini kullanabiliriz. Bu durumda, şu kod satırını:

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

şununla değiştirmemiz gerekir:

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

Bu yaklaşım kodumuzu daha tutarlı ve okunabilir hale getirir.

Matplotlib’te Bir Gantt Grafiği Nasıl Özelleştirilir

İlk veri çerçevemize geri dönelim:

print(df)Altyapı:

Çıktı:

  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 Altyapı:

ve ilk Gantt grafiğimize:

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

Çıktı:

Özellikle, bu grafiğe daha fazla içgörü kazandırmak için bazı özelleştirmeler eklemek istiyoruz.

Matplotlib ile grafik özelleştirmeyi daha derinlemesine incelemek için şu kaynaklara göz atın: Matplotlib Tutorial: Python Plotting ve Matplotlib Cheat Sheet: Plotting in Python.

Temel Gantt Grafiği Ayarları

Bunlar şunları içerir:

• Grafiğe başlık ekleme
• Eksenleri ayarlama ve özelleştirme
• Izgara ekleme

Grafiğe başlık ekleme

Gantt grafiği de dahil olmak üzere her grafik için anlamlı bir başlık şarttır. Projemizin adının Project X olduğunu varsayalım:

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()Altyapı:

Çıktı:

Eksenleri ayarlama ve özelleştirme ile ızgara ekleme

Bu adımda, önceki kodun üzerine inşa ederek aşağıdaki işlemleri gerçekleştireceğiz:

1. ax nesnesiyle çalışabilmek için alt grafikli bir figür oluşturun.
2. Görevlerin tümünü yukarıdan aşağıya kronolojik sıraya koymak için y eksenini ters çevirin.
3. X işaretlerinin en uygun konumlarını belirleyin.
• Project X’in Perşembe günü başladığını unutmadan, x işaretlerini her Pazartesiye yerleştirmek istediğimizi varsayalım.
• Grafikte kalabalığı önlemek için yalnızca ana işaretleri tercih ediyoruz.
4. X işareti etiketleri ve uygun biçimlerini belirleyin.
• Yine, Project X’in Perşembe günü başladığını ve yalnızca Pazartesileri etiketlememiz gerektiğini akılda tutuyoruz.
• Project X tamamen 2022 yılıyla ilgili olduğundan, her tarih için yılı belirtmemize gerek yok.
• X işareti sayısının x işareti etiketlerinin sayısıyla eşit olduğundan emin olmak önemlidir.
5. X işaretlerini ve etiketleri ekleyin.
6. Dikey bir ızgara ekleyin.

# 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()Altyapı:

Çıktı:

Her türlü Python kodunu kolayca yazıp okuyabilmek için daha fazla pratiğe ihtiyacınız varsa, Intermediate Python kursumuz iyi bir referans noktasıdır.

Görevleri Ekibe Göre Renklendirme

Şimdi, her çubuğu (belirli bir görevi temsil eden) o görevin atandığı ekibe göre renklendirelim. Bunun için şunları yapacağız:

1. Anahtarları ekip adları, değerleri temel matplotlib renkleri olan bir sözlük oluşturun.
2. Alt grafikli bir figür oluşturun.
3. Veri çerçevesinin satırlarını yineleyin, her satır için bir çubuk oluşturun ve ilgili ekibe karşılık gelen rengi ekleyin.
4. Önceden uyguladığımız tüm temel ayarları ekleyin.

# 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()Altyapı:

Çıktı:

Açıklama Kutusu (Legend) Ekleme

Yukarıdaki Gantt grafiği örneğinde eksik olan şey, hangi rengin hangi ekibe karşılık geldiğini gösteren bir açıklama kutusu. Bunu düzeltmek için, önceden tanımlanmış bir renkle doldurulan matplotlib 2D sanatçı nesneleri olan yamalar (patch) oluşturalım. Her ekip için birer tane olacak şekilde, ilgili renkte yamalar listesi üretmek üzere matplotlib.patches.Patch sınıfını kullanacağız:

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

Artık grafiğimize bir açıklama kutusu eklemeye hazırız:

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()Altyapı:

Çıktı:

Yukarıdaki Gantt grafiği örneği çok daha bilgilendirici görünüyor.

Grafiklerin estetiğini ve okunabilirliğini artırmaya yönelik daha fazla tekniği Improving Your Data Visualizations in Python kursunda bulabilirsiniz.

Tamamlanma Durumu Ekleme

Şimdiye kadar, bu dersin başında hesapladığımız completion_days column sütununu kullanmadık. Şimdi, her görevin tamamlanma aşamasının ne olduğunu göstererek Gantt grafiğimizi daha içgörülü hale getirmek için bunu kullanacağız.

Teknik olarak yapacağımız şey, halihazırda oluşturduğumuz her çubuğun üzerine bir çubuk daha eklemek. Alt çubuk, her görevin ayrılan günlerdeki toplam süresini temsil ederken, üst çubuk o görevin ayrılan günlerdeki tamamlanma durumuna karşılık gelecek. 

Her görev için her iki çubuk da ilgili ekiple ilişkili aynı renkte olacak, ancak aralarındaki farkı görebilmek için alt çubuk üsttekinden daha açık olacaktır.

Başka bir deyişle, bir ekip bir görevde beklenenin üzerinde performans gösteriyorsa, bu iki çubuğun birleşimi, ekibin o görevde beklenenden daha fazla gün çalışmış gibi görünecektir (bu da muhtemelen görevin son teslim tarihinden önce tamamlanacağı anlamına gelir). 

Tersine, bir ekip bir görevde beklenenin altında performans gösteriyorsa, ilgili çubukların birleşimi, ekibin o görevde beklenenden daha az gün çalışmış gibi görünecektir (bu da muhtemelen görevin son teslim tarihinden sonra tamamlanacağı anlamına gelir).

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()Altyapı:

Çıktı:

Yukarıdaki grafikten, ekiplerin görevlerini tamamlama hızlarının aynı olmadığını görebiliyoruz; bu, birçok gerçek dünya projesinde yaygın bir durumdur. Bu grafikten daha fazla bilgi almak için, bugünün tarihinin 17 Kasım 2022 olduğunu varsayalım ve bu tarihi grafiğimizde işaretleyelim:

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()Altyapı:

Çıktı:

Project X’in mevcut durumu hakkında şu gözlemleri yapabiliriz:

• Ar-Ge ekibi F Görevinde beklenenin üzerinde performans gösteriyor ve muhtemelen son teslim tarihinden önce tamamlayacak.
• BT ekibi G Görevinde gecikmede ve muhtemelen desteğe ihtiyaç duyuyor.
• Satış ekibi H Görevinde takvime uygun ilerliyor.
• Muhasebe ekibi I Görevine proje takviminden önce başladı.

Bu tür gözlemler, ekip liderlerine ve proje yöneticisine proje takvimini buna göre ayarlamada ve gerekli kaynakları zamanında tahsis ederek teslimat gecikmelerini önlemede yardımcı olabilir.

Diğer Olası Ayarlar

Matplotlib Gantt grafiğimize daha fazla ayrıntı ekleyebiliriz. Örneğin:

• Her çubuk üzerinde görev tamamlama yüzdesini ekleme.
• Bazı görevleri alt görevlere ayırma (bunu teknik olarak bu derste daha önce tartıştık).
• İlişkili görevleri anotasyonla belirtme.
• Kritik kilometre taşlarını ve son teslim tarihlerini işaretleme.
• Hafta sonlarını ve tatilleri vurgulama.
• Çubukları ekibe veya görev türüne göre sıralama.
• Bilgi ayrıntı düzeyini artırmak için x eksenine küçük işaretler ekleme.
• Grafiğin genel biçimlendirme ve yerleşimini iyileştirme.

Ancak Gantt grafiğimizi sade tutmak ve çok fazla ayrıntıyla kalabalıklaştırmamak önemlidir. Diğer tüm veri görselleştirme türlerinde olduğu gibi, grafiğin bilgi kapasitesi ile okunabilirliği ve o grafiği oluşturmak için kullanılan kodun okunabilirliği arasında gerekli dengeyi korumalıyız.

Matplotlib ile Python’da Kendi Gantt Grafiğinizi Oluşturmaya Başlayın

Özetle, bu derste şunları inceledik:

• Gantt grafiğinin ne olduğu
• hangi tür bilgileri gösterdiği
• ne zaman kullanıldığı
• matplotlib ile Gantt grafiği oluşturmanın farklı yolları ve incelikleri
• matplotlib ile Python’da Gantt grafiğinin nasıl yapılacağı 
• daha içgörü kazandırmak için nasıl daha fazla ayar yapılacağı
• nihai sonucun nasıl yorumlanacağı. 

Ek olarak, çeşitli Gantt grafiği örneklerine ve bunları adım adım oluşturma sürecine baktık.

Python’da etkileyici ve bilgilendirici grafikler oluşturmayı daha entegre bir yaklaşımla öğrenmek için Data Visualization with Python yetkinlik yolumuza göz atın.