Metodekjeding med pipe()
Skriv lesbare datapipelines med pipe() for å kjede egendefinerte funksjoner sammen med innebygde Pandas-metoder.
Metodekjeding med pipe() er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Pandas & NumPy Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Problemet med mellomliggende variabler
En datapipeline for rensing uten pipe() samler ofte opp mange mellomliggende variabler: df1 = clean(df), df2 = transform(df1), df3 = enrich(df2). Disse variablene fyller navneområdet, gjør feilsøking vanskeligere og frister utviklere til å bruke dem på feil måte. Resultatet er kode som er vanskelig å lese ovenfra og ned som en sekvens av transformasjoner.
import pandas as pd
df = pd.read_csv('orders.csv')
# Without pipe — intermediate variables everywhere
df1 = df.dropna(subset=['revenue'])
df2 = df1[df1['quantity'] > 0]
df3 = df2.assign(revenue_per_unit=df2['revenue'] / df2['quantity'])
print(df3.shape)Introduksjon til pipe()
DataFrame.pipe(func) kaller func(df) og returnerer resultatet, slik at De kan kjede egendefinerte funksjoner på samme måte som De kjeder innebygde Pandas-metoder, for eksempel .dropna().query(). Den viktigste fordelen er at hvert transformasjonstrinn er tydelig og lett å lese fra venstre mot høyre (eller ovenfra og ned når det formateres med parenteser), slik at den logiske rekkefølgen i pipelinen gjenspeiles.
def drop_nulls(df):
return df.dropna(subset=['revenue'])
def filter_positive_qty(df):
return df[df['quantity'] > 0]
def add_revenue_per_unit(df):
return df.assign(revenue_per_unit=df['revenue'] / df['quantity'])
# With pipe — clean chain
df_clean = (df
.pipe(drop_nulls)
.pipe(filter_positive_qty)
.pipe(add_revenue_per_unit)
)
print(df_clean.shape)Sende argumenter gjennom pipe()
Send ekstra argumenter til funksjonen som pipelinen bruker, ved hjelp av nøkkelordargumenter etter funksjonsnavnet: df.pipe(func, arg1=val1). Funksjonssignaturen må godta df som sin første parameter. Parameteriserte funksjoner gjør pipelinen konfigurerbar: De kan endre terskler, kolonnenavn eller atferd uten å endre funksjonskroppen, bare ved å endre argumentene i pipe-kallet.
def filter_by_region(df, regions):
return df[df['region'].isin(regions)]
def cap_revenue(df, upper):
df = df.copy()
df['revenue'] = df['revenue'].clip(upper=upper)
return df
df_result = (df
.pipe(filter_by_region, regions=['North', 'East'])
.pipe(cap_revenue, upper=1000)
)
print(df_result.shape)Kombinere pipe() med innebygde metoder
Styrken til pipe() er at den integreres sømløst med innebygde Pandas-metoder i den samme kjeden. Du kan blande .dropna(), .query(), .rename() og .pipe(custom_func) i valgfri rekkefølge. Dette gjør kjeden både kortfattet (ved at innebygde metoder brukes når det er mulig) og fleksibel (ved at egendefinerte funksjoner kan brukes når de innebygde metodene ikke strekker til).
df_result = (
df
.dropna(subset=['revenue', 'order_date'])
.query('quantity > 0')
.rename(columns={'unit_price': 'price'})
.pipe(add_revenue_per_unit)
.reset_index(drop=True)
)
print(df_result.head())Feilsøking av en pipe()-kjede
Det kan være vanskelig å feilsøke en lang kjede fordi du ikke kan inspisere mellomtilstander ved å legge inn en utskriftssetning midt i kjeden. En løsning er å skrive en videreførende feilsøkingsfunksjon som skriver ut informasjon om størrelse og kolonner, og deretter returnerer DataFrame-en uendret. Sett den inn hvor som helst i kjeden for å inspisere tilstanden på det aktuelle trinnet uten å bryte kjeden.
def debug(df, label=''):
print(f'[{label}] shape: {df.shape}')
print(f'[{label}] columns: {df.columns.tolist()}')
return df
df_result = (
df
.pipe(drop_nulls)
.pipe(debug, label='after drop_nulls')
.pipe(filter_positive_qty)
.pipe(debug, label='after filter')
)
print('Done')Bygge en fullstendig rensepipeline
Kombiner alle rensetrinnene i én enkelt pipeline-funksjon ved hjelp av pipe(). Når du pakker kjeden inn i en funksjon kalt clean_pipeline(df), blir pipelinen testbar som en enhet. Kall den med en rå DataFrame og motta en renset DataFrame. Dette mønsteret følger ETL-paradigmet (Extract, Transform, Load) som brukes i profesjonell data engineering.
def clean_pipeline(df):
return (
df
.dropna(subset=['order_id', 'revenue'])
.drop_duplicates(subset=['order_id'])
.query('quantity > 0 and revenue >= 0')
.pipe(add_revenue_per_unit)
.reset_index(drop=True)
)
df_clean = clean_pipeline(df)
print('Clean rows:', len(df_clean))pipe() kontra apply(): viktige forskjeller
pipe(func) sender hele DataFrame-en til func og forventer en DataFrame (eller et transformert objekt) tilbake. apply(func, axis=1) sender én rad om gangen. Bruk pipe() til transformasjoner av hele DataFrame-en som beholder samme form (eller bevisst endrer den), og bruk apply() til beregninger på rad- eller kolonnenivå. De utfyller hverandre og konkurrerer ikke.
# pipe: receives the whole DataFrame
def scale_revenue(df, factor=1.0):
df = df.copy()
df['revenue'] = df['revenue'] * factor
return df
# apply: receives one row at a time
df['revenue_x2'] = df.apply(lambda row: row['revenue'] * 2, axis=1)
df_scaled = df.pipe(scale_revenue, factor=1.1)
print('pipe scales all rows at once; apply does row-by-row')Gjenbrukbare pipeline-komponenter
Skriv hvert pipelinetrinn som en ren funksjon — uten global tilstand, med en DataFrame som inndata og en DataFrame som returverdi. Rene funksjoner er enkle å enhetsteste: kall dem med en liten test-DataFrame og kontroller formen og kolonneverdiene i resultatet. Et bibliotek med testede, gjenbrukbare pipeline-funksjoner gjør analysen av nye datasett med lignende rensekrav betydelig raskere.
def normalise_strings(df, cols):
df = df.copy()
for col in cols:
df[col] = df[col].str.strip().str.lower()
return df
def parse_dates(df, cols):
df = df.copy()
for col in cols:
df[col] = pd.to_datetime(df[col])
return df
df_result = (
df
.pipe(normalise_strings, cols=['region', 'category'])
.pipe(parse_dates, cols=['order_date'])
)
print(df_result.dtypes)Logge pipelinetrinn med pipe()
Legg til strukturert logging i hver pipeline-funksjon slik at du kan revidere hver transformasjon i produksjon. Ta med antall rader i inndata, antall rader i utdata og relevant statistikk (for eksempel hvor mange rader som ble fjernet av et filter). Da får du et komplett spor av hver pipeline-kjøring uten å trenge en ekstern arbeidsflytorkestrator for grunnleggende revisjonsspor.
import logging
logging.basicConfig(level=logging.INFO)
def logged_dropna(df, subset):
before = len(df)
df = df.dropna(subset=subset)
after = len(df)
logging.info(f'dropna: {before - after} rows removed, {after} remaining')
return df
df_clean = df.pipe(logged_dropna, subset=['revenue'])
print('Logged pipeline complete.')Betingede trinn i en pipeline
Noen ganger skal et rensetrinn bare kjøres basert på et flagg eller innholdet i dataene. Du kan legge til betingede trinn i en pipe-kjede ved å sette inn en funksjon som enten viderefører eller transformerer dataene: Den kontrollerer en betingelse og utfører enten en transformasjon eller returnerer DataFrame-en uendret. Dette bevarer kjedestrukturen samtidig som det støtter valgfrie trinn.
def maybe_cap_revenue(df, cap=None):
if cap is None:
return df
df = df.copy()
df['revenue'] = df['revenue'].clip(upper=cap)
return df
CAPPING_ENABLED = True
CAP_VALUE = 1000 if CAPPING_ENABLED else None
df_result = df.pipe(maybe_cap_revenue, cap=CAP_VALUE)
print('Conditional step applied:', CAPPING_ENABLED)Eksportere resultatet fra pipelinen
Det siste trinnet i en pipe()-kjede er ofte en eksport. Du kan kjede en egendefinert eksportfunksjon ved hjelp av pipe(), eller ganske enkelt kalle den innebygde Pandas-eksportmetoden etter kjeden. Ved å bruke et trinn med pipe(save_to_parquet) blir eksporten en del av kjededokumentasjonen, og du sikrer at den alltid kjøres på den endelig rensede DataFrame-en, ikke på en mellomversjon.
def save_parquet(df, path):
df.to_parquet(path, index=False)
print(f'Saved {len(df)} rows to {path}')
return df # return df so the chain can continue if needed
df_final = (
df
.pipe(clean_pipeline)
.pipe(save_parquet, path='orders_final.parquet')
)
print('Pipeline complete.')Hurtigsjekk
Test forståelsen Deres av konsepter innen dataanalyse fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen har De lært: å bruke pipe() til å kjede egendefinerte funksjoner sammen med innebygde Pandas-metoder, å bygge gjenbrukbare, parameteriserte og testbare pipelinetrinn som rene funksjoner, og å legge til feilsøkingslogging og betingede trinn i en pipe-kjede. Neste tema er hvordan transformasjonstrinn struktureres som funksjoner for en ETL-pipeline i produksjon.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Metodekjeding med pipe()» gratis?
Ja – hele teksten i «Metodekjeding med pipe()» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Pandas & NumPy Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Metodekjeding med pipe()»?
Skriv lesbare datapipelines med pipe() for å kjede egendefinerte funksjoner sammen med innebygde Pandas-metoder. Du øver på Pandas & NumPy Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Pandas & NumPy Academy?
Ingen tidligere erfaring er nødvendig. Pandas & NumPy Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.
Hvor lang tid tar leksjonen «Metodekjeding med pipe()»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Pandas & NumPy Academy-leksjonen?
Ja. Alle Pandas & NumPy Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- apply() på kolonner og rader
- apply() med GroupBy
- map() og applymap() for elementvise operasjoner
- Metodekjeding med pipe()