La loi binomiale est un outil statistique qui permet de calculer la probabilité d'obtenir un certain nombre de succès (k), sur une quantité de tirage défini. Pour qu'une situation puisse être modélisée par une loi binomiale, elle doit respecter quatre critères :

- avoir un nombre connu de tirage (n) ;

- aucun tirage ne dépend d'un autre ;

- un tirage produit un succès ou un échec ;

- la probabilité de succès (p) reste la même pour chaque tirage.

La formule de la loi binomiale permettant de calculer la probabilité p d'obtenir exactement k succès sur n tirages avec remise est :

P(X=k) = C(n,k) x pᵏ x (1 - p)ⁿ⁻ᵏ, où :

- P(X=k), ou P(k), est la probabilité d'obtenir exactement k succès pour n tirages ;

- n est le nombre de tirages avec remise ;

- k est le nombre exact de succès voulus avec k < n ;

- p est la probabilité d'obtenir un succès à chaque tirage.

- C(n,k) est le coefficient binomial.

Le coefficient de la loi binomiale est la quantité de façons d'obtenir un certain nombre de succès dans une série d'essais indépendants. On obtient ce nombre avec la formule : C(n,k) = n! / ( k! x ( n - k )!). 

Par exemple, dans un sac, il y a 10 billes : 3 bleues, 3 vertes, 2 rouges et 2 jaunes. Sur 5 tirages avec remise, qu'elle est la probabilité d'obtenir 3 billes qui ne soient pas rouge ? On a donc : 

- il y a 80% de billes qui ne sont pas rouge (p = 80 ou 0,8) ;

- nombre de 5 tirages (n = 5) ; 

- on souhaite exactement 3 billes qui ne soient pas rouges (k = 3).

P(X=k) = C(n,k) x pᵏ x (1 - p)ⁿ⁻ᵏ

P(X=3) = C(5,3) x 0.8³ x (1 - 0.8)⁵⁻³

P(X=3) = C(5,3) x 0.8³ x (1 - 0.8)⁵⁻³

P(X=3) = 10 x 0.512 x 0.2²

P(X=3) = 5.12 x 0.04

P(X=3) = 0.2048$$

Il y a donc une probabilité de 20.48 % d'obtenir exactement 3 billes qui ne soient pas rouges sur 5 tirages.

Le programme doit :

1. demander la probabilité de succès par tirage (p) ;

2. demander le nombre de tirages (n) ;

3. demander le nombre de succès attend (k) ;

4. controler si les saisies sont valides ;

5. calculer et afficher le coeficient binominal (C(n,k))

6. calculer et afficher la probalité issue de la loi binominale (P(X=k)) ;

7. demander si l'utilisateur souhaite calculer une autre probabilité.

D'abord, faite-le fonctionner. Ensuite, faite-le beau. Enfin, faite-le performant.

Amusez-vous bien !

Télécharger RETROGICIEL - La loi binomiale.

Cette présentation nécessite que Python 3 soit installé sur votre machine.

Après avoir téléchargé le fichier La loi binomiale.7z, décompressez-le dans le répertoire de votre choix.

Ouvrez le répertoire qui vient d'être créé.

Lancez le fichier Retrogiciel.py.

Cliquez sur l'onglet RUN et testez le programme.

Créez votre propre script dans un des langages proposés ou un autre de votre choix.

Le répertoire contient aussi : 

- Python.py, l'exemple en PYTHON sans tkinter ;

- Tkinter.py, l'exemple en PYTHON avec tkinter ;

- Qb84.bas, l'exemple en QBASIC avec qb64 ;

- Bbc.bas, l'exemple en BBC BASIC avec bbc sdl.

# --- Origine Nerd ---

# --- RETROGICIEL - PYTHON ---

# --- La binomiale ---

# -*- coding: utf-8 -*-

# --- IMPORTATION DES MODULES ---

import math

# --- PRESENTATION ---

print ( "LA LOI BINOMINALE." )

print ( )

# --- BOUCLE PRINCIPALE ---

while True :

# --- Possibilites de succes par tirage (p) ---

while True :

# --- Possibilites de succes par tirage (p) ---

while True :

try :

kchances = float ( input ( "Probabilité d'avoir un succès par tirage en % ? " ) )

kchances = kchances / 100

if kchances > 0 and kchances < 1 : break

except : pass

# --- Nombre de tirages à prendre en compte (n) ---

while True :

try :

ktirages = int ( input ( "Nombre de tirages à réaliser ? " ) )

if ktirages > 0 : break

except : pass

