Pandas & NumPy Academy · Les

Definitieve visualisatie en export van het rapport

Maak een Matplotlib-figuur met meerdere panelen en geannoteerde grafieken, exporteer deze naar PNG en PDF en schrijf een gestructureerde samenvatting naar een markdown-bestand.

Les 4 van 413 stappen

Definitieve visualisatie en export van het rapport 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 uiteindelijke resultaat

In de laatste fase van het eindproject worden berekende KPI's omgezet in een verzorgd, deelbaar resultaat: een Matplotlib-figuur met meerdere panelen en toelichtingen, plus een gestructureerd markdown-rapport met ingesloten verwijzingen naar visualisaties. Dit ontvangen belanghebbenden daadwerkelijk — duidelijke visualisaties en een samenvattend verhaal. Goede visualisatie zet cijfers om in inzichten; een goede rapportstructuur maakt die inzichten bruikbaar. In deze les behandelen we de opbouw van figuren, toelichtingen, export naar PNG/PDF en het genereren van gestructureerde markdown.

De figuur met meerdere panelen instellen

Gebruik plt.subplots() met figsize en gridspec_kw om een figuur te maken met panelen van verschillende afmetingen. Een veelgebruikte indeling voor een rapport voor leidinggevenden is een brede trendgrafiek bovenaan en een heatmap voor retentie met een staafgrafiek voor regio's op de onderste rij. Stel vooraf een consistente stijl in met plt.style.use('seaborn-v0_8-whitegrid') voor overzichtelijke, professioneel uitziende grafieken zonder elk onderdeel handmatig op te maken.

import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec

plt.style.use('seaborn-v0_8-whitegrid')

# 2x2 layout with custom row heights
fig = plt.figure(figsize=(16, 12))
gs = gridspec.GridSpec(2, 2,
                       height_ratios=[1, 1.2],
                       hspace=0.4, wspace=0.35)

ax_trend   = fig.add_subplot(gs[0, :])   # full width top row
ax_heatmap = fig.add_subplot(gs[1, 0])   # bottom left
ax_bar     = fig.add_subplot(gs[1, 1])   # bottom right

print('Figure with 3 panels created.')

Paneel 1: Lijngrafiek van de maandelijkse omzettrend

Geef de totale maandelijkse omzet weer als een lijn met markeringen, leg daar een voortschrijdend gemiddelde over 3 maanden overheen en kleur het gebied onder de werkelijke lijn in. Licht de maanden met de piek en het dal toe met pijlen en tekst via ax.annotate(). Zo wordt het verhaal direct duidelijk: wanneer de omzet het sterkst was, wanneer deze daalde en of de langetermijntrend positief is. Gebruik kleuren die de werkelijke waarden onderscheiden van de afgevlakte waarden zonder met elkaar te botsen.

import pandas as pd
import matplotlib.pyplot as plt

monthly = pd.read_parquet('output/kpi_monthly_category_revenue.parquet')
monthly_total = monthly.sum(axis=1)

ax = plt.gca()
ax.plot(monthly_total.index, monthly_total.values,
        marker='o', linewidth=2, color='#2196F3', label='Monthly Revenue')
ax.plot(monthly_total.index,
        monthly_total.rolling(3, min_periods=1).mean().values,
        linewidth=2, linestyle='--', color='#FF5722', label='3-Month Avg')
ax.fill_between(monthly_total.index, monthly_total.values, alpha=0.1, color='#2196F3')

# Annotate peak
peak_idx = monthly_total.idxmax()
ax.annotate(f'Peak: ${monthly_total[peak_idx]/1e3:.0f}K',
            xy=(peak_idx, monthly_total[peak_idx]),
            xytext=(0, 20), textcoords='offset points',
            arrowprops=dict(arrowstyle='->', color='#E91E63'),
            color='#E91E63', fontsize=10)
ax.set_title('Monthly Revenue Trend', fontsize=14, fontweight='bold')
ax.legend()
plt.show()

