Matplotlib subplot() Fonksiyonu: Veri Görselleştirmede Ustalaşma

Matplotlib’in subplot() fonksiyonu, Python ile veri görselleştirme yaparken birden fazla grafiği tek bir figür üzerinde düzenlemenin anahtarıdır. Bu güçlü araç sayesinde, karmaşık veri setlerini karşılaştırmalı olarak inceleyebilir, farklı değişkenler arasındaki ilişkileri net bir şekilde ortaya koyabilirsiniz. Peki, bu fonksiyonu en verimli şekilde nasıl kullanabilir ve görselleştirmelerinizi bir üst seviyeye taşıyabilirsiniz? Bu makalede, subplot() dünyasına derinlemesine bir yolculuk yaparak temel prensiplerden ileri düzey uygulamalara kadar her şeyi adım adım öğreneceğiz.

Veri analizi ve bilim alanlarında çalışan herkes, çoğu zaman tek bir grafiğin yetersiz kaldığı durumlarla karşılaşmıştır. Örneğin, bir hisse senedinin fiyat performansını aynı anda işlem hacmiyle karşılaştırmak, bir makine öğrenimi modelinin farklı metriklerini (doğruluk, hassasiyet, geri çağırma) tek bir bakışta görmek veya sensör verilerindeki eğilimleri farklı zaman ölçeklerinde incelemek isteyebilirsiniz. İşte tam bu noktada Matplotlib’in alt grafik (subplot) özelliği devreye girer. Alt grafikler, birden fazla görselleştirmeyi mantıklı bir düzen içinde, tek bir “figure” (figür) üzerinde bir araya getirerek verinin daha kapsamlı anlaşılmasını sağlar. Bu sayede, farklı değişkenler arasındaki korelasyonları veya aynı değişkenin farklı yönlerini hızlıca değerlendirebilirsiniz.

Tek bir grafiğe tüm bilgiyi sıkıştırmaya çalışmak genellikle görsel karmaşaya yol açar ve okunabilirliği büyük ölçüde düşürür. Bu durum, veri odaklı kararlar alırken yanlış yorumlamalara bile sebep olabilir. Oysa alt grafikler, her bir görselleştirmeye kendi alanını tanıyarak, bilgiyi parçalara ayırır ve sindirilmesini kolaylaştırır. Böylece, hem sunumlarınız daha profesyonel bir görünüm kazanır hem de analizleriniz derinlik kazanır. Özellikle büyük veri setleriyle çalışırken veya bir rapor hazırlarken, alt grafiklerin sunduğu düzen ve açıklık paha biçilmezdir. Ayrıca, zaman içinde farklı parametrelerin değişimini izlemek gibi dinamik analizlerde de alt grafikler, karşılaştırmalı bir perspektif sunarak eğilimleri daha net görmemize yardımcı olur. Şimdi bu gücün nasıl kullanılacağına dair temel kavramlara odaklanalım.

Matplotlib’in Temel Taşları: Figure ve Axes Nesneleri

Matplotlib’de görselleştirme yaparken karşılaşacağınız en temel iki kavram “Figure” (Figür) ve “Axes” (Eksenler) nesneleridir. Bu ikili, bir ressamın tuvali ve üzerindeki resim gibi düşünülebilir. Bir “Figure” nesnesi, tüm görselleştirmenizi barındıran genel bir pencere veya kağıt parçasıdır. Bu, grafiklerinizin ve diğer görsel elemanların yer alacağı ana konteynerdir. Başlıklar, genel başlıklar (supertitles), kenar boşlukları ve hatta diğer araç çubukları gibi öğeler bir Figure’e aittir. Bir Matplotlib uygulamasında gördüğünüz her pencere veya kayıt edilen her görüntü, aslında bir Figure nesnesidir.

