(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/
Pour exécuter une saisie Python, sélectionner la cellule et valider avec SHIFT+Entrée.
Le but de l’activité est de :
Pour une présentation de la planche de Galton, voir la vidéo suivante.
On note $N$ le nombre d'étages de la planche de Galton, et on considère le repère tel que ci-dessous, dans lequel les clous de la planche sont à coordonnées entières. L'abscisse initiale d'une bille vaut 0 puis augmente ou diminue de 1 à chaque étage. On modélisera la trajectoire d'une bille sur cette planche à l'aide de la liste des abscisses successives prises par la bille.
Dans cette partie, on suppose que $N=5$. La planche est donc composée de 5 rangées de clous.
1.1. Créer une liste abs_bille correspondant à une trajectoire possible d'une bille sur la planche, dont la première valeur est 0, et comportant 6 valeurs.
Pour exécuter la saisie Python, sélectionner la cellule et valider avec SHIFT+Entrée. Faire de même au fur et à mesure de l'activité pour les cellules suivantes.
# Effectuer la saisie pour créer la liste abs_bille
abs_bille=[0,-1,-2,-1,-2,-3]
1.2. La fonction Python Visualisation_Planche_Galton donnée dans la cellule ci-dessous permet d'observer des trajectoires de billes à partir des listes de leurs abscisses. Exécuter les deux cellules suivantes pour appeler cette fonction Visualisation_Planche_Galton avec abs_bille précédemment généré.
#Exécuter cette cellule pour mettre la fonction Visualisation_Planche_Galton en mémoire
from copy import deepcopy
import matplotlib.pyplot as plt
from matplotlib import animation, rc
from IPython.display import HTML
def Visualisation_Planche_Galton(Positions_billes, attente=3, Temps_total=5000, hauteur=8, resolution=80):
'''
Fonction permettant la visualisation d'une chute de billes sur la planche de Galton
Liste_billes: chaque élément est la liste des abscisses d'une bille (list)
attente: attente entre chaque bille lachée: écart des ordonnées entre deux billes successives (int)
Temps_total: Durée totale de visionnage en ms (int)
hauteur: Hauteur du graphique en pouces (float)
resolution: résolution en dpi (int)
'''
#Duplication profonde de la liste des listes des abscisses
Liste_billes=deepcopy(Positions_billes)
N=max([len(b) for b in Liste_billes])-1 #hauteur de la planche (Attention: les listes ont normalement la même taille)
M=len(Liste_billes)//2+1 #hauteur du réceptacle pour les billes
#Réglages de la fenêtre d'affichage
largeur=2*N*hauteur/(N+M+0.25) ; borne_x=N+1/2
plt.figure(num=0, figsize=(largeur,hauteur), dpi=resolution) ; fig,ax = plt.subplots(num=0)
ax.set_xlim(( -borne_x,borne_x)) ; ax.set_ylim((-M-0.25, N)) ; ax.xaxis.set_ticks(range(-N,N+1))
plt.tick_params(axis = 'x', labelsize = 8) ; plt.yticks([], [])
#taille des billes
taille_bille=242//(N+M+0.25)
#représentation de la planche de Galton
list_x=[2*k-(L-1) for L in range(N+1) for k in range(L)]
list_y=[N-L for L in range(N+1) for k in range(L)]
Trace_Galton,= ax.plot(list_x,list_y, ls="none", marker=".",color="black")
#Objet pour la représentation des billes descendantes
Trace_billes,= ax.plot([], [], ls="none", marker="o",color="blue", markersize=taille_bille)
#Objet pour la représentation des billes accumulées dans le réceptacle
Trace_point_acc, = ax.plot([], [], ls="none", marker="o",color="blue", markersize=taille_bille)
#Liste des effectifs de billes accumulées
accumulation=[0 for x in range(-N,N+1)]
#Initialisation des positions des billes
b_x=[None for p in range(len(Liste_billes))] # liste des abscisses des billes à placer
b_y=[None for p in range(len(Liste_billes))] # liste des ordonnées des billes à placer
def init():
"""
Fonction initialisant l'animation
"""
return (Trace_Galton,Trace_billes,Trace_point_acc,)
def animate(i):
"""
Fonction définissant la i ème scène de l'animation
"""
#gestion des billes en descente
for p in range(len(Liste_billes)): #pour chaque bille
if Liste_billes[p] and i>=attente*p:#s'il reste des positions à traiter et qu'on a lâché la bille
if len(Liste_billes[p])>1: #si ce n'est pas la dernière position
b_x[p],b_y[p] = Liste_billes[p].pop(0),N-i+attente*p #on place la bille à sa position et on efface cette position
elif -M+0.5*(accumulation[N+int(Liste_billes[p][0])]-1)<N-i+attente*p: #sinon si on n'a pas atteint la hauteur accumulée
b_x[p],b_y[p] = Liste_billes[p][0],N-i+attente*p #on place la bille à sa nouvelle position (descente verticale)
else: #sinon
accumulation[N+int(Liste_billes[p].pop(0))]+=1 #on compte la bille comme accumulée
b_x[p],b_y[p] = None,None #et on supprime la position
#Représentation des billes en descente
Trace_billes.set_data(b_x,b_y)
#Représentation des billes accumulées dans les réceptacles
l_x,l_y = [k for k in range(-N,N+1) for y in range(accumulation[N+k])],[-M+0.5*y for k in range(-N,N+1) for y in range(accumulation[N+k])]
Trace_point_acc.set_data(l_x,l_y)
return (Trace_Galton,Trace_billes,Trace_point_acc,)
#Création de l'animation
Nb_images=attente*len(Liste_billes)+N+M
anim = animation.FuncAnimation(fig, animate, init_func=init, frames=Nb_images, interval=Temps_total/Nb_images, blit=False, repeat=False)
return HTML(anim.to_jshtml())
#Exécuter cette cellule pour observer la trajectoire de la bille correspondante à abs_bille
Visualisation_Planche_Galton( [abs_bille] )
1.3.a. Si lors de sa descente sur la planche l'abscisse de la bille vaut $x$, quelles sont les valeurs possibles pour son abscisse à l'étape suivante ? Quelles sont les probabilités d'obtenir chacune de ces valeurs ?
Si l'abscisse de la bille vaut $x$, les valeurs possibles pour l'abscisse suivante sont $x-1$ et $x+1$, de façon équiprobable, donc avec des probabilités associées égales à $\frac{1}{2}$.
1.3.b. Ecrire une fonction Python suiv, qui reçoit x en argument, et qui renvoie l'abscisse suivante de la bille.
Aide: L'import from random import random permet d'utiliser la fonction random() qui renvoie une valeur aléatoire de l'intervalle $[0;1[$. La syntaxe random()<1/2 est donc un test permettant de générer équiprobablement True ou False.
#Ecrire ici la fonction suiv d'argument x
from random import random
def suiv(x):
if random()<1/2:
return x-1
return x+1
1.4.a. On considère la fonction Python trajetci-dessous. Quelle est son utilité ? Compléter sa description.
def trajet():
'''
Fonction qui génère une liste correspondant à un trajet aléatoire d'une bille
sur la planche de Galton à 5 étages
'''
x=0
L=[x]
for k in range(5):
x=suiv(x)
L.append(x)
return L
1.4.b. A l'aide de cette fonction, créer une liste abs_bille, puis valider les cellules suivantes pour observer la trajectoire de la bille.
#Créer ici une liste abs_bille à l'aide de la fonction trajet précédente
abs_bille=trajet()
#Valider cette cellule pour voir la liste abs_bille qui a été générée
abs_bille
[0, 1, 0, 1, 0, 1]
#Exécuter cette cellule pour observer le trajet de la bille
Visualisation_Planche_Galton( [abs_bille] )
1.5.a. On construit ci-dessous une liste en compréhension nommée liste_trajets permettant de modéliser 50 trajets de billes différentes sur la planche. Valider les cellules pour afficher les listes d'abscisses et observer ces trajets sur la planche de Galton (Patienter pendant les calculs...).
#Valider la cellule
#Création d'une liste de trajets de 50 billes
liste_trajets = [ trajet() for b in range(50) ]
#Affichage des trajets
liste_trajets
[[0, 1, 0, -1, -2, -1], [0, 1, 2, 3, 2, 1], [0, 1, 2, 3, 2, 3], [0, -1, -2, -3, -2, -3], [0, -1, 0, -1, 0, -1], [0, 1, 0, 1, 0, -1], [0, 1, 0, 1, 2, 3], [0, -1, 0, -1, 0, -1], [0, 1, 2, 3, 2, 3], [0, 1, 2, 1, 2, 3], [0, -1, -2, -3, -4, -3], [0, 1, 2, 3, 2, 3], [0, 1, 0, -1, 0, -1], [0, 1, 0, 1, 2, 3], [0, -1, -2, -1, -2, -1], [0, -1, 0, 1, 0, -1], [0, 1, 0, -1, 0, 1], [0, 1, 2, 1, 0, -1], [0, 1, 0, 1, 2, 3], [0, -1, 0, 1, 0, -1], [0, -1, 0, 1, 0, -1], [0, 1, 2, 1, 2, 1], [0, -1, 0, 1, 2, 1], [0, 1, 2, 3, 4, 5], [0, -1, -2, -3, -2, -1], [0, 1, 2, 3, 4, 3], [0, 1, 2, 3, 2, 1], [0, 1, 0, -1, -2, -1], [0, 1, 2, 1, 2, 1], [0, 1, 2, 1, 2, 1], [0, -1, -2, -3, -4, -3], [0, 1, 2, 3, 4, 5], [0, -1, 0, -1, 0, -1], [0, 1, 2, 1, 0, -1], [0, 1, 0, 1, 2, 1], [0, 1, 2, 3, 4, 3], [0, -1, -2, -1, -2, -3], [0, 1, 0, -1, 0, 1], [0, 1, 0, -1, 0, 1], [0, -1, 0, -1, 0, 1], [0, -1, 0, 1, 0, 1], [0, -1, -2, -1, -2, -3], [0, -1, -2, -3, -4, -3], [0, 1, 2, 3, 2, 3], [0, -1, 0, -1, -2, -1], [0, 1, 2, 3, 4, 3], [0, -1, 0, 1, 2, 1], [0, -1, -2, -1, 0, 1], [0, 1, 0, 1, 0, -1], [0, -1, -2, -1, 0, -1]]
#Création de l'animation sur la planche de Galton
Visualisation_Planche_Galton( liste_trajets )
1.5.b. Décrire le résultat. Y a-t-il certaines sorties de la planche de Galton qui semblent moins fréquentes que d'autres ?
Il semble que les billes arrivent moins souvent sur les bords de la planche de Galton.
1.5.c. Visionner la vidéo ci-dessous. Votre conjecture de la question 1.5.b. semble-t-elle se vérifier?
La conjecture précédente semble vérifiée pour cette expérience.
1.6. On considère l'expérience qui consiste à faire descendre une bille sur la planche de Galton à 5 étages. On note X la variable aléatoire qui correspond au nombre de fois où la bille a tourné à droite.
a. $p(X=5)=\left( \frac{1}{2} \right)^5=0,03125$
b. Si on note $S$ l'événement "la bille tourne à droite" et $E=\bar{S}$, alors l'expérience consiste en la répétition de $5$ épreuves de Bernoulli identiques et indépendantes. X compte le nombre de succès donc X$\sim \mathcal{B} \left( 5,\frac{1}{2} \right)$.
c. Tableau de la loi de probabilité de X:
$ \;\; \; \; \; \; x_i \; \; \; \; \; \;\; \; \; \; \; \; $ | $ 0 $ | $ 1 $ | $ 2 $ | $ 3 $ | $ 4 $ | $ 5 $ |
---|---|---|---|---|---|---|
$p\left( X=x_i\right)$ | $0.03125$ | $0.15625$ | $0.3125$ | $0.3125$ | $0.15625$ | $0.03125$ |
d. Si X$=2$ alors la bille a tourné deux fois à droite et trois fois à gauche, et son abscisse finale vaut $-1$.
e. Tableau de la loi de probabilité de Y:
$ \;\; \; \; \; \; y_i \; \; \; \; \; \;\; \; \; \; \; \; $ | $ -5 $ | $ -3 $ | $ -1 $ | $ 1 $ | $ 3 $ | $ 5 $ |
---|---|---|---|---|---|---|
$p\left( y=y_i\right)$ | $0.03125$ | $0.15625$ | $0.3125$ | $0.3125$ | $0.15625$ | $0.03125$ |
Les probabilités que la bille arrive sur les bords de la planche de Galton sont bien nettement plus faibles.
2.1. On reprend la fonction trajet (vue dans la question 1.4.a.). Ajouter un argument N pour que la fonction permette de générer une liste correspondant à un trajet d'une bille sur une planche de Galton à N étages.
#Ajouter l'argument N à la fonction trajet
def trajet(N):
'''
Fonction qui génère une liste correspondant à un trajet aléatoire d'une bille
sur la planche de Galton à N étages
'''
x=0
L=[x]
for k in range(N):
x=suiv(x)
L.append(x)
return L
2.2.a. Dans la cellule ci-dessous, créer une liste liste_trajets permettant de modéliser 100 trajets de billes sur une planche de Galton à 10 étages.
Aide: On pourra s'inspirer de la syntaxe utilisée dans la question 1.5.a.
#Créer liste_trajets correspondant à 100 trajets de billes sur une planche de Galton à 10 étages
liste_trajets = [ trajet(10) for b in range(100) ]
2.2.b. Valider les cellules pour afficher les listes d'abscisses et observer ces trajets sur la planche de Galton (Patienter pendant les calculs...).
#Valider cette cellule pour afficher les listes de trajets
liste_trajets
[[0, -1, 0, -1, 0, 1, 2, 1, 0, 1, 2], [0, -1, 0, -1, -2, -3, -4, -3, -2, -1, 0], [0, -1, 0, 1, 0, -1, -2, -1, 0, -1, -2], [0, -1, -2, -3, -4, -3, -4, -3, -2, -1, 0], [0, 1, 0, 1, 0, -1, -2, -1, -2, -1, -2], [0, 1, 2, 3, 2, 3, 4, 3, 2, 1, 0], [0, -1, -2, -3, -4, -5, -6, -5, -6, -7, -8], [0, -1, -2, -1, 0, 1, 0, 1, 0, 1, 2], [0, -1, -2, -1, 0, 1, 2, 1, 2, 3, 2], [0, 1, 0, -1, -2, -1, 0, 1, 0, -1, 0], [0, -1, -2, -3, -2, -1, 0, 1, 0, 1, 0], [0, 1, 2, 1, 0, 1, 0, 1, 0, 1, 2], [0, -1, -2, -3, -2, -1, 0, 1, 0, -1, -2], [0, 1, 2, 3, 2, 1, 0, -1, -2, -1, -2], [0, 1, 2, 1, 2, 3, 2, 1, 2, 1, 0], [0, 1, 2, 1, 2, 3, 2, 1, 0, -1, -2], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8], [0, 1, 2, 3, 4, 5, 4, 3, 2, 3, 4], [0, 1, 2, 1, 0, 1, 2, 3, 4, 5, 4], [0, -1, -2, -1, 0, -1, 0, 1, 2, 3, 4], [0, -1, -2, -3, -2, -1, -2, -1, -2, -1, -2], [0, -1, -2, -3, -4, -5, -6, -5, -4, -5, -4], [0, -1, 0, 1, 0, 1, 0, -1, -2, -3, -4], [0, -1, 0, -1, 0, 1, 2, 1, 0, 1, 2], [0, 1, 0, 1, 0, 1, 0, -1, -2, -1, 0], [0, 1, 0, -1, 0, 1, 2, 1, 0, -1, 0], [0, 1, 2, 3, 2, 3, 2, 3, 4, 5, 6], [0, -1, -2, -3, -4, -3, -2, -3, -4, -3, -2], [0, 1, 0, 1, 0, -1, -2, -1, 0, -1, -2], [0, 1, 2, 3, 2, 3, 2, 3, 4, 3, 4], [0, -1, 0, -1, 0, 1, 0, -1, -2, -3, -4], [0, 1, 0, -1, 0, 1, 2, 3, 4, 3, 4], [0, 1, 0, -1, -2, -1, 0, 1, 0, 1, 0], [0, -1, -2, -1, 0, 1, 2, 3, 4, 3, 2], [0, -1, -2, -3, -2, -3, -4, -3, -2, -1, -2], [0, -1, 0, 1, 2, 3, 2, 1, 2, 1, 0], [0, 1, 2, 3, 4, 5, 6, 5, 4, 5, 6], [0, -1, -2, -1, -2, -3, -4, -3, -2, -1, -2], [0, 1, 0, -1, 0, 1, 0, -1, 0, -1, 0], [0, -1, -2, -1, 0, -1, 0, 1, 0, -1, 0], [0, -1, 0, 1, 0, -1, -2, -3, -4, -3, -4], [0, -1, -2, -3, -4, -3, -4, -3, -4, -3, -2], [0, -1, 0, -1, -2, -3, -4, -5, -6, -7, -6], [0, -1, -2, -3, -2, -1, 0, 1, 0, -1, 0], [0, -1, -2, -1, 0, 1, 2, 3, 2, 1, 2], [0, -1, 0, 1, 2, 1, 2, 3, 2, 1, 2], [0, 1, 0, -1, -2, -3, -2, -1, -2, -3, -2], [0, 1, 0, -1, 0, -1, 0, -1, -2, -3, -4], [0, -1, 0, 1, 2, 3, 2, 1, 2, 1, 0], [0, 1, 2, 3, 2, 1, 0, 1, 0, -1, 0], [0, 1, 2, 1, 0, -1, -2, -3, -4, -5, -4], [0, -1, -2, -1, 0, -1, 0, -1, -2, -1, 0], [0, 1, 0, -1, -2, -1, -2, -3, -4, -5, -6], [0, 1, 0, 1, 0, 1, 0, -1, 0, -1, -2], [0, -1, -2, -1, -2, -1, -2, -3, -2, -1, -2], [0, 1, 2, 1, 2, 3, 2, 3, 4, 3, 2], [0, 1, 0, 1, 2, 1, 2, 3, 4, 5, 4], [0, -1, -2, -3, -4, -3, -2, -1, 0, -1, -2], [0, 1, 0, -1, 0, 1, 0, 1, 2, 3, 4], [0, 1, 0, -1, -2, -1, -2, -1, -2, -1, 0], [0, 1, 2, 1, 2, 3, 4, 5, 6, 5, 6], [0, -1, 0, 1, 2, 3, 4, 3, 4, 3, 2], [0, -1, 0, -1, -2, -3, -4, -5, -6, -7, -6], [0, -1, -2, -1, -2, -3, -4, -5, -4, -3, -2], [0, -1, -2, -3, -2, -1, 0, -1, 0, -1, -2], [0, -1, 0, 1, 0, 1, 2, 1, 2, 1, 0], [0, 1, 2, 3, 4, 3, 4, 5, 6, 5, 6], [0, -1, -2, -1, 0, -1, 0, -1, 0, -1, -2], [0, 1, 0, 1, 2, 1, 2, 1, 2, 3, 2], [0, 1, 2, 1, 0, -1, 0, 1, 0, 1, 0], [0, -1, 0, 1, 0, -1, 0, 1, 0, -1, -2], [0, 1, 2, 3, 4, 5, 6, 5, 6, 7, 6], [0, -1, 0, -1, 0, 1, 0, -1, -2, -3, -4], [0, -1, 0, -1, 0, -1, 0, 1, 2, 3, 4], [0, 1, 2, 3, 4, 3, 2, 3, 2, 3, 4], [0, -1, 0, 1, 0, -1, 0, -1, 0, 1, 2], [0, -1, 0, -1, 0, 1, 2, 3, 4, 5, 6], [0, -1, -2, -1, -2, -3, -4, -3, -4, -5, -6], [0, 1, 2, 3, 4, 5, 4, 3, 4, 5, 4], [0, -1, -2, -1, 0, -1, 0, -1, 0, 1, 0], [0, -1, -2, -1, 0, -1, -2, -3, -4, -3, -4], [0, -1, 0, 1, 2, 1, 2, 3, 2, 1, 0], [0, -1, 0, -1, -2, -3, -2, -1, -2, -1, 0], [0, -1, -2, -3, -4, -3, -4, -3, -4, -3, -4], [0, -1, 0, -1, -2, -1, -2, -1, 0, 1, 2], [0, 1, 0, -1, -2, -3, -4, -3, -4, -5, -6], [0, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2], [0, 1, 0, 1, 0, 1, 2, 3, 4, 3, 4], [0, -1, -2, -3, -4, -5, -4, -5, -4, -5, -4], [0, -1, 0, -1, 0, -1, -2, -3, -4, -5, -4], [0, -1, -2, -1, -2, -3, -4, -5, -4, -3, -4], [0, 1, 2, 1, 2, 1, 0, -1, -2, -3, -4], [0, -1, -2, -3, -4, -5, -6, -5, -6, -5, -4], [0, -1, -2, -3, -4, -3, -2, -3, -2, -3, -4], [0, -1, 0, -1, -2, -3, -2, -3, -2, -3, -2], [0, -1, -2, -3, -4, -3, -2, -1, 0, -1, -2], [0, -1, 0, 1, 0, 1, 2, 3, 4, 3, 4], [0, -1, 0, -1, -2, -3, -4, -5, -4, -5, -4], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [0, 1, 2, 1, 0, -1, 0, -1, -2, -1, 0]]
#Création de l'animation sur la planche de Galton
Visualisation_Planche_Galton( liste_trajets )
2.3.a. Exécuter les cellules ci-dessous. Dans chaque cas, indiquer ce que permet d'obtenir la syntaxe proposée.
liste_trajets[0] permet d'obtenir la liste des abscisses de la 1ère bille (de rang 0).
liste_trajets[0][-1] permet d'obtenir l'abscisse finale de la 1ère bille (de rang 0).
liste_trajets[1] permet d'obtenir la liste des abscisses de la 2ème bille (de rang 1).
liste_trajets[1][-1] permet d'obtenir l'abscisse finale de la 2ème bille (de rang 1).
liste_trajets[0] #permet d'obtenir la liste des abscisses de la bille de rang 0
[0, -1, 0, -1, 0, 1, 2, 1, 0, 1, 2]
liste_trajets[0][-1] #permet d'obtenir l'abscisse finale de la bille de rang 0
2
liste_trajets[1] #permet d'obtenir la liste des abscisses de la bille de rang 1
[0, -1, 0, -1, -2, -3, -4, -3, -2, -1, 0]
liste_trajets[1][-1] #permet d'obtenir l'abscisse finale de la bille de rang 1
0
2.3.b. Ecrire une fonction decompte qui compte, dans une liste liste_trajets, le nombre de billes qui ont pour abscisse finale 4.
# Ecrire la fonction decompte
def decompte(liste_trajets):
compteur=0
for k in range(len(liste_trajets)):
if liste_trajets[k][-1]==4:
compteur=compteur+1
return compteur
#test avec la liste précédemment générée
decompte(liste_trajets)
12
2.3.c. Modifier la fonction decompte pour qu'elle compte le nombre de billes qui ont pour abscisse finale a où a est donné en argument de la fonction.
# Ecrire la fonction decompte modifiée
def decompte(liste_trajets,a):
compteur=0
for k in range(len(liste_trajets)):
if liste_trajets[k][-1]==a:
compteur=compteur+1
return compteur
2.3.d. Ecrire une fonction frequence qui reçoit un entier a en argument et renvoie la fréquence de billes qui ont pour abscisse finale a.
# Ecrire la fonction frequence
def frequence(liste_trajets,a):
return decompte(liste_trajets,a)/len(liste_trajets)
2.3.e A l'aide de cette fonction frequence, déterminer la fréquence de billes dont l'abscisse finale vaut 4 pour les trajets stockés dans liste_trajets.
# Effectuer l'appel à la fonction frequence
f=frequence(liste_trajets,4)
f
0.12
2.4.a. Calculer la probabilité qu'une bille ait pour abscisse finale 4 sur la planche de Galton à 10 étages. Calculer l'écart entre cette valeur et la valeur obtenue à la question 2.3.e.
On pourra utiliser la fonction combinaison ci-dessous, qui permet de calculer le coefficient binomial $\displaystyle \left( \begin{array}{c} n \\ k \end{array} \right)$ .
Une bille a pour abscisse finale 4 si et seulement si elle a tourné exactement 7 fois à droite et 3 fois à gauche. Si on note $X$ la variable aléatoire qui correspond au nombre de virages à droite de la bille, alors $X$ suit la loi binomiale de paramètre $n=10$ et $p=\frac{1}{2}$.
La probabilité cherchée est donc $p(X=7)=\left( \begin{array}{c} 10 \\ 7 \end{array} \right) \times \left(\frac{1}{2}\right) ^7 \times \left(\frac{1}{2}\right) ^3=\left(\begin{array}{c} 10 \\7 \end{array}\right)\times \left(\frac{1}{2}\right) ^{10}=0,1171875$
from math import factorial
def combinaison(n,k):
"fonction qui calcule le coefficient binomial de paramètres n et k"
return factorial(n)//(factorial(k)*factorial(n-k))
# Effectuer une saisie pour le calcul de la probabiltié
p=combinaison(10,7)*(1/2)**10
p
0.1171875
2.4.b. Calculer l'écart entre les valeurs obtenues aux questions 2.3.e. et 2.4.a.
# Effectuer une saisie pour la comparaison des deux valeurs
abs(f-p)
0.0028124999999999956
(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/