Pandas, NumPy ve Matplotlib ile Veri Analizi

Python'daki her ciddi finansal hesaplama sonunda NumPy üzerinden çalışır. Python listeleri esnek olsa da yavaştır — her eleman tip kontrolü ek yüküyle birlikte tam bir Python nesnesidir. NumPy dizileri ham sayıları bitişik bellek bloklarında saklar, saf Python döngülerinden 100 kat daha hızlı çalışan işlemleri mümkün kılar.

İşte pratikteki fark:

import numpy as np

# 1 milyon rastgele günlük getiriden bir dizi oluştur
returns = np.random.normal(0.0005, 0.02, 1_000_000)

# Vektörleştirilmiş işlemler — döngüye gerek yok
cumulative = np.cumprod(1 + returns)  # $1'in büyümesi
sharpe = returns.mean() / returns.std() * np.sqrt(252)
max_drawdown = np.min(cumulative / np.maximum.accumulate(cumulative) - 1)

print(f"Sharpe Ratio: {sharpe:.3f}")
print(f"Max Drawdown: {max_drawdown:.2%}")

Finans için kilit NumPy kavramları:

• Vektörleştirilmiş işlemler — Eleman eleman döngü yapmak yerine matematiği tüm dizilere aynı anda uygula.
• Broadcasting — Farklı şekillerdeki dizileri aritmetik için otomatik olarak hizala (örn. her elemandan bir skaler ortalamayı çıkarma).
• Lineer cebir — np.linalg, portföy optimizasyonunda kullanılan matris çarpımı, özdeğer ayrışımı ve çözücüler sağlar.
• Rastgele örnekleme — Monte Carlo simülasyonları, bootstrap örneklemesi ve stokastik modelleme hepsi np.random'a bağlıdır.

NumPy motor ise, pandas gösterge panelidir. NumPy dizilerini, finansal veri manipülasyonunu sezgisel ve ifadeli hale getiren etiketli, indeksli yapılara sarar.

İki temel yapı vardır:

• Series — bir indeksle tek bir veri sütunu (düşün: kapanış fiyatlarının bir zaman serisi).
• DataFrame — ortak bir indeksi paylaşan, her biri bir Series olan sütunların bir tablosu (düşün: OHLCV mum grafik verisi).

Veriyi yüklemek ve incelemek basittir:

import pandas as pd

# CSV'den oku
df = pd.read_csv("btc_daily.csv", parse_dates=["date"], index_col="date")

# Veya JSON'dan (API yanıtlarında yaygın)
df = pd.read_json("https://api.example.com/candles?symbol=ETH")

# Hızlı inceleme
print(df.shape)          # (365, 5)
print(df.dtypes)         # Sütun tipleri
print(df.describe())     # İstatistiksel özet
print(df.tail())         # Son 5 satır

Pandas'ı finans için vazgeçilmez kılan şey DatetimeIndex'idir. İndeksin datetime tipinde olduğunda, güçlü zaman serisi işlemlerinin kilidini açarsın:

# Tarih aralığına göre dilimle
q1_data = df["2025-01":"2025-03"]

# Günlük veriyi haftalık OHLC'ye yeniden örnekle
weekly = df["close"].resample("W").ohlc()

# Eksik veriyi ileri doldur (hafta sonları, tatiller)
df = df.asfreq("D").ffill()

Bu işlemler, finansal verinin karmaşık gerçekliklerini — boşluklar, saat dilimi farkları, düzensiz zaman damgaları — halleder, böylece veri tesisatçılığı yerine analize odaklanabilirsin.

Finansal analiz özünde pencereleşmiştir. Tek bir veri noktasını izole bir şekilde nadiren önemsersin — bağlam, onun son geçmişle nasıl ilişkilendiğinden gelir. Pandas'ın .rolling() metodu buradaki birincil aracındır.

import pandas as pd
import numpy as np