“Axes” nesnesi ise, Figure içinde yer alan ve asıl verilerin çizildiği bireysel grafikleri temsil eder. Bir Figure birden fazla Axes nesnesi içerebilir ve her Axes nesnesinin kendi X ve Y eksenleri, başlığı, etiketleri ve çizilen verileri (çizgi grafikleri, saçılım grafikleri, çubuk grafikler vb.) bulunur. Matplotlib’de plot(), scatter(), hist() gibi fonksiyonları çağırdığınızda, aslında bu çağrılar bir Axes nesnesi üzerinde gerçekleşir. Yani, verilerinizi gerçekten görselleştiren ve üzerinde manipülasyon yaptığınız yer Axes nesnesidir. Bir figure’ü boş bir tuval gibi hayal ederseniz, axes’ler de bu tuval üzerindeki çerçevelenmiş resimler gibi düşünebilirsiniz. Alt grafikler oluşturduğumuzda, aslında bir Figure içinde birden fazla Axes nesnesi tanımlamış oluyoruz. Bu ayrım, Matplotlib’i anlamak ve özellikle alt grafiklerle çalışırken kontrolü ele almak için kritik öneme sahiptir.

import matplotlib.pyplot as plt
import numpy as np

# Boş bir Figure ve tek bir Axes oluşturalım
fig, ax = plt.subplots() 

# Axes üzerinde bir çizgi grafiği çizelim
ax.plot(np.random.rand(10)) 

# Grafiğe başlık ve eksen etiketleri ekleyelim
ax.set_title("Tek Başına Bir Grafik")
ax.set_xlabel("X Ekseni")
ax.set_ylabel("Y Ekseni")

# Figure'e genel bir başlık ekleyebiliriz
fig.suptitle("Ana Figür Başlığı")

plt.show()

Yukarıdaki kod örneğinde, plt.subplots() fonksiyonu hem bir Figure nesnesi (fig) hem de tek bir Axes nesnesi (ax) döndürür. Daha sonra, tüm çizim işlemleri ax üzerinde yapılırken, fig.suptitle() gibi fonksiyonlar Figure'ün tamamına etki eder. Bu net ayrım sayesinde, alt grafikler oluştururken her bir grafiği bağımsız olarak yönetebilir ve ana figürün genel özelliklerini de kontrol edebiliriz. Bu temel bilgileri anladığımızda, subplot() ve subplots() fonksiyonlarının nasıl çalıştığını kavramak çok daha kolay olacaktır.

subplot() ve subplots() Fonksiyonları Arasındaki Fark Nedir? Nasıl Kullanılırlar?

Matplotlib'de alt grafikler oluşturmanın iki ana yolu vardır: plt.subplot() ve plt.subplots(). Her ikisi de aynı amaca hizmet etse de, kullanımları ve esneklik dereceleri açısından farklılıklar gösterirler. Bu farkları anlamak, ihtiyacınıza en uygun olanı seçmenizi sağlayacaktır.

plt.subplot() ile Adım Adım Alt Grafik Oluşturma

