Method chaining met pipe()
Schrijf leesbare pipelines voor gegevenstransformaties door met pipe() aangepaste functies te koppelen aan native Pandas-methoden.
Method chaining met pipe() is een gratis Pandas & NumPy Academy-les op CoddyKit. Dit is les 4 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.
Het probleem met tussentijdse variabelen
Een gegevensopschoningsketen zonder pipe() stapelt vaak veel tussentijdse variabelen op: df1 = clean(df), df2 = transform(df1), df3 = enrich(df2). Deze variabelen vervuilen de naamruimte, maken foutopsporing moeilijker en verleiden ontwikkelaars ertoe ze verkeerd opnieuw te gebruiken. Het resultaat is code die moeilijk van boven naar beneden te lezen is als een reeks transformaties.
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)Kennismaken met pipe()
DataFrame.pipe(func) roept func(df) aan en retourneert het resultaat, zodat je aangepaste functies op dezelfde manier kunt koppelen als ingebouwde Pandas-methoden zoals .dropna().query(). Het belangrijkste voordeel is dat elke transformatiestap expliciet en leesbaar is van links naar rechts (of van boven naar beneden wanneer je haakjes gebruikt voor de opmaak), overeenkomstig de logische volgorde van de gegevensverwerkingsketen.
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)Argumenten doorgeven via pipe()
Geef extra argumenten door aan de functie in de keten met benoemde argumenten na de functienaam: df.pipe(func, arg1=val1). De handtekening van de functie moet df als eerste parameter accepteren. Functies met parameters maken de gegevensverwerkingsketen configureerbaar: je kunt drempelwaarden, kolomnamen of gedrag wijzigen zonder de functie zelf aan te passen, simpelweg door de argumenten van de aanroep van pipe te wijzigen.
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)pipe() combineren met ingebouwde methoden
De kracht van pipe() is dat deze naadloos integreert met de eigen methoden van Pandas in dezelfde keten. Je kunt .dropna(), .query(), .rename() en .pipe(custom_func) in elke gewenste volgorde combineren. Hierdoor is de keten zowel beknopt (door waar mogelijk ingebouwde methoden te gebruiken) als flexibel (door aangepaste functies te gebruiken waar ingebouwde methoden tekortschieten).
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())Een keten met pipe() debuggen
Het debuggen van een lange keten kan lastig zijn, omdat je geen tussenliggende toestanden kunt bekijken door in het midden een printinstructie toe te voegen. Een oplossing is een doorvoerfunctie voor debugging te schrijven die informatie over de vorm en kolommen afdrukt en vervolgens het DataFrame ongewijzigd retourneert. Voeg deze op een willekeurig punt in de keten in om de toestand op dat moment te bekijken zonder de keten te onderbreken.
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')Een volledige gegevenspijplijn bouwen
Combineer alle schoonmaakstappen in één pijplijnfunctie met pipe(). Door de keten in een functie met de naam clean_pipeline(df) te plaatsen, wordt de pijplijn als geheel testbaar. Roep de functie aan met een onbewerkt DataFrame en ontvang een schoon DataFrame terug. Dit patroon sluit aan bij het ETL-paradigma (Extract, Transform, Load) dat in professionele gegevensverwerking wordt gebruikt.
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() versus apply(): belangrijkste verschillen
pipe(func) geeft het volledige DataFrame door aan func en verwacht een DataFrame (of getransformeerd object) terug. apply(func, axis=1) geeft telkens één rij door. Gebruik pipe() voor transformaties op het volledige DataFrame die dezelfde vorm behouden (of deze bewust wijzigen), en gebruik apply() voor berekeningen op rijen- of kolomniveau. Ze vullen elkaar aan en concurreren niet met elkaar.
# 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')Herbruikbare onderdelen van een gegevenspijplijn
Schrijf elke stap van de pijplijn als een pure functie — zonder globale toestand, die een DataFrame ontvangt en een DataFrame retourneert. Pure functies zijn eenvoudig met unittests te testen: roep ze aan met een klein test-DataFrame en controleer de vorm en kolomwaarden van de uitvoer. Een bibliotheek met geteste, herbruikbare pijplijnfuncties versnelt de analyse van nieuwe gegevenssets met vergelijkbare schoonmaakvereisten aanzienlijk.
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)Stappen van een gegevenspijplijn logboekregistreren met pipe()
Voeg gestructureerde logboekregistratie toe aan elke pijplijnfunctie, zodat je elke transformatie in productie kunt controleren. Neem het aantal invoerrijen, het aantal uitvoerrijen en relevante statistieken op (bijvoorbeeld het aantal rijen dat door een filter is verwijderd). Zo krijg je een volledige registratie van elke uitvoering van de pijplijn, zonder voor eenvoudige controlesporen een externe werkstroomorchestrator nodig te hebben.
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.')Voorwaardelijke stappen in een gegevenspijplijn
Soms mag een schoonmaakstap alleen worden uitgevoerd op basis van een vlag of de inhoud van de gegevens. Je kunt voorwaardelijke stappen aan een pipe-keten toevoegen door een identiteits- of transformatiefunctie in te voegen: deze controleert een voorwaarde en past een transformatie toe of retourneert het DataFrame ongewijzigd. Zo blijft de structuur van de keten intact en worden optionele stappen ondersteund.
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)Het resultaat van de gegevenspijplijn exporteren
De laatste stap in een pipe()-keten is vaak een export. Je kunt met pipe() een aangepaste exportfunctie aan de keten koppelen of na de keten eenvoudig de eigen exportmethode van Pandas aanroepen. Met een stap als pipe(save_to_parquet) blijft het exportonderdeel gedocumenteerd in de keten en weet je zeker dat deze altijd op het laatst opgeschoonde DataFrame wordt uitgevoerd, niet op een tussenversie.
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.')Korte controle
Test je begrip van de concepten van gegevensanalyse uit deze les.
Samenvatting van de les
In deze les heb je geleerd hoe je: pipe() gebruikt om aangepaste functies met de eigen methoden van Pandas te koppelen, herbruikbare, parametriseerbare en testbare pijplijnstappen als pure functies bouwt, en debuglogboekregistratie en voorwaardelijke stappen in een pipe-keten toevoegt. Hierna bekijken we hoe je transformatiestappen als functies structureert voor een professionele ETL-pijplijn.
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 “Method chaining met pipe()” gratis?
Ja — de volledige tekst van “Method chaining met pipe()” 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 “Method chaining met pipe()”?
Schrijf leesbare pipelines voor gegevenstransformaties door met pipe() aangepaste functies te koppelen aan native Pandas-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 4 van 4.
Hoe lang duurt de les “Method chaining met pipe()”?
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
- apply() op kolommen en rijen
- apply() met GroupBy
- map() en applymap() voor elementgewijze bewerkingen
- Method chaining met pipe()