Cette deuxième activité fait appel à des notions et instructions vues dans l’activité 1. Prenez bien le temps de les mémoriser. Retour à l'activite 1
Objectif de l’activité 2 : A l’occasion, de la création de la simulation d’un jeu de dés et l’étude statistique des résultats, on introduit le module random, le type d’une variable, les variables de type liste, la manipulation des listes, les compteurs. On consolide la création des fonctions Python, l’utilisation des structures conditionnelles (if … else :…), des structures répétitives bornées (for) et des structures répétitives non bornées (while).
Dans ce qui suit nous aurons besoin du module random de Python dont voici une liste non exhaustive de fonctions. Vérifiez que vous comprenez bien toutes ces instructions en les copiant dans un script Python. Elles sont à mémoriser pour la suite.
from random import* nb=random() # random() génère un nombre pseudo-aléatoire entre 0 et 1 (0 et 1 exclus) print(nb) # affichage de la valeur de nb dans la console print(type(nb)) # permet de connaître le type de la variable nb tab=[0,1,2,3,4,5,6,7,8,9] # tab est une liste d'entiers print(type(tab)) # permet de connaître le type de la variable tab shuffle(tab) # shuffle est une fonction du module random. Elle mélange les valeurs de la liste tab print(tab) # on affiche la nouvelle liste tab dans la console
Davantage d’informations sur le module random ici
Dans ce qui suit, on souhaite créer la simulation d’un lancer de dé non truqué à 6 faces. Pour cela, on va générer de manière aléatoire les entiers 1, 2, 3, 4, 5, 6.
Dans ce qui suit, on souhaite créer le jeu où on lance une fois un dé et où on gagne si on obtient 6.
A faire : Créer la fonction jeu0() qui ne prend pas de paramètre et qui renvoie True si le dé tombe sur 6 et False sinon.
Remarque : la fonction jeu0() aurait pu renvoyer la chaîne de caractères "Gagné !" si le dé tombe sur 6 et la chaîne de caractères "Perdu !" sinon. Testez, dans les deux cas, à l’aide de la fonction type(…) le type de la variable obtenue.
A faire : Observez attentivement les instructions suivantes. Elles s’intéressent au type d’une variable. On remarquera tout particulièrement l’utilité de la fonction int(…). Vérifiez que vous comprenez bien toutes ces instructions en les copiant dans un script Python. Elles sont à mémoriser pour la suite.
a=5 print(type(a)) b=20/3 print(b, "est est une variable de type : ",type(b)) c=20//3 print(c, "est est une variable de type : ",type(c)) d=20%3 print(d, "est est une variable de type : ",type(d)) e=False print(e, "est est une variable de type : ",type(e)) f='Bonjour !' print(f, "est est une variable de type : ",type(f)) g='1789' print(g, "est est une variable de type : ",type(g)) h=int(g) print(h, "est est une variable de type : ",type(h)) t=[44,49,53,72,85] print(t, "est est une variable de type : ",type(t))
Dans ce qui suit, on souhaite créer le jeu dont le nombre de points est le nombre de lancers nécessaires pour obtenir 6.
Indications :on pourra se servir des instructions suivantes qui permettent de saisir au clavier une valeur et de l’affecter à une variable (de type string). L’affichage de la console obtenu par la dernière instruction est-il cohérent ? Comment modifier ces lignes de manière à obtenir le résultat attendu ? (On pourra utiliser une des instructions rencontrées dans la partie B)
a=input("Saisir une valeur entière")
print(a)
print(type(a))
b=input("Saisir une valeur entière")
print(b)
print(type(b))
print('La somme est égale à :',a+b) # Cet affichage est-il cohérent ?
# Si ce n'est pas le cas faites les modifications
# nécessaires et appelez le professeur.
Dans ce qui suit, on fait encore évoluer le jeu en limitant le nombre de lancers de dé à 4. Ainsi, on gagne si on obtient la face, saisie au clavier, avant 4 lancers de dé.
Indications :On s’inspirera de la fonction suivante qui renvoie un triplet (3-upplet) contenant le cosinus, le sinus et la tangente d’un angle dont on donne respectivement le côté adjacent, le côté opposé et l’hypoténuse.
def trigo(adj,opp,hyp): # la fonction prend trois paramètres
cos=adj/hyp
sin=opp/hyp
tan=opp/adj
return cos,sin,tan # elle renvoie un triplet (3-upplet)
a=3 # valeur du côté adjacent
o=4 # valeur du côté opposé
h=5 # valeur de l'hypothénuse
t=trigo(a,o,h) # t prend la valeur renvoyée par la fonction. Il s'agit d'un triplet (un 3 upplet)
print(t)
print("Le cosinus de l'angle est :",t[0]) # t[0] permet d'obtenir la première valeur du 3 upplet
print("Le sinus de l'angle est :",t[1]) # t[1] permet d'obtenir la deuxième valeur du 3 upplet
print("La tangente de l'angle est :",t[2]) # t[2] permet d'obtenir la troisième valeur du 3 upplet
On souhaite maintenant simuler le jeu qui consiste à lancer deux dés cubiques à 6 faces et dont le nombre de points est égal au chiffre des unités du produit des faces.
Exemple :Le dé1 tombe sur 5. Le dé2 tombe sur 6. Le produit des faces est 30. Le chiffre des unités est 0. Le nombre de point obtenu est 0.
Créez la fonction jeu3() qui ne prend pas de paramètre et qui renvoie le nombre de points obtenus après le lancer des deux dés.
Indications :on rappelle les instructions suivantes. Vous les avez déjà rencontrées dans la Partie B.
a/b # a/b est le résultat de la division de a par b a//b # a//b est le quotient de la division euclidienne de a par b a%b # a%b est le reste de la division euclidienne de a par b
Utilisez la fonction précédente pour créer la fonction listeLancers qui prend en paramètre un entier n correspondant au nombre de lancers des deux dés souhaités et qui renvoie la liste des résultats obtenus c’est à dire des points obtenus à chaque lancers.
Indications :
L=[] # Création d’une liste vide nommé ici L
L.append(1) # Ajout d’une valeur dans la liste L
L.append(3) # Ajout d’une deuxième valeur dans une L
L.append(5) # Ajout d’une troisième valeur dans une L
n=len(L) # On calcule la longueur de L et on l'affecte à n
u=L[0] # Première valeur de L (valeur d'indice 0)
v=L[n-1] # Dernière valeur de L (valeur d'indice n-1)
# Parcours d’un tableau Méthode 1 :
print("Méthode1")
for i in range(n): # i prend les valeurs {0 ; 1 ; ... ; n-1}
print(L[i])
# Parcours d’un tableau Méthode 2 :
print("Méthode2")
for element in L:
print(element)
Créez la fonction moyenne(tab) qui prend en paramètre tab, une liste d’entiers, et qui renvoie la moyenne des valeurs contenues dans la liste.
Créez la fonction compterZero(tab) qui prend en paramètre tab une liste d’entiers et qui renvoie le nombre de zéro contenu dans cette liste.
En vous inspirant du code de la fonction précédente, créez la fonction compter(tab,res) qui prend en paramètre tab une liste d’entiers naturels et res un entier naturel et qui renvoie le nombre d’occurrences de l’entier res dans cette liste.
En utilisant la fonction compter(tab,res), créez la fonction effectif(tab) qui prend en paramètre tab, une liste d’entiers inférieurs ou égaux à 9 et qui renvoie la liste tabEffectif, de longueur 10, contenant les différentes occurrences des entiers de 0 à 9 dans la liste tab.
Exemple : On joue à ce jeu 10 fois de suite. On obtient la liste des points :[5, 6, 5, 8, 8, 6, 2, 0, 8, 2].
Le tableau des effectifs est alors : tabEffectif=[1, 0, 2, 0, 0, 2, 2, 0, 3, 0]. En effet,
0 apparaît 1 fois dans tab donc tabEffectif[0]=1
1 n’est pas dans tab donc tabEffectif[1]=0
8 apparaît 3 fois dans tab donc tabEffectif[8]=3
On souhaite créer une deuxième version de la fonction effectif(tab). On l’appellera effectif2(tab). Dans cette nouvelle version on ne souhaite plus utiliser la fonction compter(tab,res).
Pour cela, on crée une liste vide tabEffectif contenant 10 fois la valeur 0.
On balaie la liste tab à l'aide d'une struture répétitive bornée.
Pour chaque valeur tab[i] de tab, on incrémente dans la liste tabEffectif, la valeur dont l’indice est égale à tab[i].
Exemple : Si tab=[5, 6, 5, 8, 8, 6, 2, 0, 8, 2]
Initialement, on a : tabEffectif=[0,0,0,0,0,0,0,0,0,0]
tab[0]=5 donc tabEffectif devient égal à [0,0,0,0,0,1,0,0,0,0]
tab[1]=6 donc tabEffectif devient égal à [0,0,0,0,0,1,1,0,0,0]
etc….
Créez la fonction fréquence(tab) qui prend en paramètre le tableau tab généré par la fonction listeLancers et qui renvoie la fréquence des occurrences des entiers inférieurs ou égaux à 9 dans le tableau tab.
Exemple : Si tab=[5, 6, 5, 8, 8, 6, 2, 0, 8, 2], alors la fonction fréquence renvoie le tableau :
[0.1, 0.0, 0.2, 0.0, 0.0, 0.2, 0.2, 0.0, 0.3, 0.0]
En effet, on a vu que la fonction effectif renvoie [1, 0, 2, 0, 0, 2, 2, 0, 3, 0]
On souhaite analyser les résultats obtenus par cette simulation.