plt.subplot(nrows, ncols, index) fonksiyonu, tek tek alt grafikler oluşturmak istediğinizde kullanışlıdır. Burada nrows toplam satır sayısını, ncols toplam sütun sayısını ve index ise mevcut alt grafiğin konumunu belirtir (1'den başlayarak soldan sağa, yukarıdan aşağıya doğru sayılır). Her plt.subplot() çağrısı, yeni bir Axes nesnesi oluşturur ve onu mevcut Figure'e ekler. Eğer bir Figure henüz oluşturulmamışsa, bu fonksiyon otomatik olarak yeni bir Figure oluşturur.

import matplotlib.pyplot as plt
import numpy as np

# Birincil alt grafik: 2 satır, 1 sütun, 1. grafik
plt.subplot(2, 1, 1) 
plt.plot(np.random.rand(10), color='red')
plt.title("Zaman Serisi A")
plt.ylabel("Değer")

# İkincil alt grafik: 2 satır, 1 sütun, 2. grafik
plt.subplot(2, 1, 2) 
plt.plot(np.random.rand(10) * 10, color='blue')
plt.title("Zaman Serisi B")
plt.ylabel("Hacim")
plt.xlabel("Zaman")

# Grafikler arasındaki boşluğu otomatik ayarla
plt.tight_layout() 
plt.suptitle("subplot() ile İki Zaman Serisi") # Figure genel başlığı
plt.show()

Bu yöntemde, her plt.subplot() çağrısından sonra, o anda aktif olan Axes nesnesi üzerinde çizim yaparsınız. Bu, basit düzenlemeler için yeterli olabilir, ancak birden fazla alt grafiği döngü içinde oluştururken veya Axes nesneleri üzerinde doğrudan kontrol sağlamak istediğinizde biraz hantal kalabilir. Her çağrıda manuel olarak indeks belirtmek, özellikle çok sayıda alt grafikle çalışırken hata yapma olasılığını artırabilir. Ayrıca, tüm Axes nesnelerine aynı anda erişim sağlamak biraz daha karmaşık hale gelir.

plt.subplots() ile Daha Kontrollü Alt Grafik Oluşturma

fig, ax = plt.subplots(nrows, ncols, ...) fonksiyonu, Matplotlib'de alt grafik oluşturmanın tercih edilen yoludur. Bu fonksiyon, bir Figure nesnesi (fig) ve bir veya daha fazla Axes nesnesini (ax) aynı anda döndürür. Eğer tek bir alt grafik oluşturuyorsanız, ax tek bir Axes nesnesi olacaktır. Eğer birden fazla alt grafik oluşturuyorsanız, ax bir NumPy dizisi (array) şeklinde Axes nesnelerini içerecektir. Bu yapı, özellikle döngülerle alt grafikler oluştururken veya her bir alt grafik üzerinde ayrı ayrı işlem yaparken çok daha esneklik ve kontrol sağlar.

import matplotlib.pyplot as plt
import numpy as np

# 2 satır, 2 sütunlu bir alt grafik düzeni oluşturalım
# fig: ana Figure nesnesi
# axs: 2x2 boyutunda Axes nesneleri içeren bir NumPy dizisi
fig, axs = plt.subplots(2, 2, figsize=(10, 8)) 

# Her bir alt grafik üzerinde döngü yaparak çizim yapalım
for i in range(2):
    for j in range(2):
        axs[i, j].plot(np.random.rand(10), label=f'Veri {i*2+j+1}')
        axs[i, j].set_title(f'Grafik ({i+1},{j+1})')
        axs[i, j].legend()

# Grafikler arasındaki boşluğu ayarlayalım
plt.tight_layout()
fig.suptitle("subplots() ile Çoklu Alt Grafikler", fontsize=16) # Figure genel başlığı
plt.show()

plt.subplots() kullanımı, alt grafiklerin düzenini ve Figure boyutunu daha kolay yönetmenizi sağlar (figsize parametresi ile). Ayrıca, axs dizisi sayesinde, her bir alt grafiğe doğrudan erişebilir ve gerektiğinde özelliklerini değiştirebilirsiniz. Bu, özellikle karmaşık düzenlemeler veya dinamik olarak oluşturulan grafik setleri için vazgeçilmez bir özelliktir. sharex=True veya sharey=True gibi parametrelerle eksenleri paylaşma gibi gelişmiş özellikler de plt.subplots() ile çok daha kolay uygulanabilir. Genel olarak, modern Matplotlib kullanımı için plt.subplots() tercih edilen yöntemdir ve daha temiz, daha anlaşılır kod yazmanızı sağlar.

Gelişmiş Alt Grafik Düzenlemeleri ve GridSpec Kullanımı

Matplotlib'in subplot() ve subplots() fonksiyonları çoğu durumda yeterli olsa da, bazen daha karmaşık ve esnek alt grafik düzenlemelerine ihtiyaç duyarız. Örneğin, bazı grafiklerin diğerlerinden daha geniş veya daha uzun olmasını isteyebilir, veya bir grafiğin birden fazla satır veya sütunu kaplamasını sağlayabiliriz. İşte bu gibi senaryolarda GridSpec devreye girer. GridSpec, bir Figure içindeki alt grafiklerin konumlarını ve boyutlarını daha ince tanelerle kontrol etmemizi sağlayan güçlü bir araçtır.

GridSpec ile çalışırken, öncelikle bir kılavuz (grid) tanımlarız ve ardından bu kılavuz içindeki belirli hücreleri veya hücre bloklarını bir alt grafik olarak atarız. Bu, bir tablo yapısı oluşturup hücreleri birleştirmeye benzer. Bu yöntem, özellikle farklı boyutlardaki grafikleri aynı Figure içinde düzenlemek istediğinizde çok kullanışlıdır.

import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import numpy as np

fig = plt.figure(figsize=(12, 8)) # Figure nesnesini manuel oluşturalım

# 3 satır, 3 sütunluk bir ızgara tanımlayalım
gs = gridspec.GridSpec(3, 3, figure=fig)

# Büyük grafik: İlk iki satırı ve ilk iki sütunu kaplasın
ax1 = fig.add_subplot(gs[0:2, 0:2])
ax1.plot(np.random.rand(50).cumsum(), color='purple', label='Büyük Veri Seti')
ax1.set_title('Genel Eğilim (2x2 Alan Kaplayan)')
ax1.legend()

# Küçük grafik 1: İlk satırın son sütununu kaplasın
ax2 = fig.add_subplot(gs[0, 2])
ax2.bar(['A', 'B', 'C'], [10, 20, 15], color='green')
ax2.set_title('Kategorik Dağılım')

# Küçük grafik 2: İkinci satırın son sütununu kaplasın
ax3 = fig.add_subplot(gs[1, 2])
ax3.scatter(np.random.rand(20), np.random.rand(20) * 100, color='orange')
ax3.set_title('Nokta Grafiği')

# Küçük grafik 3: Son satırın tamamını kaplasın (3x1 alan)
ax4 = fig.add_subplot(gs[2, :]) # gs[2, :] -> 3. satırın tüm sütunları
ax4.hist(np.random.randn(1000), bins=30, color='brown', alpha=0.7)
ax4.set_title('Veri Dağılımı (3x1 Alan Kaplayan)')

plt.tight_layout()
fig.suptitle("GridSpec ile Karmaşık Alt Grafik Düzeni", fontsize=18, y=1.02)
plt.show()

Yukarıdaki örnekte görebileceğiniz gibi, GridSpec sayesinde farklı boyut ve konumlandırmalara sahip alt grafikler oluşturabildik. gs[row_start:row_end, col_start:col_end] dilimleme (slicing) yeteneği, istediğimiz alanları birleştirmemizi veya belirli bir aralığı seçmemizi sağlar. Bu yöntem, özellikle görsel hiyerarşi oluşturmak veya belirli bir grafiğin daha fazla dikkat çekmesini sağlamak istediğinizde çok işe yarar. Örneğin, bir ana grafiğin yanına onunla ilgili küçük detay grafikleri yerleştirmek için GridSpec idealdir. Ayrıca, GridSpec'in width_ratios ve height_ratios parametreleri ile satır ve sütunların göreceli genişliklerini ve yüksekliklerini de ayarlayabilirsiniz, bu da görsel dengeyi optimize etmek için harika bir yoldur. GridSpec, Matplotlib'de alt grafik düzenlemede size tam anlamıyla sanatsal bir özgürlük sunar.

Vaka Analizi: Finansal Verilerin Karşılaştırmalı Analizi

Gerçek dünya senaryolarında alt grafiklerin gücünü göstermek için, finansal piyasalardan bir örnek üzerinden ilerleyelim. Bir yatırımcının, belirli bir hisse senedinin fiyat hareketlerini ve işlem hacmini aynı anda inceleyerek daha bilinçli kararlar almak istediğini varsayalım. Genellikle fiyat ve hacim farklı ölçeklerde olduğu için, bunları tek bir grafikte göstermek zorluğa neden olur. Ancak alt grafikler bu sorunu zarif bir şekilde çözer.

Bu senaryoda, bir hisse senedinin günlük kapanış fiyatlarını ve günlük işlem hacmini içeren sahte veriler kullanacağız. Amacımız, fiyatın nasıl hareket ettiğini ve bu hareketlerin hangi işlem hacimleri ile desteklendiğini aynı figür üzerinde net bir şekilde göstermektir.

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from datetime import datetime, timedelta

# Sahte finansal veri oluşturalım
dates = [datetime.now() - timedelta(days=i) for i in range(100)]
dates.reverse() # Tarihleri kronolojik sıraya koy

# Rastgele hisse senedi fiyatı simülasyonu
prices = np.random.normal(loc=100, scale=5, size=100).cumsum() + 50
# İşlem hacmi simülasyonu (fiyat hareketleriyle ilişkili olabilir)
volume = np.random.normal(loc=100000, scale=20000, size=100)
# Fiyatlardaki ani artışlarda hacmi biraz artıralım
for i in range(1, len(prices)):
    if prices[i] > prices[i-1] * 1.02: # Fiyatta %2'den fazla artış varsa
        volume[i] *= np.random.uniform(1.2, 1.5) # Hacmi artır

df = pd.DataFrame({'Date': dates, 'Price': prices, 'Volume': volume})
df.set_index('Date', inplace=True)

# plt.subplots() kullanarak iki alt grafik oluşturalım
# sharex=True ile X eksenini paylaşarak kaydırma ve zoom'u senkronize edelim
fig, (ax_price, ax_volume) = plt.subplots(2, 1, figsize=(12, 8), sharex=True)

# Fiyat grafiği
ax_price.plot(df.index, df['Price'], color='blue', label='Kapanış Fiyatı')
ax_price.set_title('Hisse Senedi Fiyat ve Hacim Analizi', fontsize=16)
ax_price.set_ylabel('Fiyat ($)', color='blue')
ax_price.tick_params(axis='y', labelcolor='blue')
ax_price.grid(True, linestyle='--', alpha=0.7)
ax_price.legend(loc='upper left')

# Hacim grafiği
ax_volume.bar(df.index, df['Volume'], color='green', alpha=0.6, label='İşlem Hacmi')
ax_volume.set_ylabel('Hacim', color='green')
ax_volume.set_xlabel('Tarih')
ax_volume.tick_params(axis='y', labelcolor='green')
ax_volume.grid(True, linestyle='--', alpha=0.7)
ax_volume.legend(loc='upper left')

# X ekseni etiketlerini daha okunur hale getirelim
fig.autofmt_xdate()

# Grafikler arasındaki boşluğu ayarlayalım
plt.tight_layout(rect=[0, 0.03, 1, 0.95]) # fig.suptitle için yer bırak

plt.show()

Bu örnekte, plt.subplots(2, 1, ..., sharex=True) kullanarak üst üste iki alt grafik oluşturduk ve X eksenlerini paylaştırdık. Bu sayede, kullanıcı bir grafikte kaydırma veya yakınlaştırma yaptığında, diğer grafik de otomatik olarak senkronize olur. Bu, özellikle zaman serisi verilerinde karşılaştırmalı analiz yaparken son derece önemlidir. Hacim grafiğinde çubuk grafik kullanırken, fiyat grafiğinde çizgi grafik kullanarak farklı görselleştirme türlerini aynı figür üzerinde başarıyla birleştirdik. Renk kodlaması ve başlıklar sayesinde her iki grafiğin neyi temsil ettiği açıkça belirtildi. Bu tür bir düzenleme, finansal verileri yorumlarken eğilimleri, anormallikleri ve korelasyonları çok daha hızlı ve etkili bir şekilde görmemizi sağlar. Örneğin, bir fiyat artışının yüksek hacimle desteklenip desteklenmediğini tek bir bakışta anlayabiliriz. Bu, finansal analistler için vazgeçilmez bir görselleştirme tekniğidir.

Alt Grafiklerde Eksenleri Paylaşma ve İç İçe Grafikler

Alt grafiklerle çalışırken, bazen farklı grafiklerin eksenlerini paylaşmak isteyebiliriz. Bu, özellikle aynı birimdeki veya aynı zaman çizelgesindeki verileri karşılaştırırken görsel tutarlılığı sağlamak ve gereksiz eksen etiketlerini kaldırmak için harika bir yoldur. Matplotlib, plt.subplots() fonksiyonunun sharex ve sharey parametreleri aracılığıyla bu özelliği kolayca sunar.

Eksenleri Paylaşma

sharex=True veya sharey=True parametrelerini kullanarak, belirtilen eksenin tüm alt grafiklerde aynı olmasını sağlayabiliriz. Bu, kullanıcı bir alt grafikte yakınlaştırma veya kaydırma yaptığında, diğer tüm paylaşılan eksenlere sahip alt grafiklerin de buna göre ayarlanacağı anlamına gelir. Bu, özellikle zaman serisi verilerinde veya aynı ölçüm birimine sahip farklı değişkenleri karşılaştırırken veri yorumlamayı kolaylaştırır.

import matplotlib.pyplot as plt
import numpy as np

# 3 alt grafik, hepsi X eksenini paylaşacak
fig, axs = plt.subplots(3, 1, figsize=(10, 8), sharex=True)

# Veri oluşturma
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x) * 2
y3 = np.sin(x * 2) + np.random.rand(100) * 0.5

