Pandas & NumPy Academy · Lektion

Rollende Fenster

Berechnen Sie mit rolling(n).mean() und verwandten Methoden gleitende Mittelwerte, Summen und Standardabweichungen über eine feste Anzahl von Zeilen.

Rollende Fenster ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind Rolling Windows?

Ein Rolling Window (auch gleitendes Fenster oder Moving Window genannt) berechnet eine Statistik über ein Fenster fester Größe aus aufeinanderfolgenden Zeilen, während es sich jeweils um eine Zeile weiterbewegt. Beispielsweise ersetzt ein gleitender 7-Tage-Mittelwert den Wert jedes Tages durch den Durchschnitt dieses Tages und der 6 vorhergehenden Tage. Rolling Windows bilden die Grundlage für gleitende Mittelwerte im Finanzwesen, die Glättung verrauschter Sensordaten und die Berechnung von nachlaufenden Kennzahlen in Unternehmens-Dashboards.

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

Die Methode rolling() und der Parameter window

Series.rolling(window=n) gibt ein Rolling-Objekt zurück. Der Parameter window gibt die Größe des gleitenden Fensters an: bei ganzzahligen Fenstern als Anzahl der Zeilen oder bei zeitindexierten Series als Zeitspanne wie '7D'. Nach dem Erstellen des Rolling-Objekts können Sie beliebige Aggregationsmethoden verketten: .mean(), .sum(), .std(), .min(), .max() oder sogar .apply(func). Die ersten window-1 Zeilen sind immer NaN, weil nicht genügend vorhergehende Zeilen vorhanden sind, um das Fenster zu füllen.

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

Der Parameter min_periods

Standardmäßig benötigt rolling(n) genau n Werte, die nicht NaN sind, bevor im Fenster ein Ergebnis berechnet wird. Der Parameter min_periods reduziert diese Anforderung – beispielsweise berechnet rolling(7, min_periods=3) den Mittelwert, sobald mindestens 3 Werte verfügbar sind, und erzeugt dadurch früher in der Series Nicht-NaN-Werte. Das ist nützlich, wenn Sie bereits am Anfang einer Zeitreihe gleitende Mittelwerte statt NaN für die ersten n-1 Zeilen benötigen.

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

Gleitende Summe für laufende Summen

rolling(n).sum() berechnet an jeder Position die Summe der letzten n Zeilen. Eine gleitende 30-Tage-Summe der täglichen Umsätze liefert für jeden Tag den Umsatz des zurückliegenden Monats – sie ist aussagekräftiger als eine statische Monatssumme, da sie täglich aktualisiert wird. Gleitende Summen werden häufig in der Einzelhandelsanalyse (Umsatz der letzten 30 Tage), Webanalyse (aktive Nutzer der letzten 7 Tage) und im Finanzwesen (Volumen der letzten n Perioden) eingesetzt.

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

Gleitende Standardabweichung für die Volatilität

Im Finanzwesen wird die Volatilität als gleitende Standardabweichung der täglichen Renditen gemessen. Eine hohe gleitende Standardabweichung bedeutet, dass die Preise stark schwanken; eine niedrige weist auf stabile Preise hin. Diese Kennzahl fließt in Risikoberechnungen bei der Optionspreisermittlung und der Portfolioverwaltung ein. Die Formel lautet: Berechnen Sie die täglichen logarithmischen Renditen mit np.log(price/price.shift(1)) und wenden Sie anschließend rolling(window).std() an.

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

Zeitbasierte Rolling Windows

Statt einer festen Zeilenanzahl können Sie als Fenster eine Zeitspanne angeben: rolling('7D') bedeutet „die Daten der letzten 7 Kalendertage“. Dadurch werden unregelmäßige Zeitreihen (fehlende Wochenenden, Feiertage) automatisch korrekt behandelt – ein Fenster nach Zeilenanzahl würde abhängig von Lücken unterschiedlich viel Kalenderzeit umfassen, während ein Fenster nach Zeitspanne immer genau 7 Tage abdeckt. Die Series muss für zeitbasierte Fenster einen DatetimeIndex besitzen.

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

Rolling Apply für benutzerdefinierte Funktionen