# df'nin DatetimeIndex ile bir "close" sütununa sahip olduğunu varsay
df["sma_20"] = df["close"].rolling(20).mean()
df["sma_50"] = df["close"].rolling(50).mean()
df["ema_12"] = df["close"].ewm(span=12).mean()

# Günlük getiriler ve kayan oynaklık
df["returns"] = df["close"].pct_change()
df["vol_30d"] = df["returns"].rolling(30).std() * np.sqrt(365)

# Bollinger Bantları
df["bb_upper"] = df["sma_20"] + 2 * df["close"].rolling(20).std()
df["bb_lower"] = df["sma_20"] - 2 * df["close"].rolling(20).std()

# İki varlık arasında kayan korelasyon
df["corr_btc_eth"] = df["btc_returns"].rolling(60).corr(df["eth_returns"])

Her işlemcinin bilmesi gereken kilit kayan hesaplamalar:

• Basit Hareketli Ortalama (SMA) — N periyot üzerinde eşit ağırlıklı ortalama. Geriden gelen ama kararlı.
• Üstel Hareketli Ortalama (EMA) — .ewm() yoluyla son verilere daha fazla ağırlık verir. Fiyat değişimlerine daha duyarlı.
• Kayan Oynaklık — Bir pencere boyunca getirilerin standart sapması, yıllıklandırılmış. Pozisyon boyutlandırma ve risk bütçeleri için gerekli.
• Kayan Korelasyon — İki varlığın zaman içinde birlikte nasıl hareket ettiğini ölçer. Portföy çeşitlendirmesi için kritik.

GaiaEx gibi platformlarda, geçmiş mum grafik verisini işlem API'si üzerinden çekebilir, bir pandas DataFrame'ine yükleyebilir ve bu göstergeleri saniyeler içinde hesaplayabilirsin — tüm bunlar varlıkların MPC cüzdanında güvende kalırken.

Birden fazla varlığı yönetirken, .groupby() gerekli hale gelir. Veriyi kategoriye göre bölmene, hesaplamalar uygulamana ve sonuçları birleştirmene izin verir — böl-uygula-birleştir kalıbı.

# Birden fazla varlıklı DataFrame
trades = pd.DataFrame({
    "symbol": ["BTC", "ETH", "BTC", "SOL", "ETH", "BTC"],
    "side": ["buy", "buy", "sell", "buy", "sell", "buy"],
    "pnl": [120.5, -45.2, 89.0, 210.3, 55.8, -30.1],
    "volume": [5000, 3200, 4800, 1500, 2900, 5100],
})

# Varlık bazında performans
summary = trades.groupby("symbol").agg(
    total_pnl=("pnl", "sum"),
    avg_pnl=("pnl", "mean"),
    trade_count=("pnl", "count"),
    total_volume=("volume", "sum"),
    win_rate=("pnl", lambda x: (x > 0).mean()),
)

print(summary.sort_values("total_pnl", ascending=False))

Portföy çalışması için ileri seviye agregasyon kalıpları:

• Çok seviyeli groupby — Her varlık için uzun (long) vs kısa (short) performansı görmek için sembol ve yön bazında gruplandır.
• Özel agregasyon fonksiyonları — Her varlık grubu için Sharpe oranlarını, Sortino oranlarını, veya maksimum değer kaybını hesapla.
• Pivot tabloları — Verilerini pd.pivot_table() kullanarak varlık bazında aylık getirileri bir ısı haritası dostu formatta yeniden şekillendir.
• GroupBy ile yeniden örnekleme — Çok varlıklı zaman serisi analizi için zaman tabanlı yeniden örneklemeyi kategorik gruplandırmayla birleştir.

Görselleştirme olmadan veri sadece sayılardır. Matplotlib, analizini ham veride görünmeyen örüntüleri ortaya çıkaran grafiklere dönüştürür.

import matplotlib.pyplot as plt
import matplotlib.dates as mdates