# Her bir alt grafiğe çizim yapma
axs[0].plot(x, y1, color='red')
axs[0].set_title('Sinüs Dalga')
axs[0].set_ylabel('Y1')
axs[0].grid(True)

axs[1].plot(x, y2, color='blue')
axs[1].set_title('Kosinüs Dalga (genliği 2x)')
axs[1].set_ylabel('Y2')
axs[1].grid(True)

axs[2].plot(x, y3, color='green')
axs[2].set_title('Gürültülü Sinüs Dalga')
axs[2].set_ylabel('Y3')
axs[2].set_xlabel('Ortak X Ekseni') # Sadece en alt grafikte X ekseni etiketi gösterilir
axs[2].grid(True)

fig.suptitle("Paylaşılan X Ekseni ile Üç Alt Grafik", fontsize=16)
plt.tight_layout(rect=[0, 0.03, 1, 0.95])
plt.show()

Bu örnekte, üç alt grafik de aynı X eksenini paylaştığı için, sadece en alttaki grafikte X ekseni etiketleri gösterilir. Bu, görsel dağınıklığı azaltır ve grafiğin daha temiz görünmesini sağlar.

İç İçe (Inset) Grafikler

Bazen bir ana grafiğin belirli bir bölgesini daha yakından incelemek veya bir ana grafiğin içine küçük bir özet grafik eklemek isteyebiliriz. Matplotlib'de bu, "inset" veya "iç içe" grafikler olarak bilinir ve genellikle fig.add_axes() veya ax.inset_axes() fonksiyonları ile yapılır. ax.inset_axes(), mevcut bir Axes nesnesine bağıl olarak konumlandırıldığı için daha kullanışlıdır.

