Natuurlijk! Hier zijn enkele geavanceerde datatransformatietechnieken in Pandas, inclusief voorbeelden en uitleg: 1. Window functies (bijvoorbeeld cumulatief, rolling en expanding) a) Cumulatieve som per winkel (store_id): ```python import pandas as pd # Stel dat df je DataFrame is # Sorteren op winkel en datum voor correcte cumulatie df = df.sort_values(['store_id', 'datum']) # Cumulatieve som van verkopen per winkel df['cumulatieve_verkopen'] = df.groupby('store_id')['verkopen'].cumsum() ``` **Uitleg:** Hier wordt de cumulatieve som van 'verkopen' berekend per winkel. Door eerst te sorteren op 'store_id' en 'datum' voorkom je dat de cumulatie fout gaat door verkeerde volgorde. --- b) Rolling gemiddelde van verkopen over de laatste 7 dagen per winkel: ```python # Stel dat 'datum' als datetime is geparset df['datum'] = pd.to_datetime(df['datum']) # Sorteer voor rolling df = df.sort_values(['store_id', 'datum']) # Groep per winkel, rolling window van 7 dagen df['rolling_gemiddelde'] = df.groupby('store_id')['verkopen'].transform(lambda x: x.rolling(window='7D', on=df['datum']).mean()) ``` **Uitleg:** Hier wordt een rollend gemiddelde over 7 dagen berekend, waardoor je trends over korte periodes kunt analyseren. De 'transform' met 'lambda' maakt het mogelijk om de rolling operatie te gebruiken met een tijdsgebaseerde window. --- c) Expanding (uitbreidende) som per winkel: ```python df['expanding_som'] = df.groupby('store_id')['verkopen'].expanding().sum().reset_index(level=0, drop=True) ``` **Uitleg:** De expanding-functie berekent een cumulatief totaal dat bij elke rij groeit, met name handig voor progressieve analyses. --- 2. Conditionele transformaties gebaseerd op meerdere criteria Voorbeeld: Markeer winkels waar de verkoop onder een drempel ligt en het aantal retouren hoog is: ```python # Stel drempels in drempel_verkopen = 50 retouren_drempel = 10 # Conditionele kolom toevoegen df['laag_verkopen_hoog_retouren'] = ((df['verkopen'] < drempel_verkopen) & (df['retouren'] > retouren_drempel)) ``` **Uitleg:** Hier wordt een Booleaanse kolom gemaakt die aangeeft of beide voorwaarden tegelijk gelden. Dit kan verder worden gebruikt voor filtering of analyse. --- 3. Verwerken van multi-index DataFrames voor hiërarchische data-analyse a) Multi-index maken: ```python # Stel dat we willen indexeren op 'store_id' en 'datum' df_multi = df.set_index(['store_id', 'datum']) ``` b) Groeperingen en aggregaties op hiërarchische index: ```python # Gemiddelde verkoop per winkel gemiddelde_verkopen = df_multi['verkopen'].groupby(level='store_id').mean() # Totale retouren per winkel per maand # Eerst een kolom voor maand maken df['maand'] = df['datum'].dt.to_period('M') df_multi = df.set_index(['store_id', 'maand']) retouren_per_maand = df_multi['retouren'].groupby(level=['store_id', 'maand']).sum() ``` c) Gebruik van 'unstack' om data te pivoteren: ```python # Data per winkel en maand, transponeren pivot_df = retouren_per_maand.unstack(level='store_id') ``` **Uitleg:** Multi-index maakt hiërarchische data-analyses mogelijk, bijvoorbeeld per winkel en per maand. 'groupby' met 'level' geeft je de controle over hiërarchieën. --- **Samenvatting:** - Window functies helpen trends en cumulaties te berekenen. - Conditionele transformaties maken complexe criteria mogelijk voor data-labeling of filtering. - Multi-index DataFrames ondersteunen hiërarchische analyses en pivoteren voor overzichtelijke samenvattingen. Wil je een specifiek voorbeeld met jouw data of verder in een bepaald aspect duiken?

