0Pricing
Pandas & NumPy Academy · Lektion

Erweiterte Fenster

Berechnen Sie mit expanding().sum() kumulative Statistiken, die alle Zeilen vom Anfang bis zum jeweiligen Punkt einbeziehen.

Erweiterte Fenster ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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 ist ein Expanding-Fenster?

Ein Expanding-Fenster umfasst alle Zeilen vom allerersten Eintrag der Series bis zur aktuellen Zeile – das Fenster wächst mit jeder neuen Zeile, anstatt eine feste Größe beizubehalten. In Zeile 0 enthält es nur einen Wert, in Zeile 5 sechs Werte und in Zeile 100 insgesamt 101 Werte. Expanding-Fenster werden verwendet, um kumulative Statistiken zu berechnen, die die laufende Summe, den laufenden Mittelwert oder das laufende Maximum vom Anfang des Datensatzes bis zum aktuellen Zeitpunkt darstellen.

import pandas as pd
import numpy as np

sales = pd.Series(
    [100, 150, 120, 200, 180, 160, 220, 190],
    index=pd.date_range('2024-01-01', periods=8)
)

# Expanding mean — grows with each row
df = pd.DataFrame({'sales': sales})
df['cumulative_mean'] = df['sales'].expanding().mean()
print(df)

Die Methode expanding()

Series.expanding(min_periods=1) gibt ein Expanding-Objekt zurück. Der Parameter min_periods (Standardwert 1) legt die Mindestanzahl von Beobachtungen fest, die für das erste Ergebnis ungleich NaN erforderlich ist. Anders als bei rolling(n) ist das Fenster in expanding() nicht fest definiert – es beginnt immer am Anfang. Sie können beliebige Aggregationen verketten: .sum(), .mean(), .std(), .min(), .max().

import pandas as pd
import numpy as np

np.random.seed(42)
monthly_revenue = pd.Series(
    np.random.randint(500, 1500, 12),
    index=pd.date_range('2024-01', periods=12, freq='ME'),
    name='revenue'
)

df = pd.DataFrame({'revenue': monthly_revenue})
df['cumsum'] = df['revenue'].expanding().sum()
df['cummean'] = df['revenue'].expanding().mean()
df['cummax'] = df['revenue'].expanding().max()
df['cummin'] = df['revenue'].expanding().min()
print(df)

Pandas cumsum, cumprod, cummax, cummin

Für die gängigsten kumulativen Statistiken stellt Pandas direkte Methoden für Series und DataFrame bereit, ohne dass expanding() erforderlich ist: cumsum(), cumprod(), cummax() und cummin(). Dabei handelt es sich um optimierte Implementierungen, die etwas schneller sind als ihre Entsprechungen mit expanding(). Verwenden Sie diese Kurzformen für typische Geschäftskennzahlen wie den Umsatz seit Jahresbeginn (cumsum) oder den historischen Höchstpreis (cummax).

import pandas as pd
import numpy as np

prices = pd.Series(
    [100, 95, 110, 105, 120, 115, 130, 125],
    index=pd.date_range('2024-01-01', periods=8)
)

df = pd.DataFrame({'price': prices})
df['cummax'] = df['price'].cummax()    # all-time high
df['cummin'] = df['price'].cummin()    # all-time low
df['cumsum'] = df['price'].cumsum()    # cumulative total
df['cumprod'] = (1 + df['price'].pct_change()).cumprod()  # growth index
print(df.round(3))

Berechnung des Jahresverlaufs mit Expanding

Eine klassische Anwendung von Expanding-Fenstern ist der Umsatz seit Jahresbeginn (YTD). Für jeden Tag soll die Summe aller Umsätze vom 1. Januar des aktuellen Jahres bis zu diesem Tag berechnet werden. Dazu wird einfach cumsum() innerhalb jeder Jahresgruppe angewendet. Implementieren Sie dies mit groupby(year).cumsum() – die kumulative Summe wird am Anfang jedes Kalenderjahres zurückgesetzt und im Jahresverlauf weiter aufaddiert.

import pandas as pd
import numpy as np

np.random.seed(0)
dates = pd.date_range('2023-01-01', '2024-06-30', freq='ME')
daily = pd.DataFrame({
    'date': dates,
    'revenue': np.random.randint(100, 500, len(dates))
})

# Year-to-date cumulative revenue
daily['year'] = daily['date'].dt.year
daily['ytd_revenue'] = daily.groupby('year')['revenue'].cumsum()
daily = daily.drop(columns='year')
print(daily.tail(10).to_string(index=False))