Paneel 2: Heatmap van cohortretentie

Visualiseer de matrix met cohortretentie als een heatmap met kleurcodering met Seaborn. Normaliseer de waarden zodat 100% (periode 0) de helderste kleur heeft en afnemende retentie steeds donkerder wordt. Maskeer NaN-cellen (toekomstige perioden die nog niet hebben plaatsgevonden) om de grafiek overzichtelijk te houden. Voeg in elke cel de procentuele waarde toe zodat de grafiek snel kan worden gelezen. Deze grafiek is een van de waardevolste hulpmiddelen om patronen in klantloyaliteit te begrijpen.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

retention = pd.read_parquet('output/kpi_cohort_retention.parquet')

fig, ax = plt.subplots(figsize=(10, 6))

sns.heatmap(
    retention,
    annot=True,
    fmt='.0%',
    cmap='YlOrRd_r',
    mask=retention.isna(),
    linewidths=0.5,
    ax=ax,
    cbar_kws={'label': 'Retention Rate'}
)
ax.set_title('Cohort Retention Matrix', fontsize=14, fontweight='bold')
ax.set_xlabel('Months After First Purchase')
ax.set_ylabel('Cohort Month')
plt.tight_layout()
plt.show()

Paneel 3: Horizontale staafgrafiek van de beste regio's

Een horizontale staafgrafiek is ideaal om reg ionamen (tekstlabels op de y-as) op basis van omzet te vergelijken. Sorteer de staven in aflopende volgorde, zodat de beste regio bovenaan staat. Voeg aan het einde van elke staaf labels met de omzetwaarde toe met behulp van ax.text(). Gebruik een divergerend kleurenpalet op basis van het omzetaandeel — de beste regio krijgt de donkerste kleur. Deze grafiek maakt geografische concentratie en regionale prestaties direct inzichtelijk.

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np

region_kpi = pd.read_parquet('output/kpi_region_summary.parquet')
top5 = region_kpi.head(5).sort_values('total_revenue')

fig, ax = plt.subplots(figsize=(8, 5))
colors = cm.Blues(np.linspace(0.4, 0.9, len(top5)))

bars = ax.barh(top5['region'], top5['total_revenue'], color=colors)
for bar, val in zip(bars, top5['total_revenue']):
    ax.text(bar.get_width() * 1.01, bar.get_y() + bar.get_height()/2,
            f'${val/1e3:.0f}K', va='center', fontsize=9)

ax.set_title('Top 5 Regions by Revenue', fontsize=13, fontweight='bold')
ax.set_xlabel('Total Revenue ($)')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
plt.tight_layout()
plt.show()

De figuur met meerdere panelen opslaan

Exporteer de voltooide figuur in twee indelingen: PNG om deze in presentaties en web rapporten op te nemen, en PDF voor afdrukken met hoge resolutie. Gebruik dpi=150 of hoger voor PNG zodat de figuur scherp blijft op het scherm. Geef bbox_inches='tight' door om te voorkomen dat labels aan de rand van de figuur worden afgesneden. Sla de figuur op in de uitvoermap die tijdens het instellen van het project is aangemaakt.

import matplotlib.pyplot as plt

# After assembling all panels in the figure
fig.suptitle('2024 Sales Performance Report', fontsize=16,
             fontweight='bold', y=1.02)

# Save as PNG (for web/presentations)
fig.savefig('output/report_figure.png',
            dpi=150,
            bbox_inches='tight',
            facecolor='white')

# Save as PDF (for print)
fig.savefig('output/report_figure.pdf',
            bbox_inches='tight',
            facecolor='white')

print('Figures saved:')
print('  output/report_figure.png')
print('  output/report_figure.pdf')

Het gestructureerde markdown-rapport schrijven

Genereer het tekstrapport door programmatisch een gestructureerd markdown-bestand te schrijven. Voeg een koptekst, een samenvatting voor leidinggevenden met de belangrijkste KPI's, de belangrijkste bevindingen uit elk analyseonderdeel en verwijzingen naar de opgeslagen figuurbestanden toe. Door het rapport vanuit code te genereren in plaats van het handmatig te schrijven, levert elke uitvoering een nieuw, nauwkeurig rapport op dat de werkelijk berekende waarden weerspiegelt. Gebruik Python-f-strings om berekende getallen rechtstreeks in de tekst op te nemen.

import pandas as pd
from datetime import datetime

df = pd.read_parquet('output/analysis_ready.parquet')
region_kpi = pd.read_parquet('output/kpi_region_summary.parquet')
retention = pd.read_parquet('output/kpi_cohort_retention.parquet')

report = f'''
# 2024 Sales Performance Report

Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}

## Executive Summary

- **Total Revenue**: ${df['revenue'].sum():,.0f}
- **Total Orders**: {df['order_id'].nunique():,}
- **Unique Customers**: {df['customer_id'].nunique():,}
- **Top Region**: {region_kpi.iloc[0]['region']} (${region_kpi.iloc[0]['total_revenue']:,.0f})
- **Average Month-3 Retention**: {retention.get(3, pd.Series([0])).mean():.1%}

## Key Findings

1. Revenue grew steadily through the year with a peak in October.
2. The top region accounts for {region_kpi.iloc[0]['revenue_share']:.0%} of total revenue.
3. Month-3 cohort retention averages {retention.get(3, pd.Series([0])).mean():.1%}.

## Figures

![Revenue Trends](report_figure.png)
'''
with open('output/report.md', 'w') as f:
    f.write(report)
print('Report written to output/report.md')

Toelichtingen aan grafieken toevoegen

Effectieve grafieken vertellen een verhaal door middel van toelichtingen. Gebruik ax.axvline() om belangrijke gebeurtenissen te markeren (een productlancering, een prijswijziging), ax.axhspan() om perioden van recessie te markeren en ax.annotate() om opmerkelijke gegevenspunten met tekst en pijlen uit te lichten. Label de assen met eenheden (ax.set_ylabel('Revenue ($)')), voeg een beschrijvende titel toe, gebruik een legenda wanneer meerdere reeksen worden weergegeven en maak de labels van de maatstreepjes goed leesbaar met ax.yaxis.set_major_formatter(FuncFormatter(...)).

import matplotlib.pyplot as plt
import matplotlib.ticker as mticker
import pandas as pd

monthly_total = pd.read_parquet('output/kpi_monthly_category_revenue.parquet').sum(axis=1)

fig, ax = plt.subplots(figsize=(12, 5))
ax.plot(monthly_total.index, monthly_total.values, linewidth=2.5, color='#1565C0')

# Format y-axis as $K
ax.yaxis.set_major_formatter(
    mticker.FuncFormatter(lambda x, _: f'${x/1e3:.0f}K')
)

# Mark a hypothetical event
ax.axvline(x='2024-06', color='red', linestyle=':', alpha=0.6)
ax.text('2024-06', monthly_total.max() * 0.95,
        ' Campaign\n Launch', color='red', fontsize=9)

ax.set_title('Monthly Revenue 2024', fontsize=14, fontweight='bold')
ax.set_xlabel('Month')
ax.set_ylabel('Revenue')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

Gegevenstabellen naar Excel exporteren

Sommige belanghebbenden werken liever met Excel dan met markdown-rapporten. Gebruik pd.ExcelWriter om meerdere DataFrames naar verschillende werkbladen in één Excel-werkmap te exporteren. Dit is een professioneel resultaat voor zakelijke belanghebbenden die de gegevens zelf willen verkennen. Gebruik startrow en startcol om tabellen binnen een werkblad te rangschikken en voeg een werkblad 'Summary' met de belangrijkste cijfers als eerste tabblad toe.

import pandas as pd

region_kpi = pd.read_parquet('output/kpi_region_summary.parquet')
retention = pd.read_parquet('output/kpi_cohort_retention.parquet')
product_rank = pd.read_parquet('output/kpi_product_ranking.parquet')

with pd.ExcelWriter('output/sales_report_2024.xlsx', engine='openpyxl') as writer:
    region_kpi.to_excel(writer, sheet_name='Region KPIs', index=False)
    retention.to_excel(writer, sheet_name='Cohort Retention')
    product_rank.head(50).to_excel(writer, sheet_name='Top 50 Products', index=False)

print('Excel workbook written: output/sales_report_2024.xlsx')

Het genereren van rapporten automatiseren

Wikkel het volledige proces — inlezen, opschonen, KPI's berekenen, visualiseren en het rapport exporteren — in een main()-functie die vanaf de opdrachtregel kan worden uitgevoerd. Gebruik de Python-module logging om begin- en eindtijden, het aantal rijen in elke fase en gedetecteerde afwijkingen vast te leggen. Een proces dat volledig van begin tot eind wordt uitgevoerd met één opdracht, python pipeline.py, is klaar voor geplande automatisering via cron, Airflow of een cloudplanner.

import logging
import time
from datetime import datetime

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s'
)

def main():
    start = time.time()
    logging.info('Pipeline started')

    logging.info('Step 1: Data ingestion')
    # load_and_merge()  # returns df

    logging.info('Step 2: Data cleaning')
    # clean(df)  # returns df_clean

    logging.info('Step 3: KPI computation')
    # compute_kpis(df_clean)  # saves parquet files

    logging.info('Step 4: Visualisation and report export')
    # build_report()  # saves PNG, PDF, markdown, Excel

    elapsed = time.time() - start
    logging.info(f'Pipeline complete in {elapsed:.1f}s')

if __name__ == '__main__':
    main()

Cursus voltooien en volgende stappen

Je hebt het traject Data Analysis: Pandas & NumPy voltooid. Je kunt nu: NumPy-arrays maken en transformeren met broadcasting en lineaire algebra, Pandas-DataFrames maken en bewerken vanuit elke gegevensbron, realistische gegevensverzamelingen opschonen, hervormen en aggregeren, visualisaties van publicatiekwaliteit maken met Matplotlib en Seaborn, statistische toetsen toepassen met SciPy, met chunking en Dask werken met grote gegevensverzamelingen, Pandas integreren met SQL-databases en reproduceerbare end-to-end-processen voor gegevensverwerking ontwerpen. Deze vaardigheden vormen de basis van elke gegevensgedreven functie in de industrie.

Korte controle

Test je begrip van de concepten voor gegevensanalyse uit deze les.

Samenvatting van de les

In deze laatste les heb je geleerd dat Matplotlib-figuren met meerdere panelen met GridSpec professionele rapportindelingen mogelijk maken waarin meerdere grafiektypen worden gecombineerd, dat toelichtingen (axvline, annotate, text) grafieken van context in de vorm van een verhaal voorzien en dat geautomatiseerde rapportgeneratie (markdown, Excel, PNG, PDF) in een main()-functie het proces planbaar en reproduceerbaar maakt. Gefeliciteerd met het voltooien van het Pandas- en NumPy-traject — je bent klaar om echte uitdagingen in gegevensanalyse aan te pakken!

Gratis beginnen

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 “Definitieve visualisatie en export van het rapport” gratis?

Ja — de volledige tekst van “Definitieve visualisatie en export van het rapport” 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 “Definitieve visualisatie en export van het rapport”?

Maak een Matplotlib-figuur met meerdere panelen en geannoteerde grafieken, exporteer deze naar PNG en PDF en schrijf een gestructureerde samenvatting naar een markdown-bestand. 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 “Definitieve visualisatie en export van het rapport”?

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

  1. Project instellen en gegevens inlezen
  2. Gegevens opschonen en features construeren
  3. Analyse en KPI-berekening
  4. Definitieve visualisatie en export van het rapport
← Terug naar Pandas & NumPy Academy