import matplotlib.pyplot as plt
import numpy as np

# Ana grafik için Figure ve Axes oluşturalım
fig, ax = plt.subplots(figsize=(10, 6))

# Ana grafik verisi
x = np.linspace(0, 10, 500)
y = np.sin(x) + x/5

ax.plot(x, y, label='Ana Veri Eğilimi', color='darkcyan', linewidth=2)
ax.set_title('Ana Grafik ve Detaylı Bölge', fontsize=16)
ax.set_xlabel('X Ekseni')
ax.set_ylabel('Y Ekseni')
ax.grid(True, linestyle='--', alpha=0.6)
ax.legend()

# İç içe (inset) grafik oluşturalım
# [x, y, width, height] formatında konum ve boyutlar (ana eksenlere göre oranlar)
inset_ax = ax.inset_axes([0.6, 0.6, 0.35, 0.35]) 

# Inset grafik için daha dar bir X aralığı belirleyelim (ana grafiğin bir kısmı)
x_zoom = x[(x > 3) & (x < 5)]
y_zoom = y[(x > 3) & (x < 5)]

inset_ax.plot(x_zoom, y_zoom, color='red', linewidth=1.5)
inset_ax.set_title('Yakınlaştırılmış Bölge', fontsize=10)
inset_ax.set_xlim(3, 5) # Inset grafiğin kendi eksen limitleri
inset_ax.set_ylim(0.5, 2.5)
inset_ax.grid(True, linestyle=':', alpha=0.5)