Standardabweichung eines Expanding-Fensters

expanding().std() berechnet die laufende Standardabweichung unter Verwendung aller Daten vom Anfang bis zur aktuellen Zeile. Das ist nützlich, um zu überwachen, ob die Schwankungen einer Kennzahl im Laufe der Zeit zunehmen oder abnehmen – beispielsweise, um zu verfolgen, ob die täglichen Verkäufe eines Produkts mit zunehmender Reife des Geschäfts vorhersehbarer oder unberechenbarer werden. Im Gegensatz zur rollierenden Standardabweichung, die nur die jüngsten Schwankungen abbildet, erfasst die Expanding-Standardabweichung die gesamte historische Streuung.

import pandas as pd
import numpy as np

np.random.seed(42)
sales = pd.Series(
    np.concatenate([
        np.random.normal(100, 5, 30),   # stable period
        np.random.normal(100, 25, 30)   # volatile period
    ]),
    index=pd.date_range('2024-01-01', periods=60)
)

df = pd.DataFrame({'sales': sales})
df['expanding_std'] = df['sales'].expanding().std()
df['rolling_30d_std'] = df['sales'].rolling(30).std()
print(df.tail(10).round(2))

Rolling und Expanding im Vergleich

Der entscheidende Unterschied: Rolling-Fenster bilden die aktuelle Entwicklung ab (die letzten n Tage) und reagieren kaum auf lange zurückliegende Daten, während Expanding-Fenster die gesamte Historie einbeziehen und sich daher langsam stabilen Werten annähern. Verwenden Sie Rolling, wenn Sie an aktuellen Trends interessiert sind (ein gleitender 7-Tage-Mittelwert reagiert schneller auf aktuelle Veränderungen als ein 90-Tage-Mittelwert). Verwenden Sie Expanding, wenn Sie historische Gesamtstatistiken oder YTD-Kennzahlen benötigen, bei denen frühere Daten niemals vergessen werden dürfen.

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

np.random.seed(10)
data = pd.Series(
    np.random.randn(60).cumsum() + 50,
    index=pd.date_range('2024-01-01', periods=60)
)

df = pd.DataFrame({'value': data})
df['rolling_10'] = data.rolling(10).mean()
df['expanding'] = data.expanding().mean()

df.plot(figsize=(12, 5), title='Rolling 10-day Mean vs. Expanding Mean')
plt.ylabel('Value')
plt.show()

Expanding Apply für benutzerdefinierte kumulative Statistiken

expanding().apply(func) wendet eine benutzerdefinierte Funktion auf alle Daten vom Anfang bis zur aktuellen Zeile an, genau wie rolling().apply(). Damit lassen sich kumulative Statistiken berechnen, die nicht als Standardfunktionen verfügbar sind – beispielsweise der kumulative Variationskoeffizient (std/mean), der laufende Median oder eine kumulative Sharpe Ratio. Die Funktion erhält ein NumPy-Array mit allen bisher erfassten Werten und muss einen Skalar zurückgeben.

import pandas as pd
import numpy as np

np.random.seed(0)
returns = pd.Series(
    np.random.normal(0.001, 0.02, 60),
    index=pd.date_range('2024-01-01', periods=60)
)

# Cumulative Sharpe ratio (mean/std of returns)
def sharpe(arr):
    if len(arr) < 2:
        return float('nan')
    return arr.mean() / arr.std() * (252 ** 0.5)  # annualised

df = pd.DataFrame({'returns': returns})
df['cum_sharpe'] = df['returns'].expanding().apply(sharpe, raw=True)
print(df.tail(8).round(4))

Expanding-Fenster mit NaN-Behandlung

Expanding-Fenster überspringen NaN-Werte standardmäßig – ein NaN in der Mitte der Series wird bei der Berechnung der kumulativen Summe oder des Mittelwerts ignoriert. Sie können dies mit skipna=True überprüfen (dem Standardwert bei den meisten Pandas-Aggregationen). Bei Zeitreihen mit tatsächlich fehlenden Werten (z. B. wenn am Wochenende kein Handel stattfindet) werden Expanding-Statistiken nur aus den bisher erfassten Werten ungleich NaN berechnet, was in der Regel dem gewünschten Verhalten entspricht.

import pandas as pd
import numpy as np

data = pd.Series([10, np.nan, 20, 30, np.nan, 40, 50])

