0Pricing
Pandas & NumPy Academy · Ders

Kayan Pencereler

rolling(n).mean() ve ilgili yöntemlerle sabit sayıda satır üzerinden kayan ortalamaları, toplamları ve standart sapmaları hesaplayın.

Kayan Pencereler, CoddyKit'te ücretsiz bir Pandas & NumPy Academy dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Pandas & NumPy Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Pandas & NumPy Academy kursu toplamda 4 dersten oluşur.

Kayan Pencereler Nedir?

Kayan pencere (kaydırmalı pencere veya hareketli pencere olarak da adlandırılır), her seferinde bir satır ilerlerken art arda gelen satırlardan oluşan sabit boyutlu bir pencere üzerinde bir istatistik hesaplar. Örneğin, 7 günlük kayan ortalama, her günün değerini o gün ile önceki 6 günün ortalamasıyla değiştirir. Kayan pencereler finansta hareketli ortalamaların, gürültülü sensör verilerinin yumuşatılmasının ve işletme panolarındaki geriye dönük ölçümlerin temelini oluşturur.

import pandas as pd
import numpy as np

# Simple example: 3-day rolling mean
data = pd.Series([10, 12, 15, 11, 9, 13, 16, 14, 12, 18],
                 index=pd.date_range('2024-01-01', periods=10))

rolling_mean = data.rolling(window=3).mean()
print('Original:')
print(data.values)
print('\n3-day rolling mean:')
print(rolling_mean.values.round(2))

rolling() Yöntemi ve window Parametresi

Series.rolling(window=n) bir Rolling nesnesi döndürür. window parametresi, kayan pencerenin tamsayı pencerelerinde satır cinsinden boyutunu veya zaman dizinli Series için '7D' gibi bir zaman ofsetini belirtir. Kayan nesneyi oluşturduktan sonra herhangi bir toplama yöntemini zincirleyebilirsiniz: .mean(), .sum(), .std(), .min(), .max() veya .apply(func). İlk window-1 satır her zaman NaN olur; çünkü pencereyi doldurmak için yeterli önceki satır yoktur.

import pandas as pd
import numpy as np

prices = pd.Series(
    [100, 102, 98, 105, 110, 108, 115, 112, 120, 118],
    index=pd.date_range('2024-01-01', periods=10),
    name='price'
)

df = pd.DataFrame({'price': prices})
df['MA3'] = df['price'].rolling(3).mean()
df['MA7'] = df['price'].rolling(7).mean()
df['std3'] = df['price'].rolling(3).std()
print(df.round(2))

min_periods Parametresi

Varsayılan olarak rolling(n), bir sonuç hesaplamadan önce pencerede tam olarak n adet NaN olmayan değer bulunmasını gerektirir. min_periods parametresi bu gereksinimi azaltır — örneğin rolling(7, min_periods=3), en az 3 değer kullanılabilir olur olmaz ortalamayı hesaplayarak Series içinde daha erken NaN olmayan değerler üretir. Bu, bir zaman serisinin başlangıcında ilk n-1 satır için NaN döndürmek yerine hareketli ortalamaları elde etmek istediğinizde kullanışlıdır.

import pandas as pd
import numpy as np

prices = pd.Series([100, 102, 98, 105, 110, 108, 115],
                   index=pd.date_range('2024-01-01', periods=7))

# Default: first 6 rows are NaN
ma7_default = prices.rolling(7).mean()

# min_periods=3: compute mean once 3 values available
ma7_minperiods = prices.rolling(7, min_periods=3).mean()

df = pd.DataFrame({
    'price': prices,
    'MA7_default': ma7_default,
    'MA7_min3': ma7_minperiods
})
print(df.round(2))

Devam Eden Toplamlar için Kayan Toplam

rolling(n).sum(), her konumda son n satırın toplamını hesaplar. Günlük satışların 30 günlük kayan toplamı, her gün için geriye dönük aylık geliri verir — her gün güncellendiği için sabit bir aylık toplamdan daha bilgilendiricidir. Kayan toplamlar perakende analitiğinde (son 30 günlük satışlar), web analitiğinde (son 7 gündeki etkin kullanıcılar) ve finansta (son n dönemin hacmi) yaygın olarak kullanılır.

import pandas as pd
import numpy as np

np.random.seed(42)
dates = pd.date_range('2024-01-01', periods=60)
daily_sales = pd.Series(np.random.randint(100, 500, 60), index=dates, name='daily_sales')

df = pd.DataFrame({'daily_sales': daily_sales})
df['trailing_7d'] = df['daily_sales'].rolling(7).sum()
df['trailing_30d'] = df['daily_sales'].rolling(30).sum()