# Ana grafikte yakınlaştırılan bölgeyi belirtmek için dikdörtgen ekleyelim
ax.indicate_inset_zoom(inset_ax, edgecolor="black", alpha=0.8)

plt.tight_layout()
plt.show()

Bu örnekte, ana grafiğin içine, belirli bir X aralığının daha detaylı görünümünü sunan küçük bir grafik yerleştirdik. ax.inset_axes([x_konum, y_konum, genişlik, yükseklik]) ile inset grafiğin konumunu ve boyutunu ana Axes nesnesine göre oran olarak ayarladık. Ayrıca ax.indicate_inset_zoom() fonksiyonu ile ana grafikte hangi bölgenin yakınlaştırıldığını görsel olarak belirten bir dikdörtgen de ekledik. Bu teknik, veri biliminde belirli anormallikleri veya ilgi çekici noktaları vurgulamak için sıkça kullanılır.

Mobil Cihazlarda Matplotlib Grafikleri: Duyarlı Tasarım İpuçları

Günümüzde veri görselleştirmeleri sadece masaüstü bilgisayarlarda değil, tabletler ve akıllı telefonlar gibi çeşitli ekran boyutlarına sahip mobil cihazlarda da görüntülenmektedir. Bu nedenle, Matplotlib ile oluşturduğunuz grafiklerin farklı ekran boyutlarına uyum sağlayabilmesi (duyarlı tasarım) kritik öneme sahiptir. Matplotlib'in kendisi doğrudan "duyarlı" HTML çıktıları üretmez, ancak çizilen grafikleri web sayfalarına gömerken veya interaktif web uygulamaları geliştirirken, CSS ve JavaScript ile bu duyarlılığı sağlayabiliriz.

