Pandas & NumPy Academy · Les

Rollende vensters

Bereken rollende gemiddelden, sommen en standaardafwijkingen over een vast aantal rijen met rolling(n).mean() en verwante methoden.

Les 1 van 413 stappen

Rollende vensters is een gratis Pandas & NumPy Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Pandas & NumPy Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Pandas & NumPy Academy bevat in totaal 4 lessen.

Wat zijn voortschrijdende vensters?

Een voortschrijdend venster (ook wel schuivend venster genoemd) berekent een statistiek over een venster met een vaste grootte van opeenvolgende rijen, terwijl het telkens één rij verder schuift. Een voortschrijdend gemiddelde over 7 dagen vervangt bijvoorbeeld de waarde van elke dag door het gemiddelde van die dag en de 6 voorafgaande dagen. Voortschrijdende vensters vormen de basis van voortschrijdende gemiddelden in de financiële sector, het gladstrijken van ruisende sensorgegevens en het berekenen van achterlopende meetwaarden in bedrijfsdashboards.

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

De methode rolling() en de parameter window

Series.rolling(window=n) retourneert een Rolling-object. De parameter window is de grootte van het schuivende venster, uitgedrukt in het aantal rijen (voor gehele vensters) of als tijdsverschuiving, zoals '7D' (voor Series-objecten met een tijdindex). Nadat u het Rolling-object hebt gemaakt, kunt u elke aggregatiemethode eraan koppelen: .mean(), .sum(), .std(), .min(), .max() of zelfs .apply(func). De eerste window-1 rijen zijn altijd NaN, omdat er niet genoeg voorafgaande rijen zijn om het venster te vullen.

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

Parameter min_periods

Standaard vereist rolling(n) precies n niet-NaN-waarden in het venster voordat een resultaat wordt berekend. De parameter min_periods verlaagt deze vereiste — met rolling(7, min_periods=3) wordt het gemiddelde bijvoorbeeld berekend zodra er minstens 3 waarden beschikbaar zijn, waardoor eerder in de Series niet-NaN-waarden ontstaan. Dit is nuttig wanneer u aan het begin van een tijdreeks voortschrijdende gemiddelden wilt in plaats van NaN voor de eerste n-1 rijen.

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

Voortschrijdende som voor lopende totalen

rolling(n).sum() berekent op elke positie het totaal van de laatste n rijen. Een voortschrijdende som van de dagelijkse verkopen over 30 dagen geeft voor elke dag de omzet over de voorafgaande maand — informatiever dan een statisch maandtotaal, omdat de waarde dagelijks wordt bijgewerkt. Voortschrijdende sommen worden vaak gebruikt in retailanalyse (verkopen van de afgelopen 30 dagen), webanalyse (actieve gebruikers van de afgelopen 7 dagen) en financiën (volume over de voorafgaande n perioden).

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

Voortschrijdende standaardafwijking voor volatiliteit

In de financiële sector wordt volatiliteit gemeten als de voortschrijdende standaardafwijking van dagelijkse rendementen. Een hoge voortschrijdende standaardafwijking betekent dat prijzen sterk schommelen; een lage waarde wijst op stabiele prijzen. Deze meetwaarde vormt de basis voor risicoberekeningen bij de waardering van opties en het beheer van portefeuilles. De formule is: bereken dagelijkse logaritmische rendementen met np.log(price/price.shift(1)) en pas vervolgens rolling(window).std() toe.

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

Tijdgebaseerde voortschrijdende vensters

In plaats van een vast aantal rijen kunt u een tijdsverschuiving als venster opgeven: rolling('7D') betekent 'de gegevens van de afgelopen 7 kalenderdagen'. Dit verwerkt ongelijke tijdreeksen automatisch correct (ontbrekende weekenden, feestdagen) — een venster op basis van het aantal rijen zou afhankelijk van onderbrekingen een verschillende hoeveelheid kalendertijd omvatten, maar een venster op basis van een tijdsverschuiving beslaat altijd precies 7 dagen aan gegevens. De Series moet een DatetimeIndex hebben voor tijdgebaseerde vensters.

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 voor aangepaste functies