Zeker, ik help je graag met geavanceerde datatransformatietechnieken in Pandas. Hier zijn concrete voorbeelden met uitleg: ## 1. Window Functies en Cumulatieve Bewerkingen ```python import pandas as pd import numpy as np # Voorbeeld DataFrame aanmaken data = { 'store_id': [1, 1, 1, 2, 2, 2, 3, 3, 3], 'datum': pd.date_range('2024-01-01', periods=9, freq='D'), 'verkopen': [100, 150, 200, 120, 180, 160, 90, 110, 130], 'retouren': [10, 15, 20, 12, 18, 16, 9, 11, 13] } df = pd.DataFrame(data) # Sorteren op winkel en datum voor window functies df = df.sort_values(['store_id', 'datum']) # Rolling gemiddelde van verkopen per winkel (3-daags) df['rolling_avg_verkopen'] = df.groupby('store_id')['verkopen'].transform( lambda x: x.rolling(window=3, min_periods=1).mean() ) # Expanding totaal van retouren per winkel df['expanding_totaal_retouren'] = df.groupby('store_id')['retouren'].transform( lambda x: x.expanding().sum() ) # Cumulatieve netto-omzet (verkopen - retouren) df['cumulatieve_netto'] = df.groupby('store_id').apply( lambda x: (x['verkopen'] - x['retouren']).cumsum() ).reset_index(level=0, drop=True) print("DataFrame met window functies:") print(df) ``` **Logica**: Window functies werken binnen `groupby()` om per winkel tijdsgebonden patronen te analyseren. `rolling()` voor vaste periodes, `expanding()` voor cumulatieve groei. ## 2. Conditionele Transformaties met Meerdere Criteria ```python # Geavanceerde conditionele transformaties df['verkoop_categorie'] = np.where( (df['verkopen'] > 150) & (df['retouren']/df['verkopen'] < 0.1), 'Hoog_LaagRetour', np.where( (df['verkopen'] > 100) & (df['retouren']/df['verkopen'] >= 0.1), 'Medium_HoogRetour', 'Laag_Onbekend' ) ) # Dynamische berekening gebaseerd op meerdere voorwaarden def calculate_bonus(row): if row['verkopen'] > 180 and row['retouren'] < 15: return row['verkopen'] * 0.1 elif row['verkopen'] > 150 and row['retouren']/row['verkopen'] < 0.08: return row['verkopen'] * 0.05 else: return 0 df['bonus'] = df.apply(calculate_bonus, axis=1) # Conditionele moving average alleen voor bepaalde periodes df['conditional_ma'] = df.groupby('store_id').apply( lambda x: x['verkopen'].where(x['verkopen'] > 100).rolling(2).mean() ).reset_index(level=0, drop=True) print("\nDataFrame met conditionele transformaties:") print(df[['store_id', 'datum', 'verkopen', 'retouren', 'verkoop_categorie', 'bonus', 'conditional_ma']]) ``` **Logica**: Combinatie van `np.where()`, `apply()` met custom functies, en conditionele window operations voor complexe bedrijfslogica. ## 3. Multi-Index DataFrame voor Hiërarchische Analyse ```python # Multi-index aanmaken voor geavanceerde analyse multi_df = df.set_index(['store_id', 'datum']) multi_df = multi_df.sort_index() # Hiërarchische aggregaties store_stats = multi_df.groupby(level='store_id').agg({ 'verkopen': ['mean', 'std', 'sum'], 'retouren': ['mean', 'sum', lambda x: (x/x.sum()).mean()], # Gewogen gemiddelde 'bonus': 'sum' }) # Multi-level column names store_stats.columns = ['_'.join(col).strip() for col in store_stats.columns.values] store_stats = store_stats.rename(columns={ 'retouren_<lambda_0>': 'retouren_gewicht' }) print("\nMulti-index aggregatie per winkel:") print(store_stats) # Cross-section analysis voor specifieke winkel winkel_1_data = multi_df.xs(1, level='store_id') print(f"\nData voor winkel 1:\n{winkel_1_data}") # Hierarchische rolling calculations multi_df['hierarchical_rolling'] = multi_df.groupby(level='store_id')['verkopen'].rolling( window=2, min_periods=1 ).mean().reset_index(level=0, drop=True) ``` **Logica**: Multi-index stelt hiërarchische queries en aggregaties mogelijk. `xs()` voor cross-section analysis, hierarchische grouping met `level` parameter. ## 4. Geavanceerde Time-Series Analyse ```python # Time-based resampling per winkel df.set_index('datum', inplace=True) resampled_data = df.groupby('store_id').resample('2D').agg({ 'verkopen': ['sum', 'mean', 'count'], 'retouren': 'sum' }).dropna() # Flatten multi-level columns resampled_data.columns = ['_'.join(col).strip() for col in resampled_data.columns.values] print("\nGeresusperde data per 2 dagen:") print(resampled_data) # Percentage change per winkel df['pct_change_verkopen'] = df.groupby('store_id')['verkopen'].pct_change() df['pct_change_retouren'] = df.groupby('store_id')['retouren'].pct_change() # Vorige periode vergelijking df['vorige_verkopen'] = df.groupby('store_id')['verkopen'].shift(1) df['verschil_vorige'] = df['verkopen'] - df['vorige_verkopen'] ``` ## 5. Performance Optimalisatie Tips ```python # Gebruik vectorized operations i.p.v. apply() waar mogelijk df['netto_ratio'] = (df['verkopen'] - df['retouren']) / df['verkopen'] # Efficiente grouping met transform df['store_avg_verkopen'] = df.groupby('store_id')['verkopen'].transform('mean') # Categorical data voor geheugenoptimalisatie df['store_id'] = df['store_id'].astype('category') # Gebruik eval() voor complexe berekeningen (optioneel) df = df.eval('efficiency = (verkopen - retouren) / verkopen') ``` **Belangrijke concepten**: - **Window functies**: Tijdsgebonden patronen analyseren - **Conditionele logica**: Complexe bedrijfsregels implementeren - **Multi-index**: Hiërarchische data-structuren beheren - **Vectorization**: Performance optimaliseren - **Groupby transform**: Efficient per groep berekenen Deze technieken stellen je in staat om complexe retail analyses uit te voeren met behoud van performance en leesbaarheid.