fig, axes = plt.subplots(3, 1, figsize=(14, 10),
                         sharex=True, gridspec_kw={"height_ratios": [3, 1, 1]})

# Fiyat + Hareketli Ortalamalar
axes[0].plot(df.index, df["close"], label="Close", linewidth=1.2)
axes[0].plot(df.index, df["sma_20"], label="SMA 20", linestyle="--")
axes[0].fill_between(df.index, df["bb_upper"], df["bb_lower"],
                     alpha=0.1, color="blue", label="Bollinger Bands")
axes[0].set_ylabel("Price (USD)")
axes[0].legend(loc="upper left")

# Hacim çubukları
colors = ["green" if c > o else "red"
          for c, o in zip(df["close"], df["open"])]
axes[1].bar(df.index, df["volume"], color=colors, alpha=0.7)
axes[1].set_ylabel("Volume")

# Kayan Oynaklık
axes[2].plot(df.index, df["vol_30d"], color="purple")
axes[2].set_ylabel("30d Volatility")
axes[2].axhline(y=0.8, color="red", linestyle=":", alpha=0.5)

axes[2].xaxis.set_major_formatter(mdates.DateFormatter("%b %Y"))
plt.tight_layout()
plt.savefig("analysis_dashboard.png", dpi=150)
plt.show()

Bu, profesyonel bir üç panelli gösterge paneli üretir: üstte Bollinger Bantları ile fiyat hareketi, ortada hacim, ve altta oynaklık. Bu düzen, profesyonel işlem terminallerinde göreceğin şeyi yansıtır.

İstatistiksel görselleştirme için, seaborn Matplotlib üzerine daha yüksek seviyeli fonksiyonlarla inşa eder:

import seaborn as sns

# Getiri dağılımı
sns.histplot(df["returns"].dropna(), bins=100, kde=True)

# Varlıklar arası korelasyon ısı haritası
corr_matrix = portfolio_returns.corr()
sns.heatmap(corr_matrix, annot=True, cmap="RdYlGn", center=0)

Gerçek güç, bu araçları tekrarlanabilir bir hatta zincirlediğinde ortaya çıkar. İşte profesyonel kantitatif analistlerin her gün kullandığı bir iş akışı:

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

def analyze_asset(symbol: str, df: pd.DataFrame) -> dict:
    """Tek bir varlık için tam analiz hattı."""
    df["returns"] = df["close"].pct_change()
    df["log_returns"] = np.log(df["close"] / df["close"].shift(1))

    return {
        "symbol": symbol,
        "total_return": (df["close"].iloc[-1] / df["close"].iloc[0]) - 1,
        "annual_vol": df["returns"].std() * np.sqrt(365),
        "sharpe": df["returns"].mean() / df["returns"].std() * np.sqrt(365),
        "max_drawdown": (df["close"] / df["close"].cummax() - 1).min(),
        "skewness": df["returns"].skew(),
        "kurtosis": df["returns"].kurtosis(),
    }

# Birden fazla varlığı analiz et
results = [analyze_asset(sym, data) for sym, data in assets.items()]
summary = pd.DataFrame(results).set_index("symbol")
print(summary.round(4))

Bu hat, ham fiyat verisini alır ve her varlık için kapsamlı bir risk-getiri profili üretir. Buradan, bu metrikleri bir portföy optimize ediciye besleyebilir, tahsis önerileri üretebilir veya yeniden dengeleme sinyalleri tetikleyebilirsin.

Pandas-NumPy-Matplotlib yığını, Python finansındaki diğer her şeyin üzerine inşa edildiği temeldir. Bu üç kütüphaneyi ustaca öğren ve NYSE'de hisse senedi, GaiaEx'te kripto, veya CME'de türevler işlem yapıyor olsan da, herhangi bir piyasayı analiz edecek, herhangi bir gösterge inşa edecek ve herhangi bir stratejiyi görselleştirecek becerilere sahip olursun.