La distribuzione binominale in NumPy è uno degli strumenti più utili per simulare eventi con due soli possibili risultati, come successo o fallimento, vero o falso, testa o croce. Se stai iniziando a lavorare con Python e con il calcolo numerico, capire come funziona questa distribuzione ti aiuta a modellare molti casi reali in modo semplice e immediato.
In pratica, la distribuzione binomiale viene usata quando vuoi sapere quante volte un certo evento si verifica in un numero fisso di prove indipendenti. Un esempio classico è il lancio di una moneta: se la lanci 10 volte, quante volte esce testa? Oppure, in un contesto più concreto, quante vendite riesce a chiudere un team commerciale su 20 contatti, sapendo che ogni contatto ha una certa probabilità di andare a buon fine?
Con NumPy, questa simulazione diventa molto agevole grazie alla funzione binomial, presente nel modulo per la generazione casuale. È una funzione molto usata in statistica, data analysis, machine learning e in generale in tutti quei contesti in cui servono simulazioni rapide e realistiche.
Come generare campioni con la distribuzione binomiale in NumPy
Per lavorare con la distribuzione binomiale, in NumPy si usa normalmente numpy.random.binomial. Questa funzione permette di generare uno o più campioni partendo da tre elementi fondamentali:
- n: il numero di prove eseguite
- p: la probabilità di successo in ogni prova
- size: il numero di campioni da generare
La forma più semplice è questa:
import numpy as np
campione = np.random.binomial(
10,
0.5
)
print(campione)In questo esempio, NumPy simula 10 prove con probabilità di successo pari a 0.5. Il risultato è un singolo numero intero, che rappresenta il totale dei successi osservati.
Se invece vuoi generare più valori, puoi specificare il parametro size:
import numpy as np
campioni = np.random.binomial(
10,
0.5,
size=20
)
print(campioni)In questo caso ottieni un array con 20 simulazioni. Ogni elemento dell’array rappresenta il numero di successi ottenuti in 10 prove.
Questo approccio è molto utile quando vuoi capire il comportamento di un fenomeno su larga scala. Per esempio, puoi simulare centinaia o migliaia di esperimenti e osservare come si distribuiscono i risultati.
Ecco un caso molto comune per chi muove i primi passi: simulare il numero di acquisti completati da 100 utenti, sapendo che ognuno ha una probabilità del 30% di comprare e che ogni simulazione considera 8 opportunità di conversione:
import numpy as np
acquisti = np.random.binomial(
8,
0.3,
size=100
)
print(acquisti)La funzione è intuitiva, ma va usata con una certa attenzione. La probabilità p deve essere compresa tra 0 e 1, mentre n deve essere un numero intero non negativo. Inoltre, la distribuzione binomiale ha senso quando le prove sono indipendenti e la probabilità di successo rimane costante.
Sintassi di numpy.random.binomial spiegata in modo semplice
La sintassi generale è la seguente:
numpy.random.binomial(
n,
p,
size=None
)Vediamo il significato dei parametri in modo pratico:
- n: indica quante prove fai in ogni esperimento
- p: indica la probabilità che una singola prova abbia successo
- size: definisce quante simulazioni vuoi ottenere
Se ometti size, NumPy restituisce un solo valore. Se lo imposti, riceverai un array NumPy con la forma desiderata. Ad esempio, puoi anche generare una matrice di risultati:
import numpy as np
matrice = np.random.binomial(
12,
0.4,
size=(3, 4)
)
print(matrice)Questo produce una matrice con 3 righe e 4 colonne, utile quando vuoi organizzare i campioni in una struttura più leggibile o lavorare su più gruppi contemporaneamente.
Quando usare davvero la distribuzione binominale con NumPy
La distribuzione binomiale è adatta quando ricorrono alcune condizioni precise:
- esiste un numero fisso di prove
- ogni prova ha solo due esiti possibili
- le prove sono indipendenti
- la probabilità di successo è costante
Se una di queste condizioni viene meno, potrebbe essere più corretto usare un altro modello statistico. Tuttavia, in moltissimi esercizi introduttivi, simulazioni aziendali e problemi didattici, la binomiale resta una delle distribuzioni più immediate da comprendere e da applicare.
Analizzare i campioni generati con la distribuzione binomiale NumPy
Dopo aver generato i campioni, il passo successivo è capire cosa ci stanno raccontando. Questa fase di analisi dei campioni è fondamentale, perché trasforma una semplice simulazione in un’informazione concreta.
Supponiamo di avere 1000 simulazioni di 10 prove con probabilità di successo pari a 0.5:
import numpy as np
campioni = np.random.binomial(
10,
0.5,
size=1000
)
print(campioni)Su questi dati puoi calcolare statistiche descrittive molto utili, come la media, la deviazione standard, il valore minimo e quello massimo:
import numpy as np
campioni = np.random.binomial(
10,
0.5,
size=1000
)
media = np.mean(campioni)
dev_std = np.std(campioni)
valore_min = np.min(campioni)
valore_max = np.max(campioni)
print("Media:", media)
print("Deviazione standard:", dev_std)
print("Minimo:", valore_min)
print("Massimo:", valore_max)Se il numero di campioni è abbastanza grande, la media dovrebbe avvicinarsi al valore teorico della distribuzione binomiale, che è dato da n × p. Nel nostro caso, quindi, il risultato atteso è 10 × 0.5 = 5.
Questo è un passaggio molto importante per chi studia statistica con Python: permette di vedere in modo tangibile il legame tra teoria e simulazione.
Distribuzione delle frequenze dei campioni binomiali
Un altro aspetto interessante consiste nel contare quante volte compare ciascun risultato. In questo modo puoi osservare la forma della distribuzione empirica ottenuta dai campioni.
import numpy as np
campioni = np.random.binomial(
10,
0.5,
size=1000
)
valori, frequenze = np.unique(
campioni,
return_counts=True
)
print("Valori:", valori)
print("Frequenze:", frequenze)Con np.unique puoi ottenere sia i valori distinti sia il numero di occorrenze. È un metodo semplice ma molto efficace per leggere la distribuzione dei risultati senza introdurre strumenti troppo avanzati.
Se vuoi un’analisi leggermente più ordinata, puoi unire i risultati in una struttura più chiara:
import numpy as np
campioni = np.random.binomial(
10,
0.5,
size=1000
)
valori, frequenze = np.unique(
campioni,
return_counts=True
)
for valore, frequenza in zip(valori, frequenze)
{
print(f"Successi = {valore}, Frequenza = {frequenza}")
}Va però ricordato un punto pratico: in Python reale il blocco non usa parentesi graffe, ma l’indentazione. Se stai scrivendo codice eseguibile, la versione corretta è questa:
import numpy as np
campioni = np.random.binomial(
10,
0.5,
size=1000
)
valori, frequenze = np.unique(
campioni,
return_counts=True
)
for valore, frequenza in zip(valori, frequenze):
print(f"Successi = {valore}, Frequenza = {frequenza}")In un contesto pratico, questa analisi può aiutarti a capire, ad esempio, quale numero di successi compare più spesso o quanto i risultati siano concentrati attorno alla media.
Istogramma e visualizzazione dei risultati simulati
Quando inizi a lavorare con i dati, visualizzare i campioni è spesso il modo più rapido per capirli. Un istogramma ti permette di osservare subito se i valori si concentrano attorno a certi numeri oppure se la distribuzione è più dispersa.
Per farlo, puoi usare Matplotlib insieme a NumPy:
import numpy as np
import matplotlib.pyplot as plt
campioni = np.random.binomial(
10,
0.5,
size=1000
)
plt.hist(
campioni,
bins=range(12),
edgecolor="black",
align="left"
)
plt.title("Distribuzione Binomiale con NumPy")
plt.xlabel("Numero di successi")
plt.ylabel("Frequenza")
plt.show()Un grafico di questo tipo è molto utile anche in fase didattica, perché rende la distribuzione binomiale immediatamente leggibile. Se stai studiando la documentazione NumPy o vuoi creare piccoli esperimenti per esercitarti, questo è uno dei modi più efficaci per consolidare i concetti.
