Projets
Vous êtes seul et ne savez pas quoi faire? Nous vous proposons un jeux du pendu: affrontez l’ordinateur!
Notre projet consiste à créer un programme en python sur un jeux traditionnel d’école: le jeux du pendu.
Sommaire
Introduction
L’ordinateur va choisir un mot parmi une liste prédéfinie et inconnue de vous, joueur. Vous devez alors essayer de retrouver le mot en proposant différentes lettres. Vous avez le droit a 8 erreurs, et pas une de plus. Une fois toutes les tentatives épuisées, le bonhomme est pendu: vous avez perdu! Mais si vous trouvez le mot avant d’avoir épuisé toutes vos chances, alors c’est gagné!!
Lorsque vous avez trouvé la bonne lettre, un message s’affiche pour vous informer que votre proposition est juste. Le mot qui était vide se complète alors par la bonne lettre. Ainsi il sera plus facile de deviner quel est le mot.
Le code en entier
from random import randint,choice
def initialisation():
liste_mots=["chocolat", "tentacule", "dictionnaire", "magnifique", "saucisson", "xylophone", "serveur", "houx", "clavier"]
choix = choice(liste_mots)
myst = ""
for i in choix:
myst += "_"
return (choix,myst)
def verification(lettre,mot):
if lettre in mot:
return True
else:
return False
def mot_complet(mot):
if "_" not in mot:
return True
else:
return False
def complete_mot(lettre,mot,myst):
for i in range(len(mot)):
if mot[i] == lettre
temp = list(myst)
temp[i] = lettre
myst = "".join(temp)
return myst
def dessin_pendu(n):
dessin = ""
if n == 1:
dessin = "\n" * 7 + " =============="
elif n == 2:
dessin = "\n" + " ||/\n" + " ||\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 3:
dessin = "==============\n" + " ||/\n" + " ||\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 4:
dessin = "============Δ=\n" + " ||/ |\n" + " ||\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 5:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 6:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " || /|\ \n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 7:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " || /|\ \n" + " || |\n" + " ||\n" + " /||\n" + " =============="
elif n == 8:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " || /|\ \n" + " || |\n" + " || / \ \n" + " /||\n" + " =============="
return dessin
def jeu():
tentatives = 8
mot_choisi,mot_cache = initialisation()
while (tentatives > 0) and (not mot_complet(mot_cache)):
print("\nNombre de tentatives restantes :\t", tentatives, "\n")
print(" ".join(mot_cache),"\n\n")
lettre_choisie = input("Choisir une lettre (en minuscule) :\t")
if verification(lettre_choisie,mot_choisi):
mot_cache = complete_mot(lettre_choisie, mot_choisi, mot_cache)
print("\nLa lettre se trouve bien dans le mot\n")
else:
tentatives -= 1
print("\nLa lettre ne se trouve pas dans le mot...\n\n", dessin_pendu(8 - tentatives),"\n\n")
if tentatives == 0:
print(" ".join(mot_cache))
print("\nLe mot était :\n")
print(" ".join(mot_choisi))
print("\nVous avez malheureusement échoué ... \n")
if "_" not in mot_cache:
print(" ".join(mot_cache),"\n\n")
print("\nBravo, vous avez gagné !\n")
input("\nVeuillez taper sur la touche Entrer pour recommencer\n\n")
menu()
def menu():
print("\n-----------BIENVENUE SUR LE JEU DU PENDU-----------\n")
print("-------------------BONNE CHANCE--------------------\n\n")
print("C'EST PARTI! \n")
jeu()
menu()Nous avons choisi la bibliothèque random pour avoir accès à choice qui nous permet donc d’avoir un programme capable de faire un choix de manière complètement aléatoire.
Les appels aux différentes fonctions
Le programme ci dessus se résume en une ligne;
menu()
Celle ci sert à faire appel à la fonction menu, qui elle même va faire appel à d’autres fonctions. Ainsi le programme peut s’exécuter. Par exemple, on remarque que la fonction menu fait appel à la fonction jeu, qui elle même, fait appel à d’autres fonctions (à voir dans le code ci-dessous)
def menu():
#cette fonction présente le jeu
jeu() #renvoie à la fonction "jeu"
def jeu():
#cette fonction est le squelette du programme. elle permet de relier les nombreuses fonctions de manière a pouvoir jouer
mot_choisi,mot_cache = initialisation() #renvoie à la fonction initialisation
while (tentatives > 0) and (not mot_complet(mot_cache)): #tant que le nb de tentatives est > 0 et que --> renvoie à la fonction mot complet --> alors...
"""
etc...
"""Les grandes lignes
Pour pouvoir jouer au jeu du pendu, nous avons besoin d’avoir une liste de mots prédéfinie dans laquelle, un mot au hasard, va être choisi. Le mot, qui aura été sélectionné, apparaitra sous forme de tirets (le nombre de tirets correspondant au nombre de lettres dans le mot).
def initialisation():
liste_mots=["chocolat", "tentacule", "dictionnaire", "magnifique", "saucisson", "xylophone", "serveur", "houx", "clavier"]
choix = choice(liste_mots)
myst = ""
for i in choix:
myst += "_"
return (choix,myst)
Une fois le mot apparu sous la forme de tirets, il faut que lorsqu’une lettre est découverte par le joueur, elle prenne la place du tiret auquel elle correspond (complete_mot). Pour cela, le mot va être transformé en une liste et pourra donc être parcouru par le programme. Mais tout d’abord il faut vérifier que la lettre se trouve bien dans le mot (verification).
def verification(lettre,mot):
if lettre in mot:
return True
else:
return False
def complete_mot(lettre,mot,myst):
for i in range(len(mot)):
if mot[i] == lettre
temp = list(myst) # Transforme le mot en une liste temp
temp[i] = lettre # Remplace le tiret underscore par la lettre
myst = "".join(temp) # Re-combine les éléments de temp pour en faire à nouveau un mot
return myst # Renvoi le mot caché, complété avec la (ou les) lettre(s)
Dans ce jeu, nous avons fait le choix de représenter un bonhomme pendu, comme dans le jeu classique d’école. Pour cela, nous avons programmé une fonction permettant d’afficher une partie du dessin du pendu, au fur et à mesure que le nombre de chances diminue, . Au début il n’y a donc pas de dessin; dessin = "" . Plus le pendu apparait, plus les chances de trouver le bon mot diminuent.
def dessin_pendu(n):
dessin = ""
if n == 1:
dessin = "\n" * 7 + " =============="
elif n == 2:
dessin = "\n" + " ||/\n" + " ||\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 3:
dessin = "==============\n" + " ||/\n" + " ||\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 4:
dessin = "============Δ=\n" + " ||/ |\n" + " ||\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 5:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " ||\n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 6:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " || /|\ \n" + " ||\n" + " ||\n" + " /||\n" + " =============="
elif n == 7:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " || /|\ \n" + " || |\n" + " ||\n" + " /||\n" + " =============="
elif n == 8:
dessin = "============Δ=\n" + " ||/ |\n" + " || O\n" + " || /|\ \n" + " || |\n" + " || / \ \n" + " /||\n" + " =============="
return dessin
Pour terminer, nous avons donc crée une fonction qui, comme dit plus haut, structure notre programme. Elle lie toutes les autres fonctions. Le nombre de tentatives y est rentré, et le programme se lance.
Tant que le nombre de tentatives est supérieur à 0 et que le mot n’est pas complet, le script s’exécute. Si la lettre choisie par le joueur est dans le mot, alors le (ou les dans certains cas) tiret correspondant à la lettre sera remplacé par celle-ci. Sinon, le nombre de tentatives diminue de 1 et le dessin du pendu correspondant au nombre de tentatives apparait.
Pour gagné, il suffit donc de vérifier s’il reste ou non des tirets dans le mot (mot_complet). Lorsqu’il n’y en a plus et que tentative>0, alors c’est gagné. Et lorsque le nombre de tentative = 0, alors le mot apparait en entier, c’est perdu.
def jeu():
tentatives = 8
mot_choisi,mot_cache = initialisation()
while (tentatives > 0) and (not mot_complet(mot_cache)):
print("\nNombre de tentatives restantes :\t", tentatives, "\n")
print(" ".join(mot_cache),"\n\n") # Pour un affichage montrant bien le nombre de lettres à trouver en séparant chaque tiret underscore
lettre_choisie = input("Choisir une lettre (en minuscule) :\t")
if verification(lettre_choisie,mot_choisi):
mot_cache = complete_mot(lettre_choisie, mot_choisi, mot_cache)
print("\nLa lettre se trouve bien dans le mot\n")
else:
tentatives -= 1
print("\nLa lettre ne se trouve pas dans le mot...\n\n", dessin_pendu(8 - tentatives),"\n\n")
if tentatives == 0:
print(" ".join(mot_cache))
print("\nLe mot était :\n")
print(" ".join(mot_choisi))
print("\nVous avez malheureusement échoué ... \n")
if "_" not in mot_cache:
print(" ".join(mot_cache),"\n\n")
print("\nBravo, vous avez gagné !\n")
input("\nVeuillez taper sur la touche Entrer pour recommencer\n\n")
menu()
def mot_complet(mot):
if "_" not in mot:
return True
else:
return False 
Une fois la partie finie, il ne reste plus qu’à cliquer sur la touche Entrer et le programme nous renvoie au menu de base. Une nouvelle partie peut commencer.
A vous de jouer
Si contre, vous trouverez le lien pour télécharger le programme et faire des parties dignes de ce nom. Quelques explications ont été rajoutées dans ce code pour, si vous le souhaitez, réussir à comprendre plus en détail comment il fonctionne.
Maintenant, à vous de jouer!
Cet article a été écrit par des élèves du lycée Louis Pasteur.
Ils étudiaient alors la spécialité NSI, en classe de 1ère.
Promotion 2021 – 2021