rolling(n).apply(func) geeft elk venster als een NumPy-array door aan uw aangepaste functie. Hiermee kunt u elke voortschrijdende berekening uitvoeren die niet door de ingebouwde aggregaties wordt ondersteund — bijvoorbeeld de voortschrijdende mediaan van de absolute afwijking, voortschrijdende scheefheid of het voortschrijdende eerste kwartiel. De functie moet een eendimensionale array accepteren en een scalaire waarde retourneren. Opmerking: apply is langzamer dan ingebouwde methoden, omdat deze niet kan worden gevectoriseerd.

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 op DataFrame-kolommen

U kunt rolling().mean() rechtstreeks op een DataFrame toepassen om voortschrijdende statistieken voor alle numerieke kolommen tegelijk te berekenen. Elke kolom krijgt onafhankelijk een eigen voortschrijdend venster. Dit is handig voor het berekenen van voortschrijdende gemiddelden van meerdere aandelenkoersen of meerdere productverkoopreeksen in één bewerking, zonder over kolommen te itereren.

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

Voortschrijdend gemiddelde combineren met het origineel

Een veelgebruikt visualisatiepatroon is om zowel de ruwe tijdreeks als het voortschrijdende gemiddelde op dezelfde assen te tekenen. Het voortschrijdende gemiddelde laat de trend zien door dagelijkse ruis glad te strijken, terwijl de ruwe reeks de volatiliteit toont. Het verschil tussen beide geeft aan hoeveel ruis aanwezig is. Een voortschrijdend gemiddelde aan een DataFrame toevoegen is zo eenvoudig als het resultaat aan een nieuwe kolom toewijzen.

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

Gecentreerde voortschrijdende vensters

Standaard gebruikt rolling een achterwaarts gericht venster (de huidige rij en de n-1 voorafgaande rijen). Met center=True maakt u een gecentreerd venster waarin de huidige rij in het midden staat en evenveel eerdere als latere rijen worden gebruikt. Gecentreerde vensters leveren soepelere resultaten op en zijn geschikt voor offline gladstrijken van historische gegevens waarvan de toekomstige waarden bekend zijn. Ze zijn NIET geschikt voor livevoorspellingen, omdat ze toekomstige gegevens vereisen.

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

Voortschrijdende vensters voor GroupBy-gegevens

Je kunt voortschrijdende statistieken per groep berekenen met groupby().rolling(). Zo kun je bijvoorbeeld een voortschrijdende omzet over 7 dagen per productcategorie berekenen — het venster wordt aan het begin van elke groep opnieuw ingesteld, zodat de gegevens van het ene product niet doorlopen in die van een ander product. Gebruik na de voortschrijdende bewerking .reset_index(level=0, drop=True) om het extra groepsniveau uit de index te verwijderen en het resultaat weer uit te lijnen met het oorspronkelijke DataFrame.

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

Korte controle

Test je begrip van voortschrijdende vensters uit deze les.

Samenvatting van de les

In deze les heb je geleerd dat rolling(n) een schuivend venster van n rijen maakt waarvoor je het gemiddelde, de som, de standaardafwijking, het minimum, het maximum of aangepaste functies kunt berekenen, dat min_periods het minimale aantal waarden verlaagt dat nodig is om een resultaat te berekenen, en dat center=True gecentreerde vensters maakt voor offline gladstrijken. Hierna bekijken we uitbreidende vensters — cumulatieve statistieken die vanaf het begin van de Series groeien.

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
30
Lessen
120

Veelgestelde vragen

Is de les “Rollende vensters” gratis?

Ja — de volledige tekst van “Rollende vensters” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Pandas & NumPy Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Pandas & NumPy Academy bevat in totaal 4 lessen.

Wat leer ik in “Rollende vensters”?

Bereken rollende gemiddelden, sommen en standaardafwijkingen over een vast aantal rijen met rolling(n).mean() en verwante methoden. Je oefent met Pandas & NumPy Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Pandas & NumPy Academy te beginnen?

Ervaring vooraf is niet nodig. Pandas & NumPy Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Rollende vensters”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Pandas & NumPy Academy?

Ja. Elke les over Pandas & NumPy Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Rollende vensters
  2. Expanderende vensters
  3. Exponentieel gewogen voortschrijdend gemiddelde
  4. Rang en percentiel binnen groepen
← Terug naar Pandas & NumPy Academy