# --- Nombre de succes esperes (k) ---

while True :

try :

ksucces = int ( input ( "NNombre de succès espérés sur le nombre de tirages ? " ) )

if ksucces > 0 and ksucces < ktirages : break

except : pass

# --- Calcul du coeficient binomiale - C(n,k) = n! / {k! (n-k)!} ---

ktir_f = math.factorial ( ktirages ) # - calcul ktirages! ( pour n! )

ksuc_f = math.factorial ( ksucces ) # - calcul ksucces! ( pour k! )

ktms_f = math.factorial ( ktirages - ksucces ) # - calcul (ktirages - ksucces)! ( pour (n-k)! )    

kdiviseur = ksuc_f * ktms_f # - calcul {k! (n-k)!}

kcoeficient = int ( ktir_f / kdiviseur ) # - calcul C(n,k)

print ( "\nLe coeficient de la loi binomiale est : " , kcoeficient )

# --- Calcul de la probabilité de succès en % - P(X=k) = C(n,k) x p^k x (1-p)^(n-k) ---

kpart2 = kchances ** ksucces # - calcul p^k

kpart3 = ( 1 - kchances ) ** ( ktirages - ksucces ) # - calcul (1-p)^(n-k)

kprobabilite = kcoeficient * kpart2 * kpart3

kpourcent = int ( kprobabilite * 10000 ) / 100

print ( f"La probabilité d'obtenir { ksucces } succès en { ktirages } tirages est de : { kpourcent }%." )

# --- Choix du bouclage du programme ---

kchoix = input ( "\nVoulez-vous faire une autre estimation (O ou N) ?" )

if kchoix.upper ( ) == "N" : break

# --- FIN DU PROGRAMME ---

print ( "Au revoir" )

# --- Programme : JFB ---

# ---Septembre 2025 ---

# --- Fin ---

Pour mieux comprendre l'exemple en PYTHON sans tkinter.

# --- Origine Nerd ---

# --- RETROGICIEL - TKINTER ---

# --- La binomiale ---

# -*- coding: utf-8 -*-

# --- IMPORTATION DES MODULES ---

# --- Modules de la bibliothèque standard ---

import tkinter

import math

# --- DÉFINITION DES FONCTIONS PERSONNALISEES ---

# --- Calcul du coeficient et de la probabilité ---

def FNC_Calcul ( Qchances , Qtirages , Qsucces ) :

# --- Calcul du coeficient binomiale - C(n,k) = n! / {k! (n-k)!} ---

ktir_f = math.factorial ( Qtirages ) # - calcul ktirages! ( pour n! )

ksuc_f = math.factorial ( Qsucces ) # - calcul ksucces! ( pour k! )

ktms_f = math.factorial ( Qtirages - Qsucces ) # - calcul (ktirages - ksucces)! ( pour (n-k)! )    

kdiviseur = ksuc_f * ktms_f # - calcul {k! (n-k)!}

kcoeficient = int ( ktir_f / kdiviseur ) # - calcul C(n,k)

TKV_Coeficient.set ( f"Le coeficient de la loi binoiale est : { kcoeficient }" )

# --- Calcul de la probabilité de succès en % - P(X=k) = C(n,k) x p^k x (1-p)^(n-k) ---

kpart2 = Qchances ** Qsucces # - calcul p^k

kpart3 = ( 1 - Qchances ) ** ( Qtirages - Qsucces ) # - calcul (1-p)^(n-k)

kprobabilite = kcoeficient * kpart2 * kpart3

kpourcent = int ( kprobabilite * 10000 ) / 100

TKV_Pourcent.set ( f"La probabilité d'obtenir { Qsucces } succès en { Qtirages } tirages est de : { kpourcent }%." )

# --- Controle de validités des données saisies ---

def FNC_Controle ( ) :

kerreur = False

try :

kchances = float ( TKV_Chances.get ( ) ) / 100

ktirages = int ( TKV_Tirages.get ( ) )

ksucces = int ( TKV_Succes.get ( ) )

if kchances < 0.01 or kchances > 99.99 : kerreur = True

if ktirages < 1 : kerreur = True

if ksucces < 1 or ksucces > ktirages : kerreur = True

except :

kerreur = True

if kerreur : FNC_Erreur ( )

else : FNC_Calcul ( kchances , ktirages , ksucces )

# --- Saisie de données incorrectes ---

def FNC_Erreur ( ) :

TKV_Chances.set ( 0 )

TKV_Tirages.set ( 0 )

TKV_Succes.set ( 0 )

TKV_Coeficient.set ( "ERREUR !" )