rolling(n).apply(func) übergibt jedes Fenster als NumPy-Array an Ihre benutzerdefinierte Funktion. Dadurch sind beliebige gleitende Berechnungen möglich, die nicht durch die integrierten Aggregationen abgedeckt werden – etwa die gleitende mediane absolute Abweichung, gleitende Schiefe oder das gleitende erste Quartil. Die Funktion muss ein 1-D-Array akzeptieren und einen Skalar zurückgeben. Hinweis: apply ist langsamer als die integrierten Methoden, da es nicht vektorisiert werden kann.

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

Rolling auf DataFrame-Spalten

Sie können rolling().mean() direkt auf einen DataFrame anwenden, um gleitende Statistiken für alle numerischen Spalten gleichzeitig zu berechnen. Für jede Spalte wird unabhängig ein eigenes gleitendes Fenster berechnet. Das ist nützlich, um gleitende Mittelwerte mehrerer Aktienkurse oder Produktumsätze in einer einzigen Operation zu berechnen, ohne die Spalten einzeln zu durchlaufen.

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

Gleitenden Mittelwert mit den Originaldaten kombinieren

Ein häufig verwendetes Visualisierungsmuster besteht darin, sowohl die unveränderte Zeitreihe als auch ihren gleitenden Mittelwert in denselben Achsen darzustellen. Der gleitende Mittelwert zeigt den Trend, indem er tägliche Schwankungen glättet, während die ursprüngliche Reihe die Volatilität sichtbar macht. Der Abstand zwischen beiden zeigt, wie stark die Daten verrauscht sind. Einen gleitenden Mittelwert zu einem DataFrame hinzuzufügen ist so einfach, wie das Ergebnis einer neuen Spalte zuzuweisen.

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

Zentrierte Rolling Windows

Standardmäßig verwendet rolling ein nachlaufendes Fenster (die aktuelle Zeile und die n-1 vorhergehenden Zeilen). Mit center=True wird ein zentriertes Fenster erzeugt, bei dem die aktuelle Zeile in der Mitte liegt und gleich viele vorhergehende wie nachfolgende Zeilen verwendet werden. Zentrierte Fenster liefern glattere Ergebnisse und eignen sich für die Offline-Glättung historischer Daten, bei denen zukünftige Werte bekannt sind. Für Live-Prognosen sind sie NICHT geeignet, da sie zukünftige Daten benötigen.

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

Rollierende Fenster für GroupBy-Daten

Sie können gruppenweise rollierende Statistiken mit groupby().rolling() berechnen. Beispielsweise lässt sich der rollierende Umsatz über 7 Tage pro Produktkategorie berechnen – das Fenster wird am Anfang jeder Gruppe zurückgesetzt, sodass die Daten eines Produkts nicht in die Daten eines anderen übergehen. Verwenden Sie nach der rollierenden Operation .reset_index(level=0, drop=True), um die zusätzliche Gruppenebene aus dem Index zu entfernen und das Ergebnis wieder am ursprünglichen DataFrame auszurichten.

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

Kurzer Check

Testen Sie Ihr Verständnis der rollierenden Fenster aus dieser Lektion.

Lektionszusammenfassung

In dieser Lektion haben Sie gelernt: rolling(n) erstellt ein gleitendes Fenster aus n Zeilen, für das Sie den Mittelwert, die Summe, die Standardabweichung, das Minimum, das Maximum oder benutzerdefinierte Funktionen berechnen können. min_periods verringert die Mindestanzahl der benötigten Werte für die Berechnung eines Ergebnisses, und center=True erstellt zentrierte Fenster zur nachträglichen Glättung. Als Nächstes untersuchen wir Expanding-Fenster – kumulative Statistiken, die vom Anfang der Series an wachsen.

Häufig gestellte Fragen

Ist die Lektion „Rollende Fenster“ kostenlos?

Ja — der vollständige Text von „Rollende Fenster“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Rollende Fenster“?

Berechnen Sie mit rolling(n).mean() und verwandten Methoden gleitende Mittelwerte, Summen und Standardabweichungen über eine feste Anzahl von Zeilen. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?

Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Rollende Fenster“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?

Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Rollende Fenster
Erweiterte Fenster
Exponentiell gewichteter gleitender Mittelwert
Rang und Perzentil innerhalb von Gruppen

← Zurück zu Pandas & NumPy Academy