0Pricing
Pandas & NumPy Academy · Lezione

Visualizzazione finale ed esportazione del report

Crei una figura Matplotlib multipannello con grafici annotati, la esporti in formato PNG e PDF e scriva un riepilogo strutturato in un file Markdown.

Visualizzazione finale ed esportazione del report è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Il risultato finale

L'ultima fase del progetto trasforma i KPI calcolati in un prodotto finale curato e facile da condividere: una figura Matplotlib multipannello con grafici annotati e un report markdown strutturato con riferimenti alle visualizzazioni incorporate. È ciò che gli stakeholder ricevono concretamente: visualizzazioni chiare e un riepilogo narrativo. Una buona visualizzazione trasforma i numeri in informazioni utili; una buona struttura del report rende tali informazioni utilizzabili per agire. Questa lezione tratta l'architettura delle figure, le annotazioni, l'esportazione in PNG/PDF e la generazione di markdown strutturato.

Configurazione della figura multipannello

Utilizzare plt.subplots() con figsize e gridspec_kw per creare una figura con pannelli di dimensioni diverse. Un layout comune per un report dirigenziale prevede un ampio grafico delle tendenze nella parte superiore, con una heatmap della retention e un grafico a barre delle regioni nella riga inferiore. Impostare fin dall'inizio uno stile coerente con plt.style.use('seaborn-v0_8-whitegrid') per ottenere grafici puliti e dall'aspetto professionale senza formattare manualmente ogni elemento.

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

Pannello 1: andamento dei ricavi mensili

Rappresentare i ricavi mensili totali con una linea e dei marcatori, sovrapporre una media mobile di 3 mesi e ombreggiare l'area sotto la linea dei valori effettivi. Annotare i mesi di picco e di minimo con frecce e testo usando ax.annotate(). In questo modo il messaggio è immediato: si vede quando i ricavi sono stati più elevati, quando sono diminuiti e se la tendenza a lungo termine è positiva. Utilizzare colori che distinguano i valori effettivi da quelli smussati senza creare contrasti sgradevoli.

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

Pannello 2: heatmap della retention delle coorti

Visualizzare la matrice della retention delle coorti come una heatmap codificata a colori usando Seaborn. Normalizzare i valori in modo che il 100% (periodo 0) corrisponda al colore più brillante e che la diminuzione della retention sia rappresentata da tonalità progressivamente più scure. Mascherare le celle NaN (periodi futuri non ancora verificatisi) per mantenere il grafico pulito. Annotare ogni cella con il valore percentuale per facilitarne la lettura. Questo grafico è uno degli strumenti più utili per comprendere i modelli di fidelizzazione dei clienti.

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

Pannello 3: grafico a barre orizzontali delle regioni principali