TKV_Pourcent.set ( "Les données sont incorectes." )

# --- CREATION DE L'INTERFACE GRAPHIQUE ---

# --- Création de la fenêtre principale ---

TKI_Principal = tkinter.Tk ( )

TKI_Principal.title ( "RETROGICIEL - La loi binomialel" )

# --- Création des variables de controles ---

TKV_Chances = tkinter.DoubleVar ( )

TKV_Coeficient = tkinter.StringVar ( )

TKV_Pourcent = tkinter.StringVar ( )

TKV_Succes = tkinter.IntVar ( ) 

TKV_Tirages = tkinter.IntVar ( ) 

# --- Mise en place des controles (anonymes et nommés) dans la fenêtre principale ---

tkinter.Label ( TKI_Principal , text = "Probabilité d'avoir un succès par tirage en % : " , justify = "right" ).grid ( row = 0 , column = 0 , sticky = "e" )

tkinter.Entry ( TKI_Principal , textvariable = TKV_Chances , width = 6 ).grid ( row = 0 , column = 1 , sticky = "e" )

tkinter.Label ( TKI_Principal , text = "Nombre de tirages à réaliser : " , justify = "right" ).grid ( row = 1 , column = 0 , sticky = "e" )

tkinter.Entry ( TKI_Principal , textvariable = TKV_Tirages , width = 6 ).grid ( row = 1 , column = 1 , sticky = "e" )

tkinter.Label ( TKI_Principal , text = "Nombre de succès espérés sur le nombre de tirages : " , justify = "right" ).grid ( row = 2 , column = 0 , sticky = "e" )

tkinter.Entry ( TKI_Principal , textvariable = TKV_Succes , width = 6 ).grid ( row = 2 , column = 1 , sticky = "e" )

tkinter.Label ( TKI_Principal , font = ( None , 1 ) , bg = "gray" ).grid ( row = 3 , column = 0 , columnspan = 2 , sticky = "ew")

tkinter.Label ( TKI_Principal , textvariable = TKV_Coeficient , fg = "blue" ).grid ( row = 4 , column = 0 , columnspan = 2)

tkinter.Label ( TKI_Principal , textvariable = TKV_Pourcent , fg = "blue" ).grid ( row = 5 , column = 0 , columnspan = 2 )

tkinter.Button ( TKI_Principal , text = "Calculer" , command = FNC_Controle ).grid ( row = 6 , column = 0 , sticky = "nesw" )

tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy ).grid ( row = 6 , column = 1 , sticky = "nesw" )

# --- DEBUT DU PROGRAMME ---

TKI_Principal.mainloop ( )

# --- Programme : JFB ---

# --- Septembre 2025 ---

# --- Fin ---

Pour mieux comprendre l'exemple en PYTHON avec tkinter.

' --- Origine Nerd propose pour ---

' --- RETROGICIEL - QB64 ---

' --- La loi binomiale ---

' --- DEBUT DU PROGRAMME ---

PRINT "LA LOI BINOMIALE."

PRINT

' --- BOUCLE PRINCIPALE ---

DO

' --- Possibilites de succes par tirage (p) ---

DO

INPUT "Probabilite d'avoir un succes par tirage en % ", kchances

kchances = kchances / 100

IF kchances > 0 AND kchances < 1 THEN EXIT DO

LOOP UNTIL FALSE

' --- Nombre de tirages à prendre en compte (n) ---

DO

INPUT "Nombre de tirages a realiser ", ktirages%

IF ktirages% > 0 THEN EXIT DO

LOOP UNTIL FALSE

' --- Nombre de succes esperes (k) ---

DO

INPUT "Nombre de succes esperes ", ksucces%

IF ksucces% > 0 AND ksucces% < ktirages% THEN EXIT DO

LOOP UNTIL FALSE

' --- Calcul du coeficient binomial - C(n,k) = n! / {k! (n-k)!} ---

PRINT

ktir_f = FNC_Factoriel(ktirages%): REM - calcul ktirages! ( pour n! )

ksuc_f = FNC_Factoriel(ksucces%): REM - calcul ksucces! ( pour k! )

ktms_f = FNC_Factoriel(ktirages% - ksucces%): REM - calcul (ktirages - ksucces)! ( pour (n-k)! )

kdiviseur = ksuc_f * ktms_f: REM - calcul {k! (n-k)!}

kcoeficient = INT(ktir_f / kdiviseur): REM - calcul C(n,k)

PRINT "Le coeficient de la loi binomiale est : "; kcoeficient