print(df.tail(10).round(0))

Oynaklık için Kayan Standart Sapma

Finansta oynaklık, günlük getirilerin kayan standart sapması olarak ölçülür. Yüksek bir kayan std, fiyatların büyük dalgalanmalar gösterdiği; düşük bir kayan std ise fiyatların istikrarlı olduğu anlamına gelir. Bu ölçüm, opsiyon fiyatlaması ve portföy yönetimindeki risk hesaplamalarını yönlendirir. Formül şöyledir: np.log(price/price.shift(1)) ile günlük logaritmik getirileri hesaplayın, ardından rolling(window).std() uygulayın.

import pandas as pd
import numpy as np

np.random.seed(0)
prices = pd.Series(
    100 * np.exp(np.cumsum(np.random.normal(0.001, 0.02, 120))),
    index=pd.date_range('2024-01-01', periods=120)
)

# Daily log returns
log_returns = np.log(prices / prices.shift(1))

# 20-day rolling volatility (annualised)
volatility = log_returns.rolling(20).std() * np.sqrt(252)

print('Last 5 rows of daily volatility:')
print(volatility.tail(5).round(4))

Zamana Dayalı Kayan Pencereler

Sabit bir satır sayısı yerine pencere olarak bir zaman ofseti belirtebilirsiniz: rolling('7D'), 'verilerin son 7 takvim günü' anlamına gelir. Bu, düzensiz zaman serilerini (eksik hafta sonları ve tatiller) otomatik olarak doğru biçimde ele alır — satır sayısına dayalı bir pencere, aralıklara bağlı olarak farklı miktarda takvim zamanını kapsarken zaman ofsetine dayalı bir pencere her zaman tam 7 günlük veriyi kapsar. Zamana dayalı pencereler için Series'in bir DatetimeIndex'e sahip olması gerekir.

import pandas as pd
import numpy as np

# Business-day index (no weekends)
biz_dates = pd.bdate_range('2024-01-01', periods=15)
sales = pd.Series(np.random.randint(100, 300, 15), index=biz_dates)

# 7-calendar-day window (variable row count near weekends)
df = pd.DataFrame({'sales': sales})
df['rolling_7d'] = sales.rolling('7D').mean()

print(df.round(1))

Özel İşlevler için Kayan Apply

rolling(n).apply(func), her pencereyi özel işlevinize NumPy dizisi olarak aktarır. Bu, yerleşik toplama yöntemlerinin kapsamadığı tüm kayan hesaplamaları yapmanızı sağlar — örneğin kayan medyan mutlak sapması, kayan çarpıklık veya kayan birinci çeyrek. İşlev, tek boyutlu bir diziyi kabul etmeli ve tek bir skaler değer döndürmelidir. Not: apply, vektörleştirilemediği için yerleşik yöntemlerden daha yavaştır.

import pandas as pd
import numpy as np

prices = pd.Series(
    [100, 102, 98, 105, 110, 95, 115, 112, 120, 108],
    index=pd.date_range('2024-01-01', periods=10)
)

# Rolling range (max - min) over a 5-day window
def rolling_range(arr):
    return arr.max() - arr.min()

df = pd.DataFrame({'price': prices})
df['5d_range'] = prices.rolling(5).apply(rolling_range, raw=True)
print(df.round(2))

DataFrame Sütunlarında Kayan Pencereler

Tüm sayısal sütunlar için kayan istatistikleri aynı anda hesaplamak üzere rolling().mean() yöntemini doğrudan bir DataFrame'e uygulayabilirsiniz. Her sütun için kendi kayan penceresi bağımsız olarak hesaplanır. Bu, sütunlar üzerinde döngü kurmadan birden çok hisse senedi fiyatının veya birden çok ürün satış serisinin hareketli ortalamalarını tek bir işlemde hesaplamak için kullanışlıdır.

import pandas as pd
import numpy as np

np.random.seed(42)
dates = pd.date_range('2024-01-01', periods=10)
df = pd.DataFrame({
    'AAPL': 100 + np.cumsum(np.random.randn(10)),
    'MSFT': 200 + np.cumsum(np.random.randn(10)),
    'GOOG': 150 + np.cumsum(np.random.randn(10))
}, index=dates)

# 3-day moving average of all three stocks
ma3 = df.rolling(3).mean()
print('3-day MA for all stocks:')
print(ma3.round(2))

Kayan Ortalamayı Özgün Verilerle Birleştirme