Figür Boyutunu ve Çözünürlüğü Ayarlama

Matplotlib'de duyarlı bir yaklaşımın ilk adımı, grafiğin genel boyutunu ve çözünürlüğünü uygun şekilde ayarlamaktır. plt.figure(figsize=(genişlik, yükseklik), dpi=çözünürlük) parametreleri bu konuda size yardımcı olur. Genişlik ve yükseklik genellikle inç cinsindendir.

import matplotlib.pyplot as plt
import numpy as np

# Daha küçük bir figür boyutu tanımlayarak mobil uyumlu bir başlangıç yapabiliriz
# Ya da yüzde bazında ayarlamalar için sonraki CSS adımlarına geçebiliriz.
fig, ax = plt.subplots(figsize=(6, 4), dpi=100) # Örneğin, daha küçük bir varsayılan boyut
ax.plot(np.sin(np.linspace(0, 10, 100)))
ax.set_title("Mobil Dostu Grafik Örneği")
plt.tight_layout()
plt.savefig('mobil_grafik.png', bbox_inches='tight') # PNG olarak kaydedelim
plt.close(fig) # Figure'ü kapat

Web için statik bir görüntü oluşturuyorsanız, daha yüksek bir dpi değeri, görüntünün daha az pikselli görünmesini sağlar, ancak dosya boyutunu da artırır. Mobil cihazlar için ideal olan, hem okunabilirliği koruyan hem de hızlı yüklenen bir denge bulmaktır.

Web Sayfalarına Gömme ve CSS ile Duyarlılık

Matplotlib grafiğini bir web sayfasına gömdüğünüzde (genellikle bir PNG veya SVG dosyası olarak), CSS kullanarak duyarlı hale getirebilirsiniz. SVG formatı, vektör tabanlı olduğu için kalite kaybı olmadan yeniden boyutlandırılabilir ve bu nedenle web için daha çok tercih edilebilir.

    
    
    
    


    

        
Fiyat ve Hacim Analizi (Duyarlı)
        
        
Bu grafik, hisse senedi performansını ve işlem hacmini göstermektedir.
    

Yukarıdaki HTML ve CSS kodunda, .responsive-chart sınıfına uygulanan max-width: 100%; height: auto; özellikleri, resmin içinde bulunduğu konteynerin genişliğine göre otomatik olarak boyutlanmasını ve en boy oranını korumasını sağlar. @media kuralları ise farklı ekran boyutları için (örneğin, 768px ve 480px altında) özel stil ayarlamaları yaparak grafiğin daha da optimize edilmesini sağlar. Bu yöntemlerle, Matplotlib ile oluşturduğunuz görselleştirmelerinizi mobil dostu hale getirebilir ve geniş bir kullanıcı kitlesine ulaşabilirsiniz. Unutmayın ki, eğer interaktif grafikler istiyorsanız Plotly veya Bokeh gibi kütüphaneleri kullanmak daha doğru bir yaklaşım olabilir, ancak Matplotlib'in statik çıktıları bile doğru CSS ile duyarlı hale getirilebilir.

Sonuç: Matplotlib subplot() ile Görselleştirmelerinizi Güçlendirin

Matplotlib'in subplot() ve subplots() fonksiyonları, Python ile veri görselleştirme yaparken birden fazla grafiği tek bir figür üzerinde düzenlemek için vazgeçilmez araçlardır. Bu makale boyunca, bu fonksiyonların temel kullanımından, GridSpec ile karmaşık düzenlemelere, finansal veri analizi gibi gerçek dünya senaryolarına ve hatta mobil cihazlarda duyarlı grafik tasarımına kadar geniş bir yelpazeyi ele aldık. Gördüğünüz gibi, alt grafikler sadece estetik bir düzenleme sağlamakla kalmaz, aynı zamanda veriler arasındaki ilişkileri daha net bir şekilde anlamanıza ve karşılaştırmalı analizler yapmanıza olanak tanır.