REM --- Calcul de la probabilite de succes en % - P(X=k) = C(n,k) x p^k x (1-p)^(n-k) ---

kpart2 = kchances ^ ksucces%: REM - calcul p^k

kpart3 = (1 - kchances) ^ (ktirages% - ksucces%): REM - calcul (1-p)^(n-k)

kprobabilite = kcoeficient * kpart2 * kpart3

kpourcent = INT(kprobabilite * 10000) / 100

PRINT "La probabilite d'obtenir "; ksucces%; " succes en "; ktirages%; " tirages est de : "; kpourcent; "%."

PRINT

' --- Bouclage du programme ---

PRINT

INPUT "Voulez-vous recommencer [ O ou N ] "; kchoix$

LOOP UNTIL UCASE$(kchoix$) = "N"

' --- FIN DU PROGRAMME ---

PRINT "Au revoir."

END

' --- DEFINITION DES FONCTIONS PERSONNALISEES ---

' ---  Calcul de la factorielle d'un nombre ---

FUNCTION FNC_Factoriel (Q)

kproduit = 1

FOR kterme = 1 TO Q

kproduit = kproduit * kterme

NEXT kterme

FNC_Factoriel = kproduit

END FUNCTION

' --- Programme : JFB ---

' --- Septembre 2025 ---

' --- Fin ---

Pour mieux comprendre l'exemple en QB64.

REM --- Origine Nerd propose pour ---

REM --- RETROGICIEL - BBC BASIC ---

REM --- La loi binomiale ---

REM --- DEBUT DU PROGRAMME ---

PRINT"LA LOI BINOMIALE."

PRINT

REM --- BOUCLE PRINCIPALE ---

REPEAT

REM --- Possibilites de succes par tirage (p) ---

REPEAT

INPUT "Probabilite d'avoir un succes par tirage en % " , kchances

kchances = kchances / 100

IF kchances > 0 AND kchances < 1 THEN EXIT REPEAT

UNTIL FALSE

REM --- Nombre de tirages a prendre en compte (n) ---

REPEAT

INPUT "Nombre de tirages a realiser " , ktirages%

IF ktirages% > 0 THEN EXIT REPEAT

UNTIL FALSE

REM --- Nombre de succes esperes (k) ---

REPEAT

INPUT "Nombre de succes esperes " , ksucces%

IF ksucces% > 0 AND ksucces% < ktirages% THEN EXIT REPEAT

UNTIL FALSE

REM --- Calcul du coeficient binomiale - C(n,k) = n! / {k! (n-k)!} ---

PRINT

ktir_f = FN_Factoriel( ktirages% ) : REM - calcul ktirages! ( pour n! )

ksuc_f = FN_Factoriel( ksucces% ) : REM - calcul ksucces! ( pour k! )

ktms_f = FN_Factoriel( ktirages% - ksucces% ) : REM - calcul (ktirages - ksucces)! ( pour (n-k)! )

kdiviseur = ksuc_f * ktms_f : REM - calcul {k! (n-k)!}

kcoeficient = INT( ktir_f / kdiviseur ) : REM - calcul C(n,k)

PRINT "Le coeficient de la loi binomiale est : " ; kcoeficient

REM --- Calcul de la probabilite de succes en % - P(X=k) = C(n,k) x p^k x (1-p)^(n-k) ---

kpart2 = kchances ^ ksucces% : REM - calcul p^k

kpart3 = ( 1 - kchances ) ^ ( ktirages% - ksucces% ) : REM - calcul (1-p)^(n-k)

kprobabilite = kcoeficient * kpart2 * kpart3

kpourcent = INT( kprobabilite * 10000 ) / 100

PRINT "La probabilite d'obtenir " ; ksucces% ; " succes en " ; ktirages% ; " tirages est de : " ; kpourcent ; "%."

PRINT

REM --- Bouclage du programme ---

INPUT "Voulez-vous recommencer [ O ou N ] "; kchoix$

UNTIL kchoix$ = "N"  OR kchoix$ = "n"

REM --- FIN DU PROGRAMME ---

PRINT "Au revoir."

END

REM --- DEFINITION DES FONCTIONS PERSONNALISEES ---

REM ---  Calcul de la factorielle d'un nombre ---

DEF FN_Factoriel( Q )

kproduit = 1

FOR kterme = 1 TO Q

kproduit = kproduit * kterme

NEXT kterme

= kproduit

REM --- Programme : JFB ---

REM --- Septembre 2025 ---

REM --- Fin ---

Pour mieux comprendre l'exemple en BBC BASIC.