# cumsum skips NaN by default
df = pd.DataFrame({'value': data})
df['cumsum'] = df['value'].cumsum()      # NaN propagates in cumsum!
df['expanding_sum'] = df['value'].expanding().sum()  # NaN skipped

print(df)
print('\nNote: cumsum propagates NaN; expanding().sum() skips it.')

Expanding-Fenster für laufende Vergleichswerte

Expanding-Fenster eignen sich ideal zur Berechnung von laufenden Vergleichswerten: des historischen Höchstwerts, des besten Quartals aller Zeiten oder der niedrigsten Fehlerquote seit dem Start. Diese KPIs erfordern die Berücksichtigung aller historischen Werte – ein Rolling-Fenster würde alte Datensätze vergessen. Mit cummax() oder cummin() erhalten Sie an jedem Punkt den bisher besten (oder schlechtesten) Wert und können so leicht verfolgen, wann neue Rekorde aufgestellt wurden.

import pandas as pd
import numpy as np

np.random.seed(5)
sales = pd.Series(
    np.random.randint(100, 300, 20),
    index=pd.date_range('2024-01-01', periods=20),
    name='daily_sales'
)

df = pd.DataFrame({'sales': sales})
df['all_time_max'] = df['sales'].cummax()
df['new_record'] = df['sales'] == df['all_time_max']

print('Days where a new sales record was set:')
print(df[df['new_record']].drop(columns='new_record'))

Praxisbeispiel: Kumulative Renditen

Im Finanzwesen zeigen kumulative Renditen, wie stark eine Investition vom Startdatum bis zu jedem folgenden Datum gewachsen ist. Ausgehend von täglichen prozentualen Renditen ergibt das kumulative Produkt aus (1 + daily_return) den gesamten Wachstumsfaktor. Ein Expanding-Produkt ist hier sinnvoller als ein Rolling-Produkt – Sie möchten das Gesamtwachstum seit Beginn verfolgen und nicht nur über die letzten n Tage.

import pandas as pd
import numpy as np

np.random.seed(7)
start_price = 100
daily_returns = pd.Series(
    np.random.normal(0.0005, 0.015, 252),
    index=pd.date_range('2024-01-01', periods=252)
)

# Cumulative return = product of (1 + r_i)
cum_returns = (1 + daily_returns).cumprod()
portfolio_value = start_price * cum_returns

print(f'Start value: ${start_price:.2f}')
print(f'End value:   ${portfolio_value.iloc[-1]:.2f}')
print(f'Total return: {(portfolio_value.iloc[-1]/start_price - 1)*100:.1f}%')

Wann Sie Expanding, Rolling oder cumsum verwenden sollten

Leitlinien für die Auswahl des richtigen Ansatzes:

  • Verwenden Sie cumsum() / cummax() / cummin() für einfache kumulative Aggregationen – sie sind die schnellste Option.
  • Verwenden Sie expanding().mean() / std(), wenn Sie kumulative laufende Mittelwerte oder Varianzen benötigen.
  • Verwenden Sie expanding().apply(custom_func) für komplexe historische Gesamtstatistiken, die nicht als Standardfunktionen verfügbar sind.
  • Verwenden Sie rolling(n) statt Expanding, wenn nur die jüngere Historie den aktuellen Wert beeinflussen soll.

Kurzer Check

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

Lektionszusammenfassung

In dieser Lektion haben Sie gelernt: expanding() berechnet kumulative Statistiken über ein vom Anfang der Series an wachsendes Fenster, cumsum/cummax/cummin sind optimierte Kurzformen für gängige kumulative Operationen, und Expanding-Fenster eignen sich ideal für historische Rekorde, YTD-Kennzahlen und kumulative Anlagerenditen. Als Nächstes untersuchen wir exponentiell gewichtete gleitende Mittelwerte (EWMA), bei denen aktuelle Beobachtungen stärker gewichtet werden.

Häufig gestellte Fragen

Ist die Lektion „Erweiterte Fenster“ kostenlos?

Ja — der vollständige Text von „Erweiterte 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 „Erweiterte Fenster“?

Berechnen Sie mit expanding().sum() kumulative Statistiken, die alle Zeilen vom Anfang bis zum jeweiligen Punkt einbeziehen. 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 2 von 4.

Wie lange dauert die Lektion „Erweiterte 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

  1. Rollende Fenster
  2. Erweiterte Fenster
  3. Exponentiell gewichteter gleitender Mittelwert
  4. Rang und Perzentil innerhalb von Gruppen
← Zurück zu Pandas & NumPy Academy