Pandas & NumPy Academy · Lektion

Parameterisera pipelines med config-dict

Ersätt hårdkodade filsökvägar och kolumnnamn med en config-dict som skickas vid körning för att göra pipelinen återanvändbar.

Lektion 2 av 413 steg

Parameterisera pipelines med config-dict är en gratis lektion i Pandas & NumPy Academy på CoddyKit. Detta är lektion 2 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.

Problemet med hårdkodade värden

En pipeline med hårdkodade filsökvägar, kolumnnamn och tröskelvärden slutar fungera när miljön ändras — till exempel vid en annan server, ett namnbyte på en kolumn eller en ändrad affärsregel. Varje ändring kräver att själva pipelinekoden redigeras, vilket ökar risken för fel. Lösningen är att flytta alla variabla värden till en konfigurationsordlista som läses in vid körning och skickas vidare till pipelinefunktionerna.

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

Definiera en config-dict

Ersätt varje hårdkodat värde med en post i en konfigurationsordlista. Gruppera relaterade inställningar logiskt: sökvägar för indata och utdata tillsammans, tröskelvärden för datarensning tillsammans och mappningar av kolumnnamn tillsammans. Config-dict blir den enda sanningskällan för alla pipelineparametrar. När ett värde i config ändras uppdateras varje funktion som använder det utan att funktionskropparna behöver ändras.

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

Skicka config till extract-funktioner

Extract-funktionen läser alla sina parametrar från config: indatasökvägen, datumkolumnerna som ska tolkas samt eventuella inställningar för teckenkodning eller avgränsare. Det innebär att samma pipeline kan köras mot ett testdataset eller en fil från en annan månad genom att endast ändra config — ingen kodändring krävs. Ni kan ha separata config-filer för utvecklings-, staging- och produktionsmiljöer.

def extract(config):
    return pd.read_csv(
        config['input_path'],
        parse_dates=config.get('date_cols', [])
    )

df = extract(CONFIG)
print('Extracted:', df.shape)

Skicka config till transform-funktioner

Varje transformationsfunktion tar emot hela config och hämtar de värden den behöver. Funktioner bör använda config.get('key', default) med rimliga standardvärden så att pipelinen är robust även vid ofullständiga config-filer. En funktion som som standard kräver ett tröskelvärde på 5000 men kan åsidosättas via config är både säker och 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)

Läs in config från en JSON-fil

För pipelines i produktion bör config lagras i en JSON-fil i stället för i en Python-ordlista som är hårdkodad i skriptet. Läs in den med json.load() när pipelinen startar. Då kan driftteam ändra tröskelvärden utan åtkomst till Pythonkoden, och config kan versionshanteras med Git — varje ändring blir en spårad commit med en beskrivning av affärsorsaken till ändringen.

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

Miljöspecifika config-filer

Underhåll separata config-filer för varje miljö: config_dev.json, config_staging.json och config_prod.json. Avgör vilken som ska läsas in baserat på en miljövariabel. Detta mönster förhindrar att produktionssökvägar till filer används av misstag under utveckling och håller miljöspecifika hemligheter (till exempel databasautentiseringsuppgifter) borta från det gemensamma kodarkivet.

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

Mappa om kolumnnamn via config

Källdata har ofta kolumnnamn som skiljer sig från er interna namnstandard. I stället för att hårdkoda df.rename(columns={'OrderDate': 'order_date', 'Qty': 'quantity'}) i pipeline-koden kan ni lagra namnbytesmappningen i konfigurationen. Då blir pipelinen oberoende av källans kolumnnamn och enkel att anpassa när den uppströms dataleverantören ändrar sitt exportformat.

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

Konfiguration för aggregering: dynamiska groupby-nycklar

Aggregeringsfasen grupperar ofta efter olika kolumner för olika användningsområden. Lagra gruppnycklarna och aggregeringsspecifikationerna i konfigurationen i stället för att hårdkoda dem. Då kan analytiker skapa olika sammanfattningstabeller (per region, kategori eller månad) genom att ändra konfigurationen, utan att behöva ändra aggregeringsfunktionen. Funktionen blir en generell aggregator som helt styrs av konfigurationen.

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

Validera konfigurationen vid start

Validera konfigurationen när pipelinen startar, så att saknade eller ogiltiga nycklar upptäcks innan några data har lästs in. En pipeline som körs i 10 minuter och sedan misslyckas eftersom revenue_cap var en sträng i stället för ett flyttal slösar med tid. Kontrollera att alla obligatoriska nycklar finns, att värdena har rätt typ och att sökvägarna är åtkomliga, med en kort konfigurationskontroll som körs innan någon kostsam I/O utförs.

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)

Slå samman standardkonfiguration med användarkonfiguration

Låt användare ange en ofullständig konfiguration som bara skriver över de värden de vill ändra. Slå samman användarkonfigurationen ovanpå en standardkonfiguration med {**defaults, **user_config}. Det här mönstret ger rimliga standardvärden samtidigt som allt fortfarande kan konfigureras. Det är samma mönster som används av populära Python-bibliotek som tar emot konfiguration som en dict eller kwargs.

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)

Lagra konfigurationen tillsammans med resultatet

Spara konfigurationen tillsammans med resultatfilen, så att alla som granskar resultatet direkt kan återskapa den pipelinekörning som skapade det. Lagra den som en JSON-sidofil med samma namn som resultatet, men med filändelsen .config.json. Ta med tidsstämpeln för pipelinekörningen i den sparade konfigurationen, så att varje resultatfil kan spåras fullständigt.

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

Snabbkontroll

Testa era kunskaper om begreppen inom dataanalys från den här lektionen.

Lektionssammanfattning

I den här lektionen har ni lärt er att: ersätta hårdkodade värden med en konfigurationsdict som läses in från JSON, skicka konfigurationen till funktioner för extrahering, transformering och aggregering för full parametrisering samt validera konfigurationer vid start och spara dem tillsammans med resultatfiler för reproducerbarhet. Nästa avsnitt handlar om att testa pipelinesteg med radantalskontroller och assertions.

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 ”Parameterisera pipelines med config-dict” gratis?

Ja – hela texten till ”Parameterisera pipelines med config-dict” 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 ”Parameterisera pipelines med config-dict”?

Ersätt hårdkodade filsökvägar och kolumnnamn med en config-dict som skickas vid körning för att göra pipelinen återanvändbar. 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 2 av 4.

Hur lång tid tar lektionen ”Parameterisera pipelines med config-dict”?

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. Strukturera transformeringssteg som funktioner
  2. Parameterisera pipelines med config-dict
  3. Testa pipelinesteg med assertions
  4. Schemaläggning och loggning av pipelinekörningar
← Tillbaka till Pandas & NumPy Academy