Forskydning og lagfunktioner
Opret lag- og lead-kolonner med shift(), beregn ændringen fra periode til periode med diff(), og beregn den procentvise ændring.
Forskydning og lagfunktioner er en gratis Pandas & NumPy Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Pandas & NumPy Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.
Hvorfor forsinkelsesvariabler er vigtige
I tidsserieanalyse er værdien på et tidligere tidspunkt (en forsinkelse) ofte en af de bedste prædiktorer for den aktuelle værdi. For eksempel indeholder gårsdagens salg oplysninger om dagens salg. Når du opretter forsinkelseskolonner, kan du bruge historiske værdier som variabler i maskinlæringsmodeller eller i statistisk analyse af autokorrelation. Pandas stiller shift() til rådighed, så du kan oprette forsinkelsesvariabler i ét vektoriseret kald.
shift(): flytning af værdier frem eller tilbage
Series.shift(n) flytter alle værdier ned med n positioner (en positiv n opretter en forsinkelse) og udfylder de første n rækker med NaN. Hvis du angiver en negativ n, flyttes værdierne op (det opretter en fremadrettet værdi, hvor fremtidige værdier flyttes tilbage til den aktuelle række). Indekset forbliver uændret — det er kun værdierne, der flyttes.
import pandas as pd
import numpy as np
df = pd.DataFrame(
{'sales': [100, 120, 115, 130, 140, 125]},
index=pd.date_range('2024-01-01', periods=6, freq='D')
)
# Lag-1: yesterday's sales
df['sales_lag1'] = df['sales'].shift(1)
# Lead-1: tomorrow's sales (shifted up)
df['sales_lead1'] = df['sales'].shift(-1)
print(df)Oprettelse af flere lag-kolonner
Du opretter typisk flere lag-funktioner på én gang til maskinlæring — lag-1, lag-7 (samme dag i sidste uge) og lag-30 (samme dag i sidste måned). Den mest læsevenlige måde er at oprette dem i en løkke og tildele hver af dem til en ny kolonne. Den resulterende DataFrame indeholder den oprindelige serie samt alle dens laggede versioner, som er klar til modellering.
for lag in [1, 2, 3, 7]:
df[f'sales_lag{lag}'] = df['sales'].shift(lag)
print(df.columns.tolist())
# ['sales', 'sales_lag1', 'sales_lag2', 'sales_lag3', 'sales_lag7']
# Drop rows with NaN from the largest lag period
df_model = df.dropna()
print('Ready for modelling, shape:', df_model.shape)shift() med freq til tidsbaseret forskydning
I stedet for at forskyde med et helt antal rækker kan du forskyde med en tidsforskydning ved hjælp af parameteren freq. df.shift(1, freq='ME') forskyder indekset frem med én månedsafslutning, mens værdierne forbliver på deres pladser, og indekset ændres. Det er nyttigt til at justere to tidsserier, der er forskudt med en fast tidsperiode, uden at omarrangere værdierne.
monthly = pd.Series(
[100, 120, 115],
index=pd.date_range('2024-01-31', periods=3, freq='ME')
)
# Shift the index forward by 1 month (values stay, index moves)
shifted_index = monthly.shift(1, freq='ME')
print('Original index:', monthly.index.tolist())
print('Shifted index: ', shifted_index.index.tolist())
# Original: [2024-01-31, 2024-02-29, 2024-03-31]
# Shifted: [2024-02-29, 2024-03-31, 2024-04-30]diff(): Ændring fra periode til periode
Series.diff(n) beregner forskellen mellem en værdi og værdien n positioner tidligere: x[t] - x[t-n]. Det bruges ofte til at beregne ændringer fra dag til dag, forskelle fra uge til uge eller ændringer fra år til år. De første n rækker er NaN, fordi der ikke findes tidligere værdier at trække fra.
df['sales_diff1'] = df['sales'].diff(1) # day-over-day change
df['sales_diff7'] = df['sales'].diff(7) # week-over-week change
print(df[['sales', 'sales_diff1']].head())
# sales sales_diff1
# 2024-01-01 100 NaN
# 2024-01-02 120 20.0 <- +20 from yesterday
# 2024-01-03 115 -5.0 <- -5 from yesterdaypct_change(): Procentvis ændring
Series.pct_change(n) beregner den relative procentvise ændring: (x[t] - x[t-n]) / x[t-n]. Det er afgørende for finansiel analyse (dagligt afkast), beregning af vækstrater og alle situationer, hvor den absolutte ændring er mindre meningsfuld end den relative ændring. Gang med 100 for at få procentpoint.
df['pct_chg'] = df['sales'].pct_change().round(3)
df['pct_chg_7d'] = df['sales'].pct_change(7).round(3)
print(df[['sales', 'pct_chg']].head())
# sales pct_chg
# 2024-01-01 100 NaN
# 2024-01-02 120 0.200 <- 20% increase
# 2024-01-03 115 -0.042 <- 4.2% decreaseKombination af shift() med aritmetik
Du kan kombinere shift() med aritmetik for at beregne afledte tidsfunktioner. Det kan for eksempel være forholdet mellem dagens værdi og sidste uges værdi, den kumulative sum siden et fast startpunkt eller forskellen fra værdien for et år siden. Alle disse følger det samme mønster: forskyd den oprindelige serie, og udfør elementvis aritmetik med de aktuelle værdier.
# Week-over-week growth index (today / last week)
df['wow_ratio'] = (df['sales'] / df['sales'].shift(7)).round(3)
# Deviation from 3-day lag
df['dev_3d'] = df['sales'] - df['sales'].shift(3)
# Is today higher than yesterday? (boolean feature)
df['higher_than_yesterday'] = df['sales'] > df['sales'].shift(1)
print(df[['sales', 'wow_ratio', 'higher_than_yesterday']].head())cumsum() og cumprod() til kumulative funktioner
Series.cumsum() beregner den løbende sum fra den første række til og med hver række, mens Series.cumprod() beregner det kumulative produkt. De er nyttige til kumulativ omsætning, kumulativt afkast (sammensat vækst) og totaler fra årets begyndelse. De kræver ingen argumenter og fungerer på alle numeriske Series-objekter eller DataFrame-kolonner.
# Cumulative sales (year-to-date total)
df['ytd_sales'] = df['sales'].cumsum()
# Cumulative product: compound growth factor
returns = pd.Series([0.02, -0.01, 0.03, 0.01, -0.005])
df_ret = pd.DataFrame({'daily_return': returns})
df_ret['compound'] = (1 + df_ret['daily_return']).cumprod() - 1
print(df_ret)Lag-funktioner til maskinlæring
Når du forbereder tidsseriedata til maskinlæring, er et standardtrin i konstruktionen af funktioner at oprette en matrix med lag-funktioner. Hver kolonne repræsenterer målvariablen på et forskelligt tidligere tidspunkt. Når lagene er oprettet, skal du fjerne rækker med NaN (som vises i begyndelsen på grund af manglende historik) og opdele dataene i trænings- og testsæt uden at blande dem, så den tidsmæssige rækkefølge bevares.
def make_lag_matrix(series, n_lags):
df_lags = pd.DataFrame({'y': series})
for lag in range(1, n_lags + 1):
df_lags[f'lag_{lag}'] = series.shift(lag)
return df_lags.dropna()
lag_df = make_lag_matrix(df['sales'], n_lags=3)
print(lag_df)
# y lag_1 lag_2 lag_3
# ... ... ... ...Forskydning inden for grupper
Når dine data indeholder flere enheder (f.eks. flere produkter eller regioner i én DataFrame), skal du beregne forskydninger inden for hver enheds gruppe separat. Brug groupby().shift() for at sikre, at lagget for produkt A's første række er NaN og ikke den sidste værdi for produkt B. Hvis grupper blandes uden dette trin, opstår der ofte en subtil fejl med datalækage.
df_multi = pd.DataFrame({
'product': ['A', 'A', 'A', 'B', 'B', 'B'],
'sales': [100, 120, 115, 200, 210, 195]
})
# WRONG: lag crosses product boundary
df_multi['lag_wrong'] = df_multi['sales'].shift(1)
# CORRECT: lag within each product
df_multi['lag_correct'] = df_multi.groupby('product')['sales'].shift(1)
print(df_multi)Fortolkning af fortegn i pct_change
En positiv værdi fra pct_change() betyder, at den aktuelle værdi er højere end den forrige; en negativ værdi betyder, at den er lavere. Vær opmærksom på division med nul, når den forrige værdi er nul — resultatet er NaN eller inf afhængigt af fortegnet på den aktuelle værdi. Brug replace([float('inf'), float('-inf')], float('nan')) til at rense uendelige værdier efter pct_change().
import numpy as np
s = pd.Series([0, 100, 50, 200])
chg = s.pct_change()
print(chg)
# 0 NaN <- no prior value
# 1 inf <- 0 -> 100 (division by zero)
# 2 -0.5 <- 100 -> 50 (-50%)
# 3 3.0 <- 50 -> 200 (+300%)
# Clean infinite values
chg_clean = chg.replace([float('inf'), float('-inf')], float('nan'))
print(chg_clean)Hurtigt tjek
Test din forståelse af forskydning og lag-funktioner fra denne lektion.
Opsummering af lektionen
I denne lektion har du lært, at shift(n) opretter lag-funktioner ved at flytte værdier ned med n positioner; diff(n) beregner den absolutte ændring fra periode til periode; pct_change(n) beregner den relative procentvise ændring; og at du skal bruge groupby().shift(), når du arbejder med flere grupper, for at undgå datalækage. Nu skal vi udtrække tidsmæssige funktioner ved hjælp af .dt-adgangsobjektet.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Forskydning og lagfunktioner” gratis?
Ja — hele teksten til “Forskydning og lagfunktioner” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Pandas & NumPy Academy-kurset, skal du opgradere til CoddyKit PRO. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Forskydning og lagfunktioner”?
Opret lag- og lead-kolonner med shift(), beregn ændringen fra periode til periode med diff(), og beregn den procentvise ændring. Du øver dig i Pandas & NumPy Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Pandas & NumPy Academy?
Der kræves ingen tidligere erfaring. Pandas & NumPy Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Forskydning og lagfunktioner”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Pandas & NumPy Academy-lektion?
Ja. Alle Pandas & NumPy Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- DatetimeIndex og periodeintervaller
- Genudtagning af tidsserier
- Forskydning og lagfunktioner
- Udtræk af tidsmæssige funktioner