Analyse en KPI-berekening
Bereken maandelijkse cohortretentie, omzet per product en het voortschrijdende aantal actieve gebruikers over 30 dagen met groupby, pivot en rolling.
Analyse en KPI-berekening is een gratis Pandas & NumPy Academy-les op CoddyKit. Dit is les 3 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.
Analyseklare gegevens laden
Laad nadat de opschoning en het maken van kenmerken zijn voltooid het controlepunt analysis_ready.parquet en begin met het berekenen van KPI's. Deze fase bestaat uitsluitend uit analyse — er worden geen gegevens meer opgeschoond. Met een schoon, gevalideerd controlepunt kun je KPI-definities snel aanpassen zonder de tijdrovende fasen voor gegevensinname en opschoning opnieuw uit te voeren. De drie te berekenen KPI's zijn: maandelijkse cohortretentie, productomzet per categorie en voortschrijdende actieve gebruikers over 30 dagen.
import pandas as pd
df = pd.read_parquet('output/analysis_ready.parquet')
print(f'Loaded: {df.shape}')
print('KPIs to compute:')
print(' 1. Monthly cohort retention matrix')
print(' 2. Category revenue and margin ranking')
print(' 3. Rolling 30-day active users per region')KPI 1: Maandelijkse omzet per categorie
De eerste KPI is maandelijkse omzet per categorie. Groepeer op zowel year_month als category, tel de omzet op en maak een draaitabel met categorieën als kolommen en maanden als rijen. Deze draaitabel vormt de basis voor de trendlijngrafiek en de staafgrafiek met de belangrijkste categorieën in het rapport. Pas een voortschrijdend gemiddelde van drie maanden toe om de trend af te vlakken en seizoenspatronen zichtbaar te maken.
import pandas as pd
df = pd.read_parquet('output/analysis_ready.parquet')
# Monthly revenue by category
monthly_cat = (
df.groupby(['year_month', 'category'])['revenue']
.sum()
.reset_index()
.pivot(index='year_month', columns='category', values='revenue')
.fillna(0)
.sort_index()
)
# 3-month rolling average
monthly_cat_smooth = monthly_cat.rolling(3, min_periods=1).mean()
print('Monthly revenue by category (head):')
print(monthly_cat.round(0).head())
print('Shape:', monthly_cat.shape)KPI 2: Belangrijkste regio's op totale omzet
Rangschik regio's op basis van de totale omzet over de volledige periode. Gebruik groupby().agg() om meerdere statistieken tegelijk te berekenen: totale omzet, aantal bestellingen, unieke klanten en gemiddelde bestelwaarde. Sorteer aflopend op totale omzet en houd de top 10 over. Bereken het omzetaandeel van elke regio ten opzichte van het totaal — hiermee wordt concentratierisico zichtbaar (als 80% van de omzet uit één regio komt, is het bedrijf geografisch kwetsbaar).
import pandas as pd
df = pd.read_parquet('output/analysis_ready.parquet')
region_kpi = (
df.groupby('region')
.agg(
total_revenue=('revenue', 'sum'),
order_count=('order_id', 'nunique'),
unique_customers=('customer_id', 'nunique'),
avg_order_value=('revenue', 'mean')
)
.reset_index()
.sort_values('total_revenue', ascending=False)
)
total = region_kpi['total_revenue'].sum()
region_kpi['revenue_share'] = (region_kpi['total_revenue'] / total).round(3)
print(region_kpi.head(10).to_string(index=False))KPI 3: Cohortretentiematrix
De cohortretentiematrix toont welk percentage van de klanten uit elk acquisitiecohort in elke volgende periode minstens één aankoop deed. Bereken dit in drie stappen: (1) wijs elke bestelling een 'period number' toe: het aantal maanden sinds de cohortmaand van de klant; (2) groepeer op cohort en period number en tel het aantal unieke klanten; (3) deel door de cohortomvang (het aantal in periode 0) om de retentiepercentages te krijgen. Maak vervolgens een draaitabel in de vorm cohort × periode.
import pandas as pd
df = pd.read_parquet('output/analysis_ready.parquet')
# Compute months since cohort start
df['cohort_period'] = (
(df['order_date'].dt.to_period('M') -
pd.PeriodIndex(df['cohort_month'], freq='M'))
.apply(lambda x: x.n)
)
cohort_data = (
df.groupby(['cohort_month', 'cohort_period'])['customer_id']
.nunique()
.reset_index()
.rename(columns={'customer_id': 'customers'})
)
# Pivot: rows=cohort, columns=period
cohort_pivot = cohort_data.pivot(
index='cohort_month', columns='cohort_period', values='customers'
)
cohort_sizes = cohort_pivot[0]
retention = cohort_pivot.divide(cohort_sizes, axis=0).round(3)
print('Retention matrix (first 3 cohorts):')
print(retention.head(3))KPI 4: Voortschrijdende actieve gebruikers over 30 dagen
Daily Active Users (DAU) en varianten met voortschrijdende vensters zijn belangrijke product-KPI's. Bereken het aantal unieke klanten dat in een willekeurig venster van 30 dagen een aankoop deed. Bereken eerst het dagelijkse aantal unieke kopers, stel de datum in als index en pas vervolgens rolling('30D').apply(lambda x: x.nunique()) toe — maar let op: rolling op een DatetimeIndex vereist een specifieke aggregatie. Een alternatief is een aangepaste vensterfunctie die unieke waarden met behulp van verzamelingen berekent.
import pandas as pd
df = pd.read_parquet('output/analysis_ready.parquet')
# Daily unique purchasers
daily = (
df.groupby('order_date')['customer_id']
.nunique()
.reset_index()
.rename(columns={'customer_id': 'daily_unique_customers'})
.set_index('order_date')
.sort_index()
)
# 30-day rolling sum (approximation: sum of daily unique purchasers)
# True rolling unique requires custom logic
daily['rolling_30d'] = daily['daily_unique_customers'].rolling('30D').sum()
print('Rolling 30-day active customers:')
print(daily.tail())Omzetrangschikking per product
Rangschik voor een analyse op productniveau alle product-ID's op totale omzet en bereken hun cumulatieve omzetaandeel. Hiermee zie je of de omzet een Paretoverdeling volgt (een veelvoorkomende bevinding: ongeveer 20% van de producten genereert ongeveer 80% van de omzet). Bereken de cumulatieve omzetkolom met .cumsum() en vind het aantal producten waarbij het cumulatieve aandeel boven 80% komt. Deze analyse helpt bij beslissingen over prioritering van het productportfolio.
import pandas as pd
df = pd.read_parquet('output/analysis_ready.parquet')
product_rev = (
df.groupby('product_id')['revenue']
.sum()
.sort_values(ascending=False)
.reset_index()
)
total_rev = product_rev['revenue'].sum()
product_rev['rev_share'] = product_rev['revenue'] / total_rev
product_rev['cumulative_share'] = product_rev['rev_share'].cumsum()
pct80_cutoff = (product_rev['cumulative_share'] <= 0.80).sum()
total_products = len(product_rev)
print(f'Top {pct80_cutoff} of {total_products} products ({pct80_cutoff/total_products:.0%}) '
f'generate 80% of revenue (Pareto)')
print(product_rev.head())Alle KPI-tabellen opslaan
Sla elke KPI-tabel op in een Parquet-bestand met een herkenbare naam in de uitvoermap. De naamgevingsconventie is: kpi_{name}.parquet. Hierdoor wordt de visualisatiefase eenvoudig — die leest precies de vooraf berekende tabel die nodig is, zonder iets opnieuw te berekenen. Sla ook een gecombineerde KPI-samenvatting op als CSV, zodat je die gemakkelijk kunt delen met niet-technische belanghebbenden die het bestand mogelijk in Excel openen.
import pandas as pd
# Save all KPI tables
monthly_cat.to_parquet('output/kpi_monthly_category_revenue.parquet')
region_kpi.to_parquet('output/kpi_region_summary.parquet', index=False)
retention.to_parquet('output/kpi_cohort_retention.parquet')
daily.to_parquet('output/kpi_rolling_active_users.parquet')
product_rev.to_parquet('output/kpi_product_ranking.parquet', index=False)
# Also a CSV summary for sharing
region_kpi.to_csv('output/region_summary.csv', index=False)
print('All KPI tables saved:')
print(' kpi_monthly_category_revenue.parquet')
print(' kpi_region_summary.parquet')
print(' kpi_cohort_retention.parquet')
print(' kpi_rolling_active_users.parquet')
print(' kpi_product_ranking.parquet')Statistische validatie van KPI's
Voer voordat je de KPI's definitief maakt statistische controles uit: test met een eenzijdige t-test tegen nulgroei of de maandelijkse omzetgroei statistisch significant is en controleer met een eenweg-ANOVA of omzetverschillen tussen regio's significant zijn. 'Regio met de hoogste omzet' rapporteren betekent meer wanneer je kunt bevestigen dat het verschil waarschijnlijk niet door toevallige variatie komt. Voeg p-waarden als metagegevenskolommen toe aan de KPI-tabellen.
import pandas as pd
import numpy as np
from scipy import stats
df = pd.read_parquet('output/analysis_ready.parquet')
# Is revenue growth statistically significant?
monthly_total = df.groupby('year_month')['revenue'].sum().sort_index()
month_changes = monthly_total.diff().dropna()
stat, p = stats.ttest_1samp(month_changes, popmean=0)
print(f'Monthly growth test: mean={month_changes.mean():.0f}, p={p:.4f}')
print('Significant positive trend?', month_changes.mean() > 0 and p < 0.05)
# ANOVA: do regions differ significantly?
groups = [g['revenue'].values for _, g in df.groupby('region')]
f, p_anova = stats.f_oneway(*groups)
print(f'Region ANOVA: F={f:.3f}, p={p_anova:.4f}')Groeipercentage van maand op maand berekenen
Het groeipercentage van maand op maand (MoM) is een fundamentele bedrijfs-KPI: growth = (current - previous) / previous × 100. Gebruik pct_change() voor een nette berekening. Een voortschrijdend gemiddelde van drie maanden van de MoM-groei maakt de onderliggende trend zichtbaar en vlakt maandelijkse schommelingen af. Negatieve groeipercentages zijn net zo belangrijk om te benadrukken als positieve — ze wijzen op perioden die nader onderzoek vereisen.
import pandas as pd
df = pd.read_parquet('output/analysis_ready.parquet')
monthly_total = (
df.groupby('year_month')['revenue'].sum().sort_index()
)
growth = monthly_total.pct_change() * 100
trend = growth.rolling(3, min_periods=1).mean()
kpi_growth = pd.DataFrame({
'revenue': monthly_total,
'mom_growth_pct': growth.round(2),
'trend_3m_avg': trend.round(2)
})
print(kpi_growth.tail(6))
print(f'\nBest month: {monthly_total.idxmax()} (${monthly_total.max():,.0f})')
print(f'Worst month: {monthly_total.idxmin()} (${monthly_total.min():,.0f})')Geautomatiseerde detectie van afwijkingen
Markeer afwijkende maanden automatisch: maanden waarin de omzet meer dan 2 standaardafwijkingen afwijkt van het voortschrijdende gemiddelde over 6 maanden. Deze maanden zijn het onderzoeken waard — ze kunnen wijzen op echte bedrijfsgebeurtenissen (een succesvolle campagne, een gegevensstoring) of problemen met de gegevenskwaliteit (dubbele gegevens die twee keer zijn geladen). Anomaliedetectie is een waardevolle aanvulling op elk dashboard voor geautomatiseerde gegevensverwerkingsprocessen en helpt analisten hun onderzoek te richten op de belangrijkste perioden.
import pandas as pd
import numpy as np
df = pd.read_parquet('output/analysis_ready.parquet')
monthly = df.groupby('year_month')['revenue'].sum().sort_index()
rolling_mean = monthly.rolling(6, min_periods=3).mean()
rolling_std = monthly.rolling(6, min_periods=3).std()
anomalies = monthly[
(monthly > rolling_mean + 2 * rolling_std) |
(monthly < rolling_mean - 2 * rolling_std)
]
print('Anomalous months (>2 std from 6-month rolling mean):')
if len(anomalies) > 0:
print(anomalies.round(0))
else:
print('None detected')Overzichtstabel met KPI's
Stel één samenvattingstabel voor leidinggevenden samen met de belangrijkste waarden van alle KPI's: totale omzet, totaal aantal bestellingen, unieke klanten, gemiddelde bestelwaarde, beste regio, beste categorie en gemiddelde retentie van cohorten na 30 dagen in maand 3. Deze samenvatting in één tabel vormt de eerste pagina van het rapport — belanghebbenden krijgen zo direct een overzicht van de belangrijkste cijfers voordat ze de grafieken en gedetailleerde tabellen bekijken.
import pandas as pd
df = pd.read_parquet('output/analysis_ready.parquet')
retention = pd.read_parquet('output/kpi_cohort_retention.parquet')
region_kpi = pd.read_parquet('output/kpi_region_summary.parquet')
summary = {
'Total Revenue': f'${df["revenue"].sum():,.0f}',
'Total Orders': f'{df["order_id"].nunique():,}',
'Unique Customers': f'{df["customer_id"].nunique():,}',
'Avg Order Value': f'${df["revenue"].mean():.2f}',
'Best Region': region_kpi.iloc[0]["region"],
'Best Category': df.groupby("category")["revenue"].sum().idxmax(),
'Avg Month-3 Retention': f'{retention.get(3, pd.Series([0])).mean():.1%}'
}
for k, v in summary.items():
print(f'{k:25s}: {v}')Korte controle
Test je begrip van de concepten voor gegevensanalyse uit deze les.
Samenvatting van de les
In deze les heb je geleerd dat groupby + pivot de matrix voor de maandelijkse omzet per categorie en de cohort-retentietabel maakt, dat rolling() afgevlakte trends en benaderingen van actieve gebruikers over 30 dagen berekent, en dat statistische validatie (een t-toets voor groei, ANOVA voor regionale verschillen) meer onderbouwing geeft aan het KPI-verhaal. Hierna visualiseren we alle resultaten in een figuur met meerdere panelen en exporteren we het definitieve rapport.
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 “Analyse en KPI-berekening” gratis?
Ja — de volledige tekst van “Analyse en KPI-berekening” 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 “Analyse en KPI-berekening”?
Bereken maandelijkse cohortretentie, omzet per product en het voortschrijdende aantal actieve gebruikers over 30 dagen met groupby, pivot en rolling. 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 3 van 4.
Hoe lang duurt de les “Analyse en KPI-berekening”?
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
- Project instellen en gegevens inlezen
- Gegevens opschonen en features construeren
- Analyse en KPI-berekening
- Definitieve visualisatie en export van het rapport