Pandas & NumPy Academy · Lektion

Rullande fönster

Beräkna rullande medelvärden, summor och standardavvikelser över ett fast antal rader med rolling(n).mean() och relaterade metoder.

Lektion 1 av 413 steg

Rullande fönster är en gratis lektion i Pandas & NumPy Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Pandas & NumPy Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Vad är rullande fönster?

Ett rullande fönster (även kallat glidande fönster) beräknar ett mått över ett fönster med ett fast antal på varandra följande rader när fönstret flyttas framåt en rad i taget. Exempelvis ersätter ett rullande medelvärde över 7 dagar varje dags värde med medelvärdet av den dagen och de 6 föregående dagarna. Rullande fönster är grunden för glidande medelvärden inom finans, utjämning av brusiga sensordata och beräkning av eftersläpande mått i affärsöversikter.

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

Metoden rolling() och parametern window

Series.rolling(window=n) returnerar ett Rolling-objekt. Parametern window anger det rullande fönstrets storlek i antal rader (för heltalsfönster) eller som ett tidsintervall, till exempel '7D' (för tidsindexerade Series-objekt). När det rullande objektet har skapats kan ni kedja valfri aggregeringsmetod: .mean(), .sum(), .std(), .min(), .max() eller även .apply(func). De första window-1 raderna blir alltid NaN eftersom det inte finns tillräckligt många föregående rader för att fylla fönstret.

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

Parametern min_periods

Som standard kräver rolling(n) exakt n värden som inte är NaN i fönstret innan ett resultat beräknas. Parametern min_periods minskar detta krav — exempelvis beräknar rolling(7, min_periods=3) medelvärdet så snart minst 3 värden är tillgängliga, vilket ger värden som inte är NaN tidigare i Series-objektet. Detta är användbart när ni vill ha glidande medelvärden i början av en tidsserie i stället för NaN för de första n-1 raderna.

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

Rullande summa för löpande totaler

rolling(n).sum() beräknar summan av de senaste n raderna vid varje position. En rullande 30-dagarssumma av daglig försäljning ger den eftersläpande månadsintäkten för varje dag — mer informativt än en statisk månadssumma eftersom den uppdateras varje dag. Rullande summor används ofta inom detaljhandelsanalys (försäljning de senaste 30 dagarna), webbanalys (aktiva användare de senaste 7 dagarna) och finans (volym under de senaste n perioderna).

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

Rullande standardavvikelse för volatilitet

Inom finans mäts volatilitet som den rullande standardavvikelsen för daglig avkastning. En hög rullande standardavvikelse innebär att priserna fluktuerar kraftigt, medan en låg rullande standardavvikelse visar att priserna är stabila. Detta mått används vid riskberäkningar för optionsprissättning och portföljförvaltning. Formeln är: beräkna daglig logaritmisk avkastning med np.log(price/price.shift(1)) och använd sedan rolling(window).std().

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

Tidsbaserade rullande fönster

I stället för ett fast antal rader kan ni ange ett tidsintervall som fönster: rolling('7D') betyder ”de senaste 7 kalenderdagarnas data”. Detta hanterar automatiskt oregelbundna tidsserier korrekt, till exempel saknade helger och helgdagar — ett fönster baserat på antal rader skulle omfatta olika lång kalendertid beroende på luckorna, medan ett tidsbaserat fönster alltid sträcker sig över exakt 7 dagar av data. Series-objektet måste ha ett DatetimeIndex för tidsbaserade fönster.

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 anpassade funktioner

rolling(n).apply(func) skickar varje fönster som en NumPy-array till er anpassade funktion. Detta möjliggör alla rullande beräkningar som inte täcks av de inbyggda aggregeringarna — exempelvis rullande medianbaserad absolut avvikelse, rullande skevhet eller rullande första kvartil. Funktionen måste ta emot en endimensionell array och returnera ett skalärt värde. Obs! apply är långsammare än de inbyggda metoderna eftersom den inte kan vektoriseras.

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

Rullande beräkningar på DataFrame-kolumner

Ni kan använda rolling().mean() direkt på en DataFrame för att beräkna rullande statistik för alla numeriska kolumner samtidigt. Varje kolumn får sitt eget rullande fönster som beräknas oberoende. Detta är användbart när ni vill beräkna glidande medelvärden för flera aktiekurser eller flera produktförsäljningsserier i en enda operation, utan att iterera över kolumnerna.

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

Kombinera rullande medelvärde med originalet

Ett vanligt visualiseringsmönster är att rita både den råa tidsserien och dess rullande medelvärde på samma axlar. Det rullande medelvärdet synliggör trenden genom att jämna ut dagliga variationer, medan den råa serien visar volatiliteten. Avståndet mellan dem visar hur mycket brus som finns. Att lägga till ett rullande medelvärde i en DataFrame är så enkelt som att tilldela resultatet till en ny kolumn.

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

Centrerade rullande fönster

Som standard använder rolling ett eftersläpande fönster (den aktuella raden och de n-1 föregående raderna). Genom att ange center=True skapas ett centrerat fönster där den aktuella raden ligger i mitten och lika många tidigare och framtida rader används. Centrerade fönster ger jämnare resultat och passar för utjämning offline av historiska data där framtida värden är kända. De passar INTE för prognoser i realtid eftersom de kräver framtida data.

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

Rullande fönster för GroupBy-data

Ni kan beräkna rullande statistik per grupp med groupby().rolling(). Exempelvis kan ni beräkna rullande intäkter över 7 dagar per produktkategori — fönstret återställs när en ny grupp börjar, så att data från en produkt inte blandas ihop med data från en annan. Efter den rullande beräkningen använder ni .reset_index(level=0, drop=True) för att ta bort den extra gruppnivån från indexet och anpassa resultatet till det ursprungliga DataFrame-objektet.

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

Snabbtest

Testa vad ni har förstått om rullande fönster i den här lektionen.

Sammanfattning av lektionen

I den här lektionen har ni lärt er att rolling(n) skapar ett glidande fönster med n rader där ni kan beräkna medelvärde, summa, standardavvikelse, minimum, maximum eller egna funktioner, att min_periods minskar det minsta antalet värden som krävs för att beräkna ett resultat och att center=True skapar centrerade fönster för utjämning i efterhand. Nästa steg är expanderande fönster — kumulativ statistik som växer från början av Series.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
30
Lektioner
120

Vanliga frågor

Är lektionen ”Rullande fönster” gratis?

Ja – hela texten till ”Rullande fönster” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Pandas & NumPy Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Rullande fönster”?

Beräkna rullande medelvärden, summor och standardavvikelser över ett fast antal rader med rolling(n).mean() och relaterade metoder. Ni övar på Pandas & NumPy Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Pandas & NumPy Academy?

Du behöver inga förkunskaper. Utbildningen i Pandas & NumPy Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Rullande fönster”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Pandas & NumPy Academy-lektionen?

Ja. Varje Pandas & NumPy Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Rullande fönster
  2. Expanderande fönster
  3. Exponentiellt viktat glidande medelvärde
  4. Rang och percentil inom grupper
← Tillbaka till Pandas & NumPy Academy