Pour ce dernier projet NSI de terminale, qui était un projet libre, j’ai décidé de faire un dessin avec turtle en python. J’ai eu cette idée car je n’avais jamais réellement crée un dessin de moi-même entièrement.
Dans cet article je vais vous montrer comment je m’y suis prise pour faire ce dessin, ensuite des difficultés que j’ai rencontrées et enfin le code entier que vous pourrez télécharger et tester chez vous.
Fond du dessin
Pour le fond du dessin, je me suis aidée d’un article des premières de la spécialité NSI pour leur projet « Art », il s’agit d’un fond dégradé, du bleu au noir pour montrer qu’il fait nuit dans mon dessin.
penup()
colormode(255)
speed(0)
goto(-640,0)
pendown()
for i in range(720):
pencolor(0,0, 255-round((i/(720/255))))
forward(1280)
goto(-640,-360+i)
penup()
goto(0, 0)
pendown()
Les étoiles
Pour les étoiles, je me également aidée d’un projet de premières NSI, il s’agit de petits cercles, coloriés à l’intérieur, en banc, de taille différentes et à des positions qui changent à chaque fois.
def etoile():
for i in range(50):
penup()
goto(randint(-720,720), randint(0,360))
pendown()
pencolor(255, 255, 255)
lcercle = randint(1,3)
fillcolor('white')
begin_fill()
circle(lcercle)
end_fill()
Le sable
Une plage sans le sable n’est pas une plage ! Pour la représenter j’ai alors fait un énorme trait de couleur jaune, afin de faire le sol de sable.
Les parasols sont des objets que l’on voit très souvent à la plage, pour les modéliser j’ai alors représenté des triangles pour le haut et un simple trait pour le bas. Chaque parasol a 3 fonctions différentes.
def bas_parasol():
penup()
goto(300,-250)
pensize(20)
pencolor(158, 158, 158)
pendown()
left(90)
forward(150)
def haut_parasol():
penup()
pensize(1)
pencolor(255, 10, 137)
right(90)
forward(75)
fillcolor(255, 10, 137)
pendown()
begin_fill()
for i in range(3):
left(120)
forward(150)
end_fill()
goto(225,-100)
pencolor(255, 163, 211)
ymontagne = -100
for i in range(14):
pendown()
goto(300,ymontagne)
goto(375,-100)
penup()
goto(225,-100)
ymontagne += 10
def parasol():
bas_parasol()
haut_parasol()
def bas_parasol2():
penup()
goto(-150,-250)
pensize(15)
pencolor(158, 158, 158)
pendown()
left(90)
forward(100)
def haut_parasol2():
penup()
pensize(1)
pencolor(38, 150, 60)
right(90)
forward(50)
fillcolor(38, 150, 60)
pendown()
begin_fill()
for i in range(3):
left(120)
forward(100)
end_fill()
goto(-200,-150)
pencolor(62, 237, 96)
ymontagne = -150
for i in range(13):
pendown()
goto(-150,ymontagne)
goto(-100,-150)
penup()
goto(-200,-150)
ymontagne += 7.5
def parasol2():
bas_parasol2()
haut_parasol2()
La lune
Qui dit étoiles et nuit, dit lune ! Pour la lune il suffit de faire plusieurs cercles : un grand de couleur gris clair et deux petits à l’intérieur de couleur gris foncé.
Pour le bas du parasol, j’ai hésité par rapport à la longueur et à la largeur.
La forme du haut du parasol :
Pour le chapeau du parasol, je voulais faire un demi cercle au lieu de triangle car c’est bien plus représentatif d’un parasol, je n’ai pas réussi à m’arrêter à la moitié d’un cercle.
Les motifs sur le haut du parasol
Ses motifs ont été aussi compliqué, je n’arrivais pas à, trouver la bonne disposition, mais j’ai fini par y arriver.
FFBB est une application qui permet de suivre l’actualité du basketball français.
Dans ce site, vous verrez comment l’utiliser de la meilleure des manières.
Tout d’abord, lorsque vous entrez dans l’application, vous êtes dans l’onglet « Actualité »
Dans toute l’application il y en a 8 :
Actualités
Vous pouvez découvrir plein d’articles sur des évènements récents dans le basket Français.
Pour en lire un il suffit de cliquer dessus.
Vidéos
Dans le même style que la page « Actualités », celle-ci répertorie des extraits de matchs, de reportages, et pleins d’autres style de vidéos.
Pour le découvrir il suffit, ici aussi, de seulement cliquer dessus.
Championnats
Cette page a pour but de trier, touts des tournois, afin de pouvoir savoir les scores, dates et heures de matchs, classements de vos équipes préférées.
Pour l’utiliser il suffit juste de chercher, dans les différentes catégories.
Coupes
De la même manière que la page « Championnats », les coupes se déroulent de la même manière.
Il suffit juste de rechercher dans les différentes catégories où votre équipe pourrait concourir.
Live
Le live annonce des matchs de niveau National 1 des hommes, qui se dérouleront prochainement.
Si vous cliquez dessus, vous pouvez voir les détails du match en question.
Favoris
Les favoris servent à ne plus avoir à toujours rechercher, comme des raccourcis.
Pour mettre des équipes en favoris dans les championnats ou coupes, vous avez tout simplement à cliquer sur le symbole « + » qui se situe en haut de la page à droite. A n’importe quel stade de vos recherches.
Recherche
Les recherches servent à trouver un club en particulier où l’on verra toute ses coupes et championnats, l’adresses et les responsables du club.
Pour le trouver vous pouvez procéder de 2 manières différentes :
En renseignant le nom du club
En renseignant le nom de la ville où se situe le club.
A propos
Enfin, la page « A propos » sont les mentions de l’application. Nous ne pouvons rien faire sur cette page à part aller consulter les sites internet mentionnés en lien.
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.
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.
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.
Projets