plt.subplot() basit, tekil alt grafikler için yeterliyken, plt.subplots() daha modern ve kontrollü bir yaklaşım sunarak Figure ve Axes nesnelerine doğrudan erişim imkanı sağlar. GridSpec ise, farklı boyutlardaki grafikleri aynı figür üzerinde esnek bir şekilde konumlandırma ihtiyacınız olduğunda devreye girer. Eksenleri paylaşma ve iç içe grafikler gibi ileri düzey teknikler, görselleştirmelerinize derinlik katarken, mobil uyumlu tasarım ipuçları da çalışmalarınızın daha geniş kitlelere ulaşmasını sağlar. Matplotlib'in bu güçlü araçlarını ustaca kullanarak, veri hikayelerinizi daha etkili ve anlaşılır bir şekilde anlatabilir, böylece analizlerinizin etkisini artırabilirsiniz. Veri biliminde ve görselleştirmede başarılı olmak için bu fonksiyonları pratik yaparak içselleştirmeniz şiddetle tavsiye edilir.

Sıkça Sorulan Sorular (SSS)

Aşağıda Matplotlib'deki alt grafiklerle ilgili sıkça sorulan bazı soruları ve cevaplarını bulabilirsiniz:

1. plt.subplot() ve plt.subplots() arasında ne fark vardır?
   plt.subplot(nrows, ncols, index), her çağrıda aktif alt grafiği belirleyerek tek tek alt grafikler oluşturur. Mevcut bir figür yoksa yeni bir figür yaratır. Buna karşılık, plt.subplots(nrows, ncols) hem bir Figure nesnesi hem de bir veya daha fazla Axes nesnesi döndürür, bu da özellikle birden fazla alt grafik üzerinde döngü yaparak veya toplu işlemler yaparak daha kontrollü ve modern bir yaklaşım sunar. Genellikle plt.subplots() tercih edilir.
2. Alt grafiklerimin eksen etiketleri veya başlıkları üst üste biniyor, bunu nasıl düzeltirim?
   Bu yaygın bir sorundur. Genellikle plt.tight_layout() fonksiyonunu kullanarak grafiğinizdeki boşlukları otomatik olarak ayarlayabilirsiniz. Daha karmaşık durumlarda, fig.subplots_adjust() ile manuel olarak kenar boşluklarını ve alt grafikler arası boşlukları kontrol edebilirsiniz.
3. Bir alt grafiğin boyutunu diğerlerinden farklı yapmak mümkün müdür?
   Evet, bu matplotlib.gridspec.GridSpec sınıfını kullanarak mümkündür. GridSpec, bir figür içindeki alt grafiklerin konumlarını ve boyutlarını daha esnek bir şekilde tanımlamanıza olanak tanır. Belirli alt grafikleri birden fazla satır veya sütun kaplayacak şekilde ayarlayabilirsiniz.
4. Alt grafikler arasında X veya Y eksenini nasıl paylaşabilirim?
   plt.subplots() fonksiyonunu kullanırken sharex=True veya sharey=True parametrelerini ayarlayarak eksenleri paylaşabilirsiniz. Bu, ilgili eksen limitlerinin ve kaydırma/yakınlaştırma işlemlerinin tüm paylaşılan eksenlerde senkronize olmasını sağlar, görsel tutarlılığı artırır ve gereksiz etiketleri gizler.
5. Matplotlib grafikleri mobil cihazlarda duyarlı olacak şekilde nasıl tasarlanır?
   Matplotlib doğrudan duyarlı HTML üretmese de, grafiği bir PNG veya SVG dosyası olarak kaydedip bir web sayfasına gömdükten sonra CSS (Cascading Style Sheets) kullanarak duyarlı hale getirebilirsiniz. Özellikle max-width: 100%; height: auto; gibi CSS özellikleri ve @media sorguları ile farklı ekran boyutlarına uyum sağlayacak stiller tanımlayabilirsiniz.