Excel + Python è finalmente GA: 5 use case finanziari concreti per PMI italiane

Python in Excel — la capacità di scrivere codice Python direttamente in una cella di Excel e usarne i risultati come fossero formule — è in general availability da maggio 2026 su tutti i piani Microsoft 365 Business (Basic, Standard, Premium) ed Enterprise. Prima era una preview lunga durata partita a fine 2023 e disponibile solo a chi aveva Insider build.

La promessa è grossa: portare la potenza di pandas, NumPy, matplotlib, scikit-learn e altre 400+ librerie scientifiche dentro Excel, senza che l’utente debba installare Python, gestire ambienti virtuali, o passare per Jupyter. Il calcolo avviene lato Microsoft Cloud su container Anaconda gestiti, non sul PC dell’utente: il PC vede solo il risultato finale.

Vediamo cinque use case concreti che una PMI italiana può adottare subito, senza diventare data scientist e senza scrivere codice da zero (la sintassi di base si impara in mezza giornata).

Come funziona — i 30 secondi di setup

1. Apri Excel desktop (Win11 o Mac) con account Microsoft 365 Business.
2. Vai in una cella vuota → digita =PY( invece di una formula normale.
3. Si apre una mini-finestra di editor Python: scrivi codice usando pd (pandas), np (NumPy), plt (matplotlib) come fossero builtin.
4. Ctrl+Enter per eseguire → il risultato (dataframe, numero, grafico) appare nella cella.

Per referenziare dati Excel dentro Python: usa xl("A1:C100") per leggere un range, xl("Tabella1[Vendite]") per leggere una colonna di una tabella nominata. Il risultato è automaticamente un pandas.DataFrame.

Il calcolo gira in cloud (free fino a 100 minuti/mese su Business Basic, 600 minuti su Premium, illimitato su Enterprise). Latenza tipica: 2-4 secondi su dataset <10k righe.

Use case 1 — Cash flow forecasting con pandas

Scenario: PMI manifattura, foglio Excel con storico fatturazione mensile 36 mesi. Si vuole forecast prossimi 6 mesi tenendo conto della stagionalità.

Con formule Excel standard: medie mobili sui 12 mesi precedenti, ma rumorose e che non catturano la stagionalità trimestrale tipica del settore.

Con Python in Excel, in una cella:

import pandas as pd
df = xl("FattureMensili[#All]", headers=True)
df['data'] = pd.to_datetime(df['data'])
df.set_index('data', inplace=True)

# Decomposizione stagionalità + trend
from statsmodels.tsa.seasonal import seasonal_decompose
decomp = seasonal_decompose(df['fatturato'], model='multiplicative', period=12)

# Forecast 6 mesi con SARIMA
from statsmodels.tsa.statespace.sarimax import SARIMAX
model = SARIMAX(df['fatturato'], order=(1,1,1), seasonal_order=(1,1,1,12)).fit()
forecast = model.forecast(steps=6)
forecast

Risultato: una colonna con i 6 valori mensili previsti. Il modello SARIMA cattura sia il trend sottostante (crescita o decrescita) sia la stagionalità ricorrente. Un controller di gestione PMI può usarlo come input al budget rolling in 3 minuti invece di costruire un modello a mano.

Vedi il template Excel Budget & Cash Flow per la base dati su cui applicare questo tipo di analisi.

Use case 2 — Analisi vendite: clienti che si stanno raffreddando

Scenario: file CRM esportato in Excel con 5 anni di transazioni, 800 clienti. Identifica i clienti con trend di acquisto in calo negli ultimi 6 mesi rispetto alla media 24 mesi.

import pandas as pd
df = xl("Vendite[#All]", headers=True)
df['data'] = pd.to_datetime(df['data'])

# Media mensile per cliente — ultimi 24 mesi
ref = df[df['data'] >= pd.Timestamp.now() - pd.DateOffset(months=24)]
media_24m = ref.groupby('cliente')['importo'].mean()

# Media mensile per cliente — ultimi 6 mesi
recente = df[df['data'] >= pd.Timestamp.now() - pd.DateOffset(months=6)]
media_6m = recente.groupby('cliente')['importo'].mean()

# Calo > 30%
calo = (media_6m / media_24m - 1) * 100
clienti_freddi = calo[calo < -30].sort_values()
clienti_freddi.head(20)

Risultato: lista dei 20 clienti più “freddi” con percentuale di calo. Direttamente azionabile dal commerciale per pianificare follow-up. Operazione che con sole pivot Excel + formule prenderebbe 2 ore di lavoro.

Use case 3 — Scenario analysis di un investimento

Scenario: la PMI valuta un investimento in un nuovo macchinario (200k€), con stima ricavi annui aggiuntivi fra 60k e 120k€/anno. Vuole capire probabilità di rientro entro 4 anni.

import numpy as np

investimento = 200_000
costo_capitale = 0.04  # 4% rendimento alternativo
anni = 4

# Monte Carlo: 10.000 simulazioni
np.random.seed(42)
ricavi_simulati = np.random.uniform(60_000, 120_000, size=(10_000, anni))
costi_op = np.random.normal(15_000, 3_000, size=(10_000, anni))  # ~15k/anno

cash_flow = ricavi_simulati - costi_op
npv = np.sum(cash_flow / (1 + costo_capitale) ** np.arange(1, anni+1), axis=1) - investimento

prob_rientro = (npv > 0).mean() * 100
prob_rientro  # es. 73.2%

Risultato: probabilità in % che l’investimento rientri entro 4 anni con tasso interno di rendimento positivo. Strumento finanziariamente solido che si costruirebbe normalmente con software dedicati (Crystal Ball, @RISK) costosi.

Use case 4 — Trovare duplicati “fuzzy” nei dati clienti

Scenario: anagrafica clienti con duplicati nascosti causati da errori di digitazione (“Rossi & Figli SRL”, “Rossi e Figli s.r.l.”, “Rossi& Figli SRL”). Le formule Excel VAL.UGUALE non li trovano. Le pivot li contano come distinti.

import pandas as pd
from rapidfuzz import fuzz, process

df = xl("Anagrafica[ragione_sociale]", headers=False)
nomi = df.iloc[:, 0].dropna().str.upper().tolist()

# Trova match >85% similarità
duplicati = []
for i, nome in enumerate(nomi):
    matches = process.extract(nome, nomi[i+1:], scorer=fuzz.token_sort_ratio, score_cutoff=85)
    for match, score, _ in matches:
        duplicati.append({'nome_a': nome, 'nome_b': match, 'similarita': score})

pd.DataFrame(duplicati).sort_values('similarita', ascending=False)

Risultato: lista coppie sospette di duplicati con punteggio. Il magazziniere o il responsabile CRM li revisiona manualmente e li consolida. Ore di lavoro risparmiate su una pulizia anagrafica.

Use case 5 — Regressione: cosa guida davvero il prezzo dei nostri preventivi?

Scenario: 2 anni di preventivi inviati a clienti, con 15 colonne (cliente, settore, dimensione richiesta, complessità tecnica, urgenza, prezzo finale, vinto/perso). Vuoi capire quali variabili predicono di più la vincita del preventivo.

import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler

df = xl("Preventivi[#All]", headers=True)
y = df['vinto'].astype(int)
X = df[['dimensione_richiesta','complessita','urgenza','prezzo_norm','settore_id']]

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

model = LogisticRegression().fit(X_scaled, y)
importanza = pd.DataFrame({
    'variabile': X.columns,
    'coefficiente': model.coef_[0]
}).sort_values('coefficiente', key=abs, ascending=False)
importanza

Risultato: classifica delle variabili che più influenzano la chiusura del preventivo. Se “urgenza del cliente” pesa più di “prezzo”, la strategia commerciale dovrebbe puntare sui clienti urgenti. Se “complessità tecnica” pesa negativamente, la PMI sta perdendo i preventivi più difficili e dovrebbe rivedere il team commerciale tecnico.

Vedi il template Preventivi & Listino prezzi per la struttura dati di partenza.

I 3 limiti reali da conoscere

1. Latenza — ogni cella PY() impiega 2-4 secondi per essere calcolata. Se hai 50 celle Python in un foglio, il refresh totale è di 1-2 minuti. Non è adatto a fogli “live dashboard” con refresh continuo.

2. Dati confidenziali — il calcolo gira su cloud Microsoft. Per documenti con dati sanitari/finanziari estremamente sensibili, verifica con il DPO se la base giuridica copre l’invio a server Microsoft Anaconda (in genere sì grazie al DPF + EU Data Boundary, ma vale la pena formalizzarlo). Vedi anche EU Data Boundary M365.

3. Curva di apprendimento — Python è “facile” rispetto a JavaScript o C#, ma non rispetto alle formule Excel. Un utente che conosce solo VLOOKUP deve dedicare 4-8 ore di formazione per scrivere autonomamente codice Python utile. Il ROI c’è solo se il profilo ha use case ripetitivi.

Quando ha senso e quando no

Python in Excel è la scelta giusta per:

• Controller / responsabili amministrativi con bisogno di analisi finanziarie ricorrenti.
• Analisti vendite con dataset CRM medio-grandi (>1k righe).
• Data analyst interni junior che vogliono lavorare in ambiente già familiare.

Non è la scelta giusta per:

• Reportistica dirigenziale ricorrente (meglio Power BI con semantic model).
• Dataset >100k righe (Excel performa male a prescindere, meglio Power BI o un database).
• Automazione di processi (meglio Power Automate per task ripetitivi business).

Conclusione

Python in Excel non sostituisce Power BI o un data scientist. Ma per le PMI italiane senza team analitico dedicato, sblocca livelli di analisi che prima erano riservati a chi sapeva programmare. Tre mesi di pratica seria su 5-10 use case ricorrenti possono trasformare un controller di gestione in un analista efficace.

Se vuoi una sessione di formazione mirata su Python in Excel per il tuo team finance/operations, parla con un nostro consulente — facciamo training PMI personalizzati con casi reali sui tuoi dati.