Yaygın bir görselleştirme yaklaşımı, ham zaman serisini ve kayan ortalamasını aynı eksenler üzerinde çizmektir. Kayan ortalama, günlük gürültüyü yumuşatarak eğilimi ortaya çıkarırken ham seri oynaklığı gösterir. İkisi arasındaki fark, mevcut gürültünün miktarını belirtir. Bir DataFrame'e kayan ortalama eklemek, sonucu yeni bir sütuna atamak kadar basittir.

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

np.random.seed(42)
dates = pd.date_range('2024-01-01', periods=60)
sales = pd.Series(
    200 + np.cumsum(np.random.randn(60) * 10),
    index=dates, name='Daily Sales'
)

df = pd.DataFrame({'sales': sales})
df['MA7'] = df['sales'].rolling(7).mean()
df['MA30'] = df['sales'].rolling(30).mean()

df.plot(figsize=(12, 5), title='Sales with 7-day and 30-day Moving Average')
plt.ylabel('Sales')
plt.show()

Merkezlenmiş Kayan Pencereler

Varsayılan olarak rolling, geriye dönük bir pencere kullanır (geçerli satır ve önceki n-1 satır). center=True ayarı, geçerli satırın ortada bulunduğu ve eşit sayıda geçmiş ve gelecek satırın kullanıldığı merkezlenmiş bir pencere oluşturur. Merkezlenmiş pencereler daha yumuşak sonuçlar üretir ve gelecek değerlerin bilindiği geçmiş verilerin çevrimdışı yumuşatılması için uygundur. Gelecek verileri gerektirdikleri için canlı tahminlerde uygun DEĞİLDİR.

import pandas as pd
import numpy as np

np.random.seed(0)
data = pd.Series(
    np.sin(np.linspace(0, 4*3.14159, 30)) + np.random.normal(0, 0.3, 30)
)

df = pd.DataFrame({'signal': data})
df['trailing_MA5'] = data.rolling(5).mean()
df['centered_MA5'] = data.rolling(5, center=True).mean()

print('Comparison (first 8 rows):')
print(df.head(8).round(3))

GroupBy Verileri için Kayan Pencereler

groupby().rolling() kullanarak grup bazında kayan istatistikler hesaplayabilirsiniz. Örneğin, her ürün kategorisi için 7 günlük kayan geliri hesaplarken pencere her grubun başlangıcında sıfırlanır; böylece bir ürünün verileri başka bir ürüne taşmaz. Kayan işlemden sonra dizindeki fazladan grup düzeyini kaldırmak ve sonucu özgün DataFrame ile hizalamak için .reset_index(level=0, drop=True) kullanın.

import pandas as pd
import numpy as np

np.random.seed(42)
dates = pd.date_range('2024-01-01', periods=10)
df = pd.DataFrame({
    'date': list(dates) * 2,
    'product': ['A'] * 10 + ['B'] * 10,
    'sales': np.random.randint(50, 200, 20)
}).sort_values(['product', 'date'])

# 3-day rolling mean per product
df['rolling_mean'] = (df
    .groupby('product')['sales']
    .transform(lambda x: x.rolling(3).mean())
)
print(df.to_string(index=False))

Hızlı Kontrol

Bu derste öğrendiğiniz kayan pencereler konusundaki anlayışınızı sınayın.

Ders Özeti

Bu derste şunları öğrendiniz: rolling(n), ortalama, toplam, std, min, max veya özel işlevler hesaplayabileceğiniz n satırlık bir kaydırmalı pencere oluşturur; min_periods, bir sonuç hesaplamak için gereken en az değer sayısını azaltır ve center=True, çevrimdışı yumuşatma için merkezlenmiş pencereler oluşturur. Sırada, Series'in başlangıcından itibaren büyüyen kümülatif istatistikleri sağlayan genişleyen pencereleri inceleyeceğiz.

Sıkça Sorulan Sorular

“Kayan Pencereler” dersi ücretsiz mi?

Evet — “Kayan Pencereler” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Pandas & NumPy Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Pandas & NumPy Academy kursu toplamda 4 dersten oluşur.

“Kayan Pencereler” dersinde ne öğreneceğim?

rolling(n).mean() ve ilgili yöntemlerle sabit sayıda satır üzerinden kayan ortalamaları, toplamları ve standart sapmaları hesaplayın. Pandas & NumPy Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Pandas & NumPy Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Pandas & NumPy Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“Kayan Pencereler” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Pandas & NumPy Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Pandas & NumPy Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Kayan Pencereler
  2. Genişleyen Pencereler
  3. Üstel Ağırlıklı Hareketli Ortalama
  4. Gruplar İçinde Sıra ve Yüzdelik Dilim
← Pandas & NumPy Academy Sayfasına Dön