Un grafico a barre orizzontali è ideale per confrontare i nomi delle regioni (etichette testuali sull'asse y) in base ai ricavi. Ordinare le barre in ordine decrescente, in modo che la regione migliore si trovi in alto. Aggiungere i valori dei ricavi alla fine di ogni barra usando ax.text(). Utilizzare una palette di colori divergente basata sulla quota di ricavi: alla regione principale deve corrispondere il colore più intenso. Questo grafico comunica immediatamente la concentrazione geografica e le prestazioni regionali.

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

Salvataggio della figura multipannello

Esportare la figura completata in due formati: PNG per inserirla in presentazioni e report web, e PDF per la stampa ad alta risoluzione. Utilizzare dpi=150 o un valore superiore per il PNG, così da garantire una figura nitida alla risoluzione dello schermo. Passare bbox_inches='tight' per evitare che le etichette vengano tagliate ai bordi della figura. Salvare nella directory di output stabilita durante la configurazione del progetto.

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

Scrittura del report markdown strutturato

Generare il report testuale scrivendo programmaticamente un file markdown strutturato. Includere un'intestazione, un riepilogo esecutivo con i KPI principali, i risultati chiave di ciascuna sezione dell'analisi e i riferimenti ai file delle figure salvate. Generando il report dal codice invece di scriverlo manualmente, ogni esecuzione produce un report aggiornato e accurato, basato sui valori effettivamente calcolati. Utilizzare le f-string di Python per incorporare direttamente nel testo i numeri calcolati.

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

Aggiunta di annotazioni ai grafici

I grafici efficaci raccontano una storia attraverso le annotazioni. Utilizzare ax.axvline() per indicare eventi importanti (il lancio di un prodotto, una variazione dei prezzi), ax.axhspan() per ombreggiare i periodi di recessione e ax.annotate() per evidenziare con testo e frecce i punti dati degni di nota. Etichettare gli assi con le unità (ax.set_ylabel('Revenue ($)')), aggiungere un titolo descrittivo, includere una legenda quando vengono mostrate più serie e formattare le etichette delle tacche per facilitarne la lettura usando 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()

Esportazione delle tabelle di dati in Excel

Alcuni stakeholder preferiscono Excel ai report markdown. Utilizzare pd.ExcelWriter per esportare più DataFrame in fogli diversi di un'unica cartella di lavoro Excel. Si tratta di un prodotto finale professionale per gli stakeholder aziendali che desiderano esplorare autonomamente i dati. Utilizzare startrow e startcol per disporre le tabelle all'interno di un foglio e aggiungere un foglio 'Summary' con i numeri di sintesi come prima scheda.

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

Automazione della generazione dei report

Racchiudere l'intera pipeline — acquisizione, pulizia, calcolo dei KPI, visualizzazione ed esportazione del report — in una funzione main() eseguibile dalla riga di comando. Utilizzare il modulo logging di Python per registrare gli orari di inizio e fine, il numero di righe a ogni fase e le eventuali anomalie rilevate. Una pipeline eseguibile dall'inizio alla fine con un unico comando python pipeline.py è pronta per l'automazione pianificata tramite cron, Airflow o un pianificatore cloud.

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

Completamento del corso e prossimi passaggi

Ha completato il percorso Data Analysis: Pandas & NumPy. Ora è in grado di: creare e trasformare array NumPy con broadcasting e algebra lineare, creare e manipolare DataFrame Pandas da qualsiasi origine dati, pulire, rimodellare e aggregare dataset del mondo reale, creare visualizzazioni di qualità editoriale con Matplotlib e Seaborn, applicare test statistici con SciPy, gestire dataset di grandi dimensioni con il chunking e Dask, integrare Pandas con database SQL e progettare pipeline di dati riproducibili dall'inizio alla fine. Queste competenze sono alla base di ogni ruolo basato sui dati nel settore.

Verifica rapida

Verifichi la Sua comprensione dei concetti di analisi dei dati trattati in questa lezione.

Riepilogo della lezione

In questa lezione finale ha appreso che le figure Matplotlib multipannello con GridSpec consentono di creare layout professionali per i report, combinando più tipi di grafico; le annotazioni (axvline, annotate, text) aggiungono contesto narrativo ai grafici; e la generazione automatizzata dei report (markdown, Excel, PNG, PDF) all'interno di una funzione main() rende la pipeline pianificabile e riproducibile. Congratulazioni per aver completato il percorso Pandas e NumPy: ora è pronto ad affrontare sfide di analisi dei dati del mondo reale!

Domande Frequenti

La lezione «Visualizzazione finale ed esportazione del report» è gratuita?

Sì — il testo completo di «Visualizzazione finale ed esportazione del report» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Cosa imparerò in «Visualizzazione finale ed esportazione del report»?

Crei una figura Matplotlib multipannello con grafici annotati, la esporti in formato PNG e PDF e scriva un riepilogo strutturato in un file Markdown. Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?

Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Visualizzazione finale ed esportazione del report»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?

Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Configurazione del progetto e acquisizione dei dati
  2. Pulizia dei dati e feature engineering
  3. Analisi e calcolo dei KPI
  4. Visualizzazione finale ed esportazione del report
← Torna a Pandas & NumPy Academy