Pipelines parametriseren met config-dicts
Vervang hardgecodeerde bestandspaden en kolomnamen door een config-dict die tijdens runtime wordt doorgegeven, zodat de pipeline herbruikbaar wordt.
Pipelines parametriseren met config-dicts is een gratis Pandas & NumPy Academy-les op CoddyKit. Dit is les 2 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 hardgecodeerde waarden
Een pijplijn met hardgecodeerde bestandspaden, kolomnamen en drempelwaarden werkt niet meer zodra de omgeving verandert — bijvoorbeeld door een andere server, een hernoemde kolom of een gewijzigde bedrijfsregel. Elke wijziging vereist een aanpassing van de pijplijncode zelf, waardoor het risico op bugs ontstaat. De oplossing is om alle variabele waarden te verplaatsen naar een configuratiedictionary die tijdens runtime wordt geladen en aan de pijplijnfuncties wordt doorgegeven.
import pandas as pd
# BAD: hardcoded values scattered through code
df = pd.read_csv('/data/orders_2024.csv')
df = df.dropna(subset=['revenue', 'quantity'])
df = df[df['revenue'] < 5000]
df.to_parquet('/output/orders_clean.parquet')
print('Hardcoded paths and thresholds are fragile')Een configuratiedictionary definiëren
Vervang elke hardgecodeerde waarde door een item in een configuratiedictionary. Groepeer gerelateerde instellingen logisch: invoer- en uitvoerpaden bij elkaar, schoonmaakdrempels bij elkaar en toewijzingen van kolomnamen bij elkaar. De configuratiedictionary wordt de enige bron van waarheid voor alle pijplijnparameters. Als je één waarde in de configuratie wijzigt, wordt elke functie die deze gebruikt bijgewerkt zonder de functie-inhoud aan te passen.
CONFIG = {
'input_path': '/data/orders_2024.csv',
'output_path': '/output/orders_clean.parquet',
'required_cols': ['order_id', 'order_date', 'revenue', 'quantity'],
'date_cols': ['order_date'],
'revenue_cap': 5000,
'min_quantity': 1,
'categorical_cols': ['region', 'category']
}
print('Config loaded:', list(CONFIG.keys()))Configuratie doorgeven aan extractfuncties
De extractfunctie leest al haar parameters uit de configuratie: het invoerpad, de te parsen datumkolommen en eventuele instellingen voor codering of scheidingstekens. Hierdoor hoef je dezelfde pijplijn voor een testgegevensset of het bestand van een andere maand alleen uit te voeren met een andere configuratie — de code hoeft niet te veranderen. Je kunt afzonderlijke configuraties bijhouden voor ontwikkel-, test- en productieomgevingen.
def extract(config):
return pd.read_csv(
config['input_path'],
parse_dates=config.get('date_cols', [])
)
df = extract(CONFIG)
print('Extracted:', df.shape)Configuratie doorgeven aan transformatiefuncties
Elke transformatiefunctie ontvangt de volledige configuratie en haalt daaruit de waarden die deze nodig heeft. Functies horen config.get('key', default) te gebruiken met zinvolle standaardwaarden, zodat de pijplijn bestand is tegen onvolledige configuraties. Een functie die standaard een drempelwaarde van 5000 vereist, maar via de configuratie kan worden aangepast, is zowel veilig als flexibel.
def transform(df, config):
required = config.get('required_cols', [])
cap = config.get('revenue_cap', float('inf'))
min_qty = config.get('min_quantity', 1)
return (
df
.dropna(subset=required)
.query(f'quantity >= {min_qty}')
.assign(revenue=lambda d: d['quantity'] * d['unit_price'])
.assign(revenue_capped=lambda d: d['revenue'].clip(upper=cap))
)
df_clean = transform(df, CONFIG)
print(df_clean.shape)Configuratie laden uit een JSON-bestand
Bewaar voor pijplijnen in productie de configuratie in een JSON-bestand in plaats van in een Python-dictionary die in het script is vastgelegd. Laad deze bij het starten van de pijplijn met json.load(). Hierdoor kunnen operationele teams drempelwaarden wijzigen zonder toegang tot de Python-code, en kun je configuraties via Git versies beheren — elke configuratiewijziging is een bijgehouden commit met een beschrijving van de zakelijke reden voor de wijziging.
import json
# config.json would contain the same keys as CONFIG above
# with open('config.json') as f:
# config = json.load(f)
# Example: write and read back
with open('/tmp/pipeline_config.json', 'w') as f:
json.dump(CONFIG, f, indent=2)
with open('/tmp/pipeline_config.json') as f:
loaded_config = json.load(f)
print('Loaded config from JSON:', loaded_config['revenue_cap'])Omgevingsspecifieke configuraties
Houd voor elke omgeving afzonderlijke configuratiebestanden bij: config_dev.json, config_staging.json en config_prod.json. Bepaal op basis van een omgevingsvariabele welk bestand moet worden geladen. Dit patroon voorkomt dat je tijdens de ontwikkeling per ongeluk bestandspaden uit productie gebruikt en houdt omgevingsspecifieke geheimen (zoals databasegegevens) buiten de gedeelde coderepository.
import os
ENV = os.environ.get('PIPELINE_ENV', 'dev')
CONFIG_PATH = f'config_{ENV}.json'
# In practice:
# with open(CONFIG_PATH) as f:
# config = json.load(f)
print(f'Using config for environment: {ENV}')
print(f'Config file: {CONFIG_PATH}')Kolomnamen opnieuw toewijzen via configuratie
Brongegevens hebben vaak kolomnamen die afwijken van je interne naamgevingsconventie. In plaats van df.rename(columns={'OrderDate': 'order_date', 'Qty': 'quantity'}) hard te coderen in de pipelinebody, sla je de hernoemingsmapping op in de configuratie. Zo is de pipeline onafhankelijk van de kolomnamen van de bron en eenvoudig aan te passen wanneer de upstreamgegevensleverancier de indeling van de export wijzigt.
CONFIG['column_rename'] = {
'OrderDate': 'order_date',
'Qty': 'quantity',
'UnitPrice': 'unit_price',
'OrderID': 'order_id'
}
def rename_columns(df, config):
return df.rename(columns=config.get('column_rename', {}))
print('Column rename mapping stored in config.')Configuratie voor aggregatie: dynamische groupby-sleutels
In de aggregatiefase wordt voor verschillende gebruikssituaties vaak op verschillende kolommen gegroepeerd. Sla de groepssleutels en aggregatiespecificaties op in de configuratie in plaats van ze hard te coderen. Zo kunnen analisten verschillende overzichtstabellen maken (per regio, per categorie, per maand) door de configuratie te wijzigen, zonder de aggregatiefunctie aan te passen. De functie wordt zo een algemene aggregator die volledig door de configuratie wordt aangestuurd.
CONFIG['agg_spec'] = {
'group_by': ['region', 'category'],
'agg_cols': {
'revenue': ['sum', 'mean'],
'quantity': ['sum', 'count']
}
}
def aggregate(df, config):
spec = config['agg_spec']
return df.groupby(spec['group_by']).agg(spec['agg_cols'])
result = aggregate(df_clean, CONFIG)
print(result.head())De configuratie bij het opstarten valideren
Valideer de configuratie bij de start van de pipeline, zodat ontbrekende of ongeldige sleutels worden gevonden voordat er gegevens worden geladen. Een pipeline die 10 minuten draait en daarna mislukt omdat revenue_cap een tekenreeks was in plaats van een float, verspilt tijd. Controleer met een korte configuratiecontrolefunctie die vóór alle dure I/O-bewerkingen wordt uitgevoerd of alle vereiste sleutels bestaan, waarden het juiste type hebben en paden toegankelijk zijn.
def validate_config(config):
required_keys = ['input_path', 'output_path', 'required_cols']
for key in required_keys:
assert key in config, f'Config missing key: {key}'
assert isinstance(config['required_cols'], list), 'required_cols must be a list'
assert isinstance(config.get('revenue_cap', 1), (int, float)), 'revenue_cap must be numeric'
print('Config validation passed.')
validate_config(CONFIG)Standaardconfiguratie samenvoegen met gebruikersconfiguratie
Sta gebruikers toe een gedeeltelijke configuratie op te geven die alleen de waarden overschrijft die voor hen van belang zijn. Voeg de gebruikersconfiguratie boven op een standaardconfiguratie samen met {**defaults, **user_config}. Dit patroon biedt zinvolle standaardwaarden en blijft toch volledig configureerbaar. Het is hetzelfde patroon dat populaire Python-bibliotheken gebruiken wanneer ze configuratie als een dict of als kwargs accepteren.
DEFAULT_CONFIG = {
'revenue_cap': 10000,
'min_quantity': 1,
'date_cols': ['order_date'],
'required_cols': ['order_id', 'revenue']
}
user_config = {'revenue_cap': 5000, 'input_path': '/data/q1.csv'}
final_config = {**DEFAULT_CONFIG, **user_config}
print('Final config revenue_cap:', final_config['revenue_cap']) # 5000
print('Final config min_quantity:', final_config['min_quantity']) # 1 (from default)De configuratie bij de uitvoer opslaan
Sla de configuratie naast het uitvoerbestand op, zodat iedereen die de uitvoer bekijkt onmiddellijk de pipeline-uitvoering kan reproduceren waarmee deze is gemaakt. Sla de configuratie op als een JSON-sidecarbestand met dezelfde naam als de uitvoer, maar met de extensie .config.json. Neem het tijdstip van de pipeline-uitvoering op in de opgeslagen configuratie, zodat elk uitvoerbestand volledig traceerbaar is.
import json
from datetime import datetime
def save_with_config(df, config):
output_path = config['output_path']
config_path = output_path.replace('.parquet', '.config.json')
run_metadata = {**config, 'run_at': datetime.now().isoformat()}
with open(config_path, 'w') as f:
json.dump(run_metadata, f, indent=2, default=str)
df.to_parquet(output_path, index=False)
print(f'Saved data to {output_path}')
print(f'Saved config to {config_path}')Korte controle
Test je begrip van de concepten voor gegevensanalyse uit deze les.
Lesoverzicht
In deze les heb je geleerd hoe je: hardgecodeerde waarden vervangt door een configuratiedictionary die uit JSON wordt geladen, de configuratie doorgeeft aan extractie-, transformatie- en aggregatiefuncties voor volledige parametrisering, en configuraties bij het opstarten valideert en naast uitvoerbestanden opslaat voor reproduceerbaarheid. Hierna bekijken we hoe je pipelinestappen test met controles van aantallen rijen en asserties als beveiliging.
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 “Pipelines parametriseren met config-dicts” gratis?
Ja — de volledige tekst van “Pipelines parametriseren met config-dicts” 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 “Pipelines parametriseren met config-dicts”?
Vervang hardgecodeerde bestandspaden en kolomnamen door een config-dict die tijdens runtime wordt doorgegeven, zodat de pipeline herbruikbaar wordt. 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 2 van 4.
Hoe lang duurt de les “Pipelines parametriseren met config-dicts”?
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
- Transformaties structureren als functies
- Pipelines parametriseren met config-dicts
- Pipelinestappen testen met assertions
- Pipelineruns plannen en loggen