Catégorie : Projets

Projets

Programme python permettant de conjuguer des verbes en Espagnol

Voici un scripte codé en Python par des élèves de la spécialité NSI, permettant de conjuguer automatiquement des verbes en Espagnol. Intéressant n’est ce pas ? Voici leur explication détaillée des différentes fonctionnalités de leur script, ainsi que de leur démarche lors de la réalisation de leur projet.

Lors de l’exécution du script, le groupe auxquels votre verbe devra être conjugué vous sera demandé. Puis ce sera au tour du temps (il n’y a que les temps principaux).

Les réponses attendues sont très simples, il est nécessaire d’écrire simplement un nombre suivant votre choix

Nous avons définis les fonction au début du script pour que ce soit plus facile a comprendre.

#On a définit dans un premier temps les fonctions utilisées dans notre menu
def fonction1():
    print("""
Vous avez choisit Les verbes en ER""")
    input() #Permet d'avoir un espcacement entre les phrases pour une meilleur lisibilité
    
def fonction2(): 
    print("""
Vous avez chosit Les verbes en AR""")
    input()
    
def fonction3():
    print("""
Vous avez choisit Les verbes en IR""")
    input()
    
def fonction4():
    print("""
Vous avez choisit le Présent""")
    input()
    
def fonction5(): 
    print("""
Vous avez chosit le Futur""")
    input()
    
def fonction6():
    print("""
Vous avez choisit le Passé""")
    input()
    
def fonction7():
    print("""
Vous avez choisit Les verbes Irréguliers""")

On définit ensuite le programme :

Menu: C’est la partie qui prend en compte tout sur les temps, les groupes ainsi que les verbes réguliers ou irréguliers.

Lorsque que l’on choisit le temps cela nous emmène sur le choix du groupe puis sur le choix entre un verbe régulier ou irrégulier. Cela nous donne donc les terminaisons (si c’est régulier) ou tous les verbes écrit en entiers (irrégulier).

#On définit le programme
def menu():
    print("Choisissez un temps :") #On chosit le temps
    choix=int(input("""
1. Présent
2. Futur
3. Passé
9. Quitter le programme
                                     
Rentrez votre choix : """))
   
   
   
    if choix==1:
        fonction4()
        print("""
Choisir un groupe :""") #On chosit ensuite le groupe
        choix=int(input("""
4. Verbe en ER
5. Verbe en AR
6. Verbe en IR
9. Quitter le programme
       
Rentrez votre choix : """))
       
       
        if choix==4:
            fonction1()
            print("""
Choisir la forme du verbe :""") #On choisit la forme du verbe
            choix=int(input("""
8. Verbe Régulier
7. Verbe Irégulier
9. Quitter le programme
 
Rentrez votre choix : """))
           
           
           
            if choix==8:
                print("""
Verbe Régulier :
 
-o, - es, -e, -emos, - éis, -en""")
                exit
               
            elif choix==7:
                print("""
Verbe Irégulier :
 
.ser : soy, eres, es, somos, sois, son
.ver : veo, ves, ve, vemos, veis, ven
.saber : sé, sabes, sabe, sabemos, sabéis, saben
.haber : he, has, ha , hemos, habéis, han
.poner : pongo, pones, pone, ponemos, ponéis, ponen
.hacer : hago, haces, hace, hacemos, hacéis, hacen
.caer : caigo, caes, cae, caemos, caéis, caen
.traer : traigo, traes, trae, traemos, traéis, traen
.tener : tengo, tienes, tiene, tenemos, tenéis, tienen""")
           
            elif choix==9:
                print("Fin du programme")
                exit
           
            else:
                choix!=9
                print("Valeur invalide")
                input()
                menu()
 
           
           
           
        elif choix==5:
            fonction2()
            print("""
Choisir la forme du verbe :""") #On choisit la forme du verbe
            choix=int(input("""
8. Verbe Régulier
7. Verbe Irégulier
9. Quitter le programme
 
Rentrez votre choix : """))
           
           
           
            if choix==8:
                print("""
Verbe Régulier :
 
-o, -as, -a, -amos, -áis, -an""")
           
           
            elif choix==7:
                print("""
Verbe Irégulier :
 
.estar : estoy, estás, está, estamos, estáis, están
.dar : doy, das, da, damos, dais, dan""")
           
       
        elif choix==6:
            fonction3()
            print("""
Choisir la forme du verbe :""") #On choisit la forme du verbe
            choix=int(input("""
8. Verbe Régulier
7. Verbe Irégulier
9. Quitter le programme
 
Rentrez votre choix : """))
           
           
           
            if choix==8:
                print("""
Verbe Régulier :
 
-o, -es, -e, -imos, -ís, -en""")
               
           
           
            elif choix==7:
                print("""
Verbe Irégulier :
 
.ir : voy, vas, vas, vamos, vais, van
.salir : salgo, sales, sale, salemos, saléis, salen
.venir : vengo, vienes, viene, venemos, venéis, vienen          
.decir : digo, dices, dice, decimos, decís, dicen""")        
       
       
 
        elif choix==9:
            print("Fin du programme")
            exit
           
        else:
            choix!=9
            print("Valeur invalide")
            input()
            menu()
           
   
    elif choix==2:
        fonction5()
        print("""
Choisir un groupe :""")#Chosir le groupe
        choix=int(input("""
4. Groupe en ER
5. Groupe en AR
6. Groupe en IR
9. Quitter le programme
       
Rentrez votre choix : """))
       
       
        if choix==4:
            fonction1()
            print("""
Choisir la forme du verbe :""") #On choisit la forme du verbe
            choix=int(input("""
8. Verbe Régulier
7. Verbe Irégulier
9. Quitter le programme
 
Rentrez votre choix : """))
           
           
           
            if choix==8:
                print("""
Verbe Régulier :
 
-é ,-ás,- á ,-emos ,-éis,- án""")
           
           
            elif choix==7:
                print("""
Verbe Irégulier :
 
.CABER : cabré, cabrás,cabrá, cabremos, cabréis, cabrán
.HABER : habré, habrás, habrá, habremos, habréis, habrán
.HACER : haré, harás, hará, haremos, haréis, harán
.PODER : podré, podrás, podrá, podremos, podréis, podrán
.PONER : pondré, pondrás, pondrá, pondremos, pondréis, pondrán
.QUERER : querré, querrás, querrá, querremos, querréis, querrán
.SABER : sabré, sabrás, sabrá, sabremos, sabréis, sabrán
.TENER : tendré, tendrás,tendrá, tendremos, tendréis, tendrán
.VALER : valdré, valdrás, valdrá, valdremos, valdréis,valdrán""")
           
           
        elif choix==5:
            fonction2()
            print("""
Choisir la forme du verbe :""") #On choisit la forme du verbe
            choix=int(input("""
8. Verbe Régulier
7. Verbe Irégulier
9. Quitter le programme
 
Rentrez votre choix : """))
           
           
           
            if choix==8:
                print("""
Verbe Régulier :
 
-é ,-ás,- á ,-emos ,-éis,- án""")
               
            elif choix==7:
                print("""
Aucun Verbe Irrégilier""")
               
       
        elif choix==6:
            fonction3()
            print("""
Choisir la forme du verbe :""") #On choisit la forme du verbe
            choix=int(input("""
8. Verbe Régulier
7. Verbe Irégulier
9. Quitter le programme
 
Rentrez votre choix : """))
           
           
           
            if choix==8:
                print("""
Verbe Régulier :
 
-é ,-ás,- á ,-emos ,-éis,- án""")
               
            elif choix==7:
                print("""
Verbe Irégilier :
 
.VENIR : vendré, vendrás, vendrá, vendremos, vendréis, vendrán
.SALIR : saldré,saldrás, saldrá, saldremos, saldréis, saldrán
.DECIR : diré, dirás, dirá, diremos, diréis, dirán""")
       
        elif choix==9:
            print("Fin du programme")
            exit
           
        else:
            choix!=9
            print("Valeur invalide")
            input()
            menu()
           
    elif choix==3:
        fonction6()
        print("""
Choisir un groupe :""")
        choix=int(input("""
4. Groupe en ER
5. Groupe en AR
6. Groupe en IR
9. Quitter le programme
       
Rentrez votre choix : """))
       
       
        if choix==4:
            fonction1()
            print("""
Choisir la forme du verbe :""") #On choisit la forme du verbe
            choix=int(input("""
8. Verbe Régulier
7. Verbe Irégulier
9. Quitter le programme
 
Rentrez votre choix : """))
           
           
           
            if choix==8:
                print("""
Verbe Régulier :
 
-í; - iste; -ió; -imos; -isteis; -ieron""")
               
            elif choix==7:
                print("""
Verbe Irégilier :
 
.HABER: hube, hubiste, hubo, hubimos, hubisteis, hubieron
.HACER: hice, hiciste, hizo, hicimos, hicisteis, hiciero
.PODER : pude, pudiste, pudo, pudimos, pudisteis, pudieron
.PONER : puse, pusiste, puso, pusimos, pusisteis, pusieron
.QUERER : quise, quisiste, quiso, quisimos, quisisteis, quisieron
.SABER : supe, supiste, supo, supimos, supisteis, supieron
.TENER : tuve , tuviste, tuvo, tuvimos, tuvisteis, tuvieron
.TRAER : traje, trajiste, trajo, trajimos, trajisteis, trajeron
.SER/IR : fui, fuiste, fue, fuimos, fuisteis, fueron""")
               
               
 
           
        elif choix==2:
            fonction5()
            print("""
Choisir la forme du verbe :""") #On choisit la forme du verbe
            choix=int(input("""
8. Verbe Régulier
7. Verbe Irégulier
9. Quitter le programme
 
Rentrez votre choix : """))
           
           
           
            if choix==8:
                print("""
Verbe Régulier :
 
-é; -aste; -ó; -amos; -asteis; - aron""")
           
            elif choix==7:
                print("""
Verbe Irégilier :
 
.DAR : di, diste, dio, dimos, disteis, dieron
.ESTAR : estuve, estuviste,estuvo, estuvimos, estuvisteis, estuvieron
.ANDAR : anduve, anduviste, anduvo, anduvimos, anduvisteis, anduvieron """)          
       
        elif choix==6:
            fonction3()
            print("""
Choisir la forme du verbe :""") #On choisit la forme du verbe
            choix=int(input("""
8. Verbe Régulier
7. Verbe Irégulier
9. Quitter le programme
 
Rentrez votre choix : """))
           
           
           
            if choix==8:
                print("""
Verbe Régulier :
 
-í; - iste; -ió; -imos; -isteis; -ieron""")
               
            elif choix==7:
                print("""
Verbe Irégilier :
 
.DECIR : dije, dijiste, dijo,dijimos, dijisteis, dijeron
.VENIR : vine, viniste, vino, vinimos, vinisteis, vinieron
.CONDUCIR : conduje, condujiste, condujo, condujimos, condujisteis, condujeron""")            
       
        elif choix==9:
            print("Fin du programme")
           
           
        else:
            choix!=9
            print("Valeur invalide")
            input()
            menu()
           
    elif choix==9:
            print("Fin du programme")
            exit
           
    else:
        choix!=9
        print("Valeur invalide")
        input()
        menu()
                 
menu()

Il y a plusieurs options de combinaison pour notre script :

ex : Présent + 1erg + irrégulier

Présent + 3emeg + régulier etc…

Entre chaque choix il faut appuyer sur ENTRER pour que le « shell » soit plus esthétique.

Vous pouvez télécharger le script si-dessous pour l’utiliser (avec Thonny) :

Projets

QCM sur les participes passés irréguliers en espagnol en…

Python est un langage de programmation interprété, multi-paradigme et multiplate-formes. Il favorise la programmation impérative structurée, fonctionnelle et orientée objet. Il est doté d’un typage dynamique fort, d’une gestion automatique de la mémoire par ramasse-miettes et d’un système de gestion d’exceptions.

Présentation du projet

Ce QCM a pour but d’apprendre et de progresser en espagnol et plus précisément sur les participes passées irréguliers, il s’adresse aux jeunes lycéens ayants des difficultés dans l’apprentissage de l’espagnol. 
Pour apprendre de manière agréable, sans ennui et de façon pédagogique, nous avons opté pour la création d’un questionnaire à choix multiples.

Notre programme

import random
#Questions Globales  # la répétition correspond a la bonne réponse
 
print(" Taper la bonne réponse A,B ou C ( ne pas oublier les majuscules , c'est une série de 14 questions . Si vous répondez autre chose que A B C le programme plantera il faudra le relancer . " )
 
 
Question = [["Quel est le participe passé de mourir en espagnol ?","A :Merto","B :Muerto","C :Morto","B :Muerto"],
            ["Quel est le participe passé de dire en espagnol  ? ","A :Dicho","B :Diche","C :Diecho","A :Dicho"],
            ["Quel est le participe passé de faire en espagnol ?","A :Hecho","B :Hechio","C :Hacer","A :Hecho"],
            ["Quel est le participe passé de casser en espagnol ?","A :Rota","B :Rato","C :Roto","C :Roto"],
            ["Quel est le participe passé de voir en espagnol ?","A :Visto","B :Viesto","C :Viste","A :Visto"] ,
            ["Quel est le participe passé de mettre en espagnol ? ","A :Pesto","B :Puesto","C :Pusto","B :Puesto"],
            ["Quel est le participe passé de revenir en espagnol ?","A :Vulte","B :Vuelte","C :Vuelto","C :Vuelto"],
            ["Quel est le participe passé de ouvrir en espagnol ?","A :Abrir","B :Abierto","C :Aberto","B :Abierto"],
            ["Quel est le participe passé de écrire en espagnol ?","A :Escrite","B :Escriento","C :Escrito","C :Escrito"],
            ["Quel est le participe passé de découvrir en espagnol ?","A :Describierto","B :Descubierte","C :Descubierto","C :Descubierto "],
            ["Quel est le participe passé de couvrir en espagnol ?","A :Cubierto","B :Cubrito","C :Cubriento","A :Cubierto"],
            ["Quel est le participe passé de imposer en espagnol ?","A :Imposto","B :Impuesto","C :Impueste","B :Impuesto"],
            ["Quel est le participe passé de décrire en espagnol ?","A :Descriente","B :Descrito","C :Descriento","B :Descrito"],
            ["Quel est le participe passé de satisfaire en espagnol ? ","A :Satisfeche","B :Satisfecho","C :Satisficho","B :Satisfecho"]
             
 
qtal = Question #On enleve des éléments de la liste pour ne pas répéter la question.
 
score = 0
x = 0
while x < 14 :
 for i in range(0,1):
 lQst = random.choice(qtal)  #On prend une question
 qtal.remove(lQst)  #Qu'on enleve de notre liste de questions
 print(lQst[0])  #On l'affiche
 
     
 print(lQst[1]) #Les 3 réponses
 print(lQst[2])
 print(lQst[3])
   
  lRep = ""
  lRep != ["A","B","C"]
 
  lRep = str(input("Votre réponse: ")) #On redemande
   
  if lRep == "A": #On récupère le choix
  lChx = lQst[1]
       
  if lRep == "B":
  lChx = lQst[2]
  if lRep == "C":
  lChx = lQst[3]
 
  if lChx == lQst[4]: #rpvrai
  print("-- VRAI --\n")
  print("Nouvelle question : " )
   x += 1
   score = score+1
       
else: #Sinon
 print("-- FAUX --\n")
 print(" La bonne réponse était : "), print(lQst[4])
 
print("Nouvelle question : " )
 x += 1
     
 
x = 14
print(" Fin du jeu ! " )
print(" Votre score est de : ", score, "sur 14")

Explication du programme

Dans ce programme nous avons fait quatorze questions qui correspondent aux quatorze participes passés irréguliers en espagnol, dans chaque question, trois réponses sont proposées dont une seule réponse est correcte et les deux autres sont fausses. 
Notre programme a pour but de différencier les bonnes des mauvaises réponses.
Le programme génère aléatoirement une question de la liste de quatorze questions(une fois la question générée, cette dernière est supprimé de la liste de questions afin qu’elle ne soit pas proposée une seconde fois), trois propositions s’affiche alors sur l’écran (A, B et C) dont une seule est juste.
Le programme vous demande alors votre réponse, qui doit être entrée par les lettres A, B ou C écrits en majuscule. Si la lettre entrée est écrite en minuscule, le programme ne reconnaît pas cette réponse et plante, il faudra alors le relancer.

Si la réponse donnée est juste, une inscription « VRAIE » sera affichée et 1 point vous sera accordé pour la note finale.

Si la réponse donnée est mauvaise, une inscription « FAUX » sera affichée est il n’y aura pas de point accordé pour la note finale. Et le programme indiquera quelle était la bonne réponse.

A la fin du programme, le programme indique que le QCM se termine et indique votre score sur quatorze points.

L’ajout d’un compteur de points

score = 0 
x = 0

x += 1
score = score+1

print( » Votre score est de : « , score, « sur 14 »)

Nous avons également créé un compteur de points qui cumule un point par bonne réponse et crée une note sur quatorze points, ce qui permet de se faire une idée sur notre niveau sur les participes passés irréguliers en espagnol.

Conclusion

Ainsi, ce programme, très facile d’utilisation, permet de faciliter l’apprentissage des participes passés irréguliers en espagnol pour un élève qui apprend cette langue.

ALLEZ-Y !

Allez-y, cliquez juste en bas pour essayer ce QCM !

Projets

Tableau d’avancement pour un élève en physique-chimie

Le tableau d’avancement est un outil utilisé principalement en physique chimie, il permet d’établir un bilan de matière à l’état initial, pendant la réaction et à l’état final. Il est ensuit utilisé pour connaitre les quantités de matières finales.

Tableau d’avancement exemple

Présentation du projet

Le programme python créé ici permet de calculer les quantités de matières finales lors d’une réaction chimique produite afin d’aider un élève de physique chimie à calculer le tableau d’avancement de cette réaction.
Le programme est un programme simple basé sur une boucle while, étudiée en classe de première de NSI. La boucle permet ici de soustraire une valeur calculée par le programme à une valeur donnée initialement par l’utilisateur jusqu’au nombre minimum de zéro.

L’utilisateur du programme se doit de rentrer en premier les informations dont le programme se base ensuite, telles les coefficients stœchiométriques et les quantités de matières initiales. Le pas d’avancement n’est pas obligatoire, c’est pour cela qu’il a été décidé de le rajouter dans la 2ème étape du projet. C’est lors de la dernière étape que le programme a été peaufiné.

Etape 1 :

print("Donner les valeurs des coefficients stœchiométriques")
a=int(input("Valeur a="))
b=int(input("Valeur b="))
c=int(input("Valeur c="))
d=int(input("Valeur d="))
print("Donner les valeurs des quantités")
na=float(input("Quantité de a"))
nb=float(input("Quantité de b"))

Etape 2 :

print("Donner les valeurs des coefficients stœchiométriques ")
a=int(input("Valeur a="))
b=int(input("Valeur b="))
c=int(input("Valeur c="))
d=int(input("Valeur d="))
pas=float(input("Donner le pas d'avancement="))
print("Donner les valeurs des quantités")
na=float(input("Quantité de a"))
nb=float(input("Quantité de b"))

Etape 3 :

print("Quelles sont les valeurs des coefficients stochiométriques ?")
a=int(input("Donnez la valeur de a="))
b=int(input("Donnez la valeur de b="))
c=int(input("Donnez la valeur de c="))
d=int(input("Donnez la valeur de d="))
pas=float(input("Donner le pas d'avancement="))
print("Donner les valeurs des quantités na et nb")
nai=float(input("La quantité de a est:"))
nbi=float(input("La quantité de b est:"))

C’est aussi lors de l’étape 2 que la boucle while a été mise en place :

while na>0.0 and nb>0.0:
    na=nai-a*x
    nb=nbi-b*x
    nc=nci+c*x
    nd=ndi+d*x
    print("na=",na,"\tnb=",nb,"\tnc=",nc,"\tnd=",nd)
    x=x+pas
print("Xmax est",x)

Analyse et conclusion

Quelques difficultés ont été rencontrées avec le « x » car il fallait le définir avant la boucle, l’insérer ainsi dans le programme ne fonctionnait pas.
La boucle while est composée de formules qui permettent de calculer les proportions restantes des réactifs et des produits jusqu’au moment où soit « a » soit « b » est égal à zéro.

L’étape 3 a permis de rajouter les dernières lignes du programme qui commentent et nous dis lequel des réactifs est limitant dans le cas où soit « a » soit « b » est atteint zéro, ou dans le cas où les deux réactifs ont atteint en même temps le palier de zéro, c’est-à-dire que le mélange a été introduit dans les proportions stœchiométriques.

if na==0 and nb==0:
    print("Le mélange a été introduit dans des proportions stœchiométriques.")
elif na==0:
    print("Le réactif limitant est na.")
elif nb==0:
    print("Le réactif limitant est nb.")
Projets

Le défi de python, concours tiplanet.org

En naviguant par hasard sur le site tiplanet.org, nous sommes tombé sur un défi Python et comme se perfectionner en python était l’un de nos objectifs, autant joindre l’utile à l’agréable.

Concours de rentrée 2019 – défi de Python

Pour le défi python 2019 des sites internet tiplanet.org et planet-casio.com , il fallait se constituer une main de 10 pokemons maximum et leur attribuer une priorité d’attaque.

Pour cela, un script Python va offrir à ta calculatrice la fonction pk(n,p) pour ajouter un Pokémon à ta main, avec :
n, le numéro de Pokémon de 1 à 94
p, la priorité d’attaque que tu souhaites donner au Pokémon en question (1 par défaut)

Dans la suite de l’article, le « nous » fait référence au participant 16 et au participant 17, car nous avons réalisé les recherches en commun.

Recherche pifométrique manuelle

Comme beaucoup de joueurs, nous avons commencé par générer des mains au petit bonheur la chance, gratifié d’un score maximum de 44,2 nous sommes vite passé à une autre méthode.

Nous aurions bien voulu commencer les recherches sur la NumWorks, mais les problèmes de mémoires dont-elle souffre à cette époque, avant la mise à jour 13.2 rendent ces recherches impossibles sur la calculatrice.

Ajouter quelques lignes de codes au script de 3.7 ko aurait fait planter la calculatrice.

Nous sommes donc passé sur Thonny et y avons exécuté nos scripts pythons

10 attaques mêlant force brute et analyse statistique

Attaque n°1 : 10n tirages aléatoires

Après avoir neutralisé les fonctions print(), les affichages des scripts du concours, et rajouté quelques variables globales, une boucle de tirage aléatoire fut codée :

import random
 
score, scoremax = 0.0, 0.0
code, codemax = 0.0, 0.0
tentative = 0
 
def tiragemain():
  for i in range(1,11,1):
    pokemonaleatoire = random.randint(1,94)
    score=pk(pokemonaleatoire,i)
  return score,code
 
while score<49.3:
  # Les trois lignes ci-dessous réinitialisent le script, qui tourne sans s'arrêter
  na,pkl=21,[]
  lnm =["Bulbizarre","Herbizarre","Florizarre","Salameche","Reptincel","Dracaufeu",
        "Carapuce","Carabaffe","Tortank","Chenipan","Chrysacier","Papilusion","Aspicot",
        "Coconfort","Dardargnan","Roucool","Roucoups","Roucarnage","Rattata","Rattatac",
        "Piafabec","Rapasdepic","Abo","Arbok","Pikachu","Raichu","Sabelette","Sablaireau",
        "Nidoran F","Nidorina","Nidoqueen","Nidoran M","Nidorino","Nidoking","Melofee",
        "Melodelfe","Goupix","Feunard","Rondoudou","Grodoudou","Nosferapti","Nosferalto",
        "Mystherbe","Ortide","Rafflesia","Paras","Parasect","Mimitoss","Aeromite","Taupiqueur",
        "Triopikeur","Miaouss","Persian","Psykokwak","Akwakwak","Ferosinge","Colossinge","Caninos",
        "Arcanin","Ptitard","Tetarte","Tartard","Abra","Kadabra","Alakazam","Machoc","Machopeur",
        "Mackogneur","Chetiflor","Boustiflor","Empiflor","Tentacool","Tentacruel","Racaillou",
        "Gravalanch","Grolem","Ponyta","Galopa","Ramoloss","Flagadoss","Magneti","Magneton",
        "Canarticho","Doduo","Dodrio","Otaria","Lamantine","Tadmorv","Grotadmorv","Kokiyas",
        "Crustabri","Fantominus","Spectrum","Ectoplasma"]
  mrandmax,mrand,mfmax,nn,mp=2**31-1,0,93,getlinechars(True)-na,na//2
  tentative = tentative+1
  score,code = tiragemain()
  if score>scoremax:
    scoremax = score
    codemax = code
    print("################# tirage n°",tentative,"score =", scoremax,"avec le code", codemax,"#################", round(score,8))

Le résultat n’est pas optimal, on ne tire aléatoirement que les Pokémons en passant naïvement que les forces sont forcement des entiers entre 1 et 10.

Mais on arrive à fabriquer des scores aux alentours de 46,2.
En une nuit, on arrive péniblement à réaliser entre 4 et 7 millions de tirages.

A ce stade de la recherche, compte tenu de nos hypothèses, on cherche une solution optimale parmi 3 . 1019 possibilités. Toute force brute est impossible.

Attaque n°2 : 10n tirages aléatoires

On décide de faire tourner le script précédent et de mémoriser les compositions des mains supérieures à 46

On va donc réaliser quelques millions de tirages, et dénombrer les Pokemons qui ont permis de faire une main supérieure à 46

  if score>46:
    for i in listeobtenu:
      benchmark46(i,score)

Le lendemain, nous avons un histogramme qui nous donne des Pokemons performant.

[0, 54, 25, 143, 11, 99, 39, 23, 5, 10, 6, 11, 9, 17, 10, 31, 70, 13, 12, 10, 48, 15, 38, 51, 18, 6, 21, 33, 13, 19, 5, 8, 13, 48, 13, 33, 35, 5, 31, 24, 31, 9, 33, 94, 28, 13, 5, 106, 16, 8, 34, 51, 27, 6, 13, 3, 36, 33, 42, 4, 17, 9, 72, 311, 3, 16, 30, 25, 32, 74, 13, 60, 172, 40, 12, 62, 44, 1, 8, 38, 6, 32, 15, 22, 21, 101, 25, 24, 73, 19, 26, 5, 33, 4, 18]

Le Pokemon 63 (Abra) est sorti 311 fois dans la nuit dans des mains valant plus de 46 points. Le 64 lui était très mauvais, et il n’était que dans 3 mains valant plus de 46 points.

Attaque n°3 : Tirages aléatoires sur liste optimale

Le deuxième jour, nous avons poursuivi les tirages aléatoires mais sur des listes optimales générées à l’aide de l’histogramme de la veille.

Liste large : [ 3 , 5 , 16 , 33, 43, 47, 51, 58, 62, 63, 69, 71, 72, 73, 75, 76, 85, 88 ]
Liste short : [ 3 , 5 , 16 , 47, 62, 63, 69, 72, 75, 85, 88]

Au lieu de tirer au hasard un Pokémon parmi 94, on le tirait dans une liste prédéfini à diverses positions (nous pensions que la force était la position, donc un entier entre 1 et 11)

def tiragemain():
  listeobtenu =[]
  top = [ 3 , 5 , 16 , 47, 62, 63, 69, 72, 75, 85, 88]
  random.shuffle(top)
  for i in range(1,11,1):    
    pokemonaleatoire = top[i-1]
    listeobtenu.append(pokemonaleatoire)
    score=pk(pokemonaleatoire,i)
  for i in listeobtenu:
    benchmark(i,score)
  if score>47:
    for i in listeobtenu:
      benchmark47(i,score)
  return score,code,listeobtenu

5 000 000 de tirages plus tard, pas de grandes améliorations, 47.6 est notre meilleur score, mais c’est déjà un joli résultat.

Attaque n°4 : Valeur moyenne des mains

Toutes les tentatives pour optimiser la valeur moyenne des mains ont échouées.
Le calcul lui même de cette moyenne n’étant pas concluant.

Attaque n°5 : Recherche des Pokémon forts sur R

En lisant le forum associée à ce défi sur Planète Casio, on croit comprendre qu’il n’y a pas un nombre fini de combinaison, donc si on tire n dans les entiers entre 1 et 94, p lui serait un réel. On relance les scripts précédents et miracle on passe au dessus de 47.8.

def tiragemain():
  listeobtenu =[]
  for i in range(1,11,1):    
    pokemonaleatoire = random.randint(1,94)
    listeobtenu.append(pokemonaleatoire)
    score=pk(pokemonaleatoire,uniform(0,2**31-1))
  if score>46:
    for i in listeobtenu:
      benchmark47(i,score)
  return score,code,listeobtenu

Après avoir affiné la liste des Pokémons optimaux, on relance les autres scripts qui mélangent, permutent, tirent d’après la liste optimale, et on obtient nos premiers score à 48.

code0^uxOeh%_##>(6#))*&#^heO0xku#_D#’’#%$*.0
Score48.1283516409064348.14694065075124

Attaque n°6 : Élimination des plus faibles

N’étant pas certains d’avoir la main optimale, on essaye de remplacer un Pokémon par tous les autres pour voir si le score s’améliore. Cette méthode ne permet pas de progresser.

Attaque n°7 : Tentative de spécifications des fonctions

On décide alors de documenter le code, de le décrypter, d’essayer de voir si on ne peut pas faire le problème à l’envers, c’est une attaque par spécification du code.

def mmod(a, b):
    # retourne la partie décimale de a a vérifier
    # si a est un entier, retourne 0
    # ?? intérêt , a % b économise de la mémoire
    return a % b
 
 
def getplatform():
    # retourne la valeur 1
    # ?? intérêt ?
    return 1
 
 
def getlinechars(o=False):
    # Cette fonction est une bague. Elle est appelée une unique fois avec true
    # et alors getlinechars(True) retourne 99
    c = 2 ** 31 - 1
    k = getplatform()
    # ?? k = 1 ;-)
    if k >= 0:
        # k = 1 donc est exécuté dans 100% des cas ...
        c = [53, o and 99 or 29, o and 509 or 21, 31, 32, c, c][k]
    return c  # c= 99  ... sauf astuce et codage plus bas ^^
    # pas défaut, en l'absence de True getlinechars() retourne 29

Les premières fonctions sont faciles à spécifier. Les variables sont parfois rigolotes :

na = 21
# 42/2 ? :-) Utilisé 2 fois, jamais modifié
mrandmax = 2 ** 31 - 1
# valeur max d'un entier positif signé codé en 32 bits... spé NSI inside
mrand = 0
# rien d'aléatoire ici, sera modifié par la fonction mseed()
mfmax = 93
# 94-1
nn = getlinechars(True) - na
# nn = 99-21 = 78 (sans calculatrice !)
mp = na // 2
# mp = 10, jamais modifié, utilisé une seule fois f° pk

mais nous sommes restés coincés sur les fonctions getattack(), clean() et surtout pk(). µ
Par contre la fonction setst() nous a passionné ! Le script original à peine modifié, commenté et codé en pep8 :

Attaque n°08 : Manipulations autour du code réponse

La liste des Pokémons est codée en dur dans le script, mais il n’en est rien de leurs qualités ni de la valeur de force optimale pour chaque Pokémon. Cette dernière est donc calculée. Or la chaîne de caractère du code réponse semble peu varier lorsque de l’on tire depuis une liste fixé de Pokémons.

Nous comprenons que :

  • La partie gauche code la liste des Pokémons
  • La partie droite leur force
  • Pour un code « ABCDEFGHIJ0987654321« , on a 10 couples (un exemple est ici en gras) qui définissent les 10 Pokémons et leurs points d’attaque.
  • On peut faire de jolie permutation sans changer le score obtenu car les couples n’influent pas les uns sur les autres
  • Il n’y a aucune clé de vérification, on peut tester des codes au hasard sans avoir la moindre idée de la main des Pokémons et de leur forces
  • Les forces sont codés par des caractères ASCII, on n’est plus du tout dans R mais de retour dans N.
def i2c(k):
    # Transforme un nombre décimal en chaine de caractère
    return chr(k + 33)
 
 
def c2i(c):
    # transforme une chaine de caractère ayant un élèment en valeur décimale
    # cette valeur décimale sera comprise entre 32 (a) et 89 (z)
    return ord(c) - 33

En modifiant à la main la partie droite de la chaîne de caractère, on arrive à modifier très substantiellement le score, à la hausse comme à la baisse. Notre premier 49 est obtenu en bricolant à la main la chaîne de caractère.

codeu^KhxO_%#l » » »l » » »%%%
Score49.031613189324844

C’était assez jouissif il faut dire, en changeant un caractère parmi les 10 derniers, notre score pouvait plonger OU augmenter bien plus vite que tous nos algorithme de tirages aléatoires qui tournaient des nuits complètes…

Ce code réponse ne contient que 20 caractères, on connaît déjà les 10 premiers (du moins on le pense) il ne nous reste plus qu’à utiliser la force brute sur les dix derniers caractères.

Attaque n°09 : Force brute

Grace à notre compréhension obtenue avec l’attaque n°08, on a supposé que pour une liste de 10 Pokémons, il existe une suite de forces optimales. On a ainsi écrit un petit script permettant de trouver cette suite optimale :

lc = [None,"!","!","!","!","!","!","!","!","!","!"]
carac = '!"#$%&'+"'"+'()*+^;_,-./0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
def cons(liste):
    # Construit le code
    global cc
    cc = ""
    for j in range(len(liste)):
        cc = cc+liste[j]
def turboBoost(pokemons,vitesse=1,style=1):
    # Prend une main de pokemon et lui donne des steroides
    # la chaine finale sous forme de liste pour modifier les caracteres
    lc[0]=pokemons
    # les caracteres a tester (tout ce qui est possible)
    for l in range(vitesse+3):  
        # creation du code par test (5x ou 4x pour trouver "l'etat stable" a tout les coups)
        # vitesse 1 = rapide, vitesse 2 = lent mais plus sur
        for i in range(1,11):
            # On initialise tout
            global cc
            cons(lc)
            scores = [0]
           
            for k in range(len(carac)):
                # On recense le score pour chaque caractere
                lc[i] = carac[k]
                cons(lc)
                score = setst(cc)
                scores.append(score)
            # On prend le gagnant, c'est notre partie de cle
            lc[i] = carac[scores.index(max(scores))-1]
            # on cree le code final
            cons(lc)
         # style pour la fonction (purement cosmetique)
        if style:
            print(int((l+1)*100/(vitesse+3)),"%")
            if vitesse == 1:
                print("====="*(l+1)*2+"....."*(8-(l+1)*2))
            if vitesse == 2:
                print("===="*(l+1)*2+"...."*(10-(l+1)*2))
    score = setst(cc)
    print(cc+" :",score,": "+code)

On remarque qu’il est nécessaire d’avoir une liste pour modifier les éléments de la chaîne de caractères un par un à une position donnée.

Rien qu’avec ce script, on a pu augmenter considérablement le score des meilleurs Pokémons issus des attaques précédentes :

Avant :

u^KhxO_%#l » » »l » » »%%%Retour ligne automatique
Out[17] : 49.031613189324844

Après :

turboBoost(« u^KhxO_%#l »)Retour ligne automatique
25 %Retour ligne automatique
==========…………………………Retour ligne automatique
50 %Retour ligne automatique
====================………………..Retour ligne automatique
75 %Retour ligne automatique
==============================……….Retour ligne automatique
100 %Retour ligne automatique
========================================

u^KhxO_%#l » » »^ » »1″ » » : 49.29025926955508 : u^KhxO_%#l » » »d » »3″ » »

Cette optimisation du membre de droite nous permettait de faire la même chose pour le membre de gauche.

On a alors écrit une fonction utilisant notre fonction d’optimisation pour tester chaque caractères pour le membre de gauche en optimisant le score à chaque fois pour trouver le code parfait.

def chasseAuxPokemons(vitesse=1):
    # La vitesse 1 m'a prise 9h mais a bien fonctionnée
   
    lcp = ["!","!","!","!","!","!","!","!","!","!"]
    for l in range(vitesse+3):  
        for i in range(10):
            # On initialise tout
            global cc
            cons(lcp)
            scores = [0]
           
            for k in range(len(carac)):
                # On cree la liste de Pokemons avec les caractères
                lcp[i] = carac[k]
                cons(lcp)
                # On applique le booster de performances dessus (rapide et sans les barres de %)
                turboBoost(cc,1,0)
                # On recense les scores
                score = setst(cc)
                scores.append(score)
            # On prend le gagnant, c'est notre nouveau Pokemon
            lcp[i] = carac[scores.index(max(scores))-1]

Grace à cette fonction, on a pu obtenir le TOP résultat, le fameux 49,31730 :

code_h#^g0KuOS » » » » » » » »7u
Score49.31730339247606

On a donc envoyé des scores légèrement en dessous pour pouvoir nous qualifier dans les premiers.

Attaque n°10 : Force brute oui mais …

Nous avions exclus quelques caractères de cette force brute, on a donc réussi uniquement à obtenir le premier TOP résultat qui était déjà pris, le fameux 49,31730 mais pas au delà. Quand les premiers 49.319 et 49.32 ont commencé à sortir, nous avons compris que nous avions trop traîné, et qu’en intégrant d’autres caractères de la table ASCII nous aurions pu finir premier. Nous pensions que 49,31730 était le résultat optimal, nous n’avons pas testé davantage alors qu’on avait à priori la bonne méthode.

Mais notre échec relatif nous à gonflé à bloc pour le défi historique, que nous avons fait en python cela va de soit et sur PC car la mémoire de la NumWorks à la date d’octobre 2019 … enfin vous voyez de quoi on veut parler, sinon il suffit de lire ceci : Script qui refuse de s’exécuter sur la Numworks N0100 pour comprendre de quoi il retourne.

Conclusions

Nombres de tirages réalisés au total : entre 20 000 000 et 30 000 000 maximum.Retour ligne automatique
3 scripts tournaient au maximum en même temps, sur deux ordinateurs distincts.

L’année prochaine, il faudra compter sur nous ! Et cette fois-ci on commencera le défi le jour J et pas en retard. Pavel va devoir … heu non rien du tout, Pavel est très au dessus du niveau moyen. 😉

Nous remercions les organisateurs des sites tiplanet et planetcasio pour ce bon moment, cette recherche était passionnante, nous a réveillé la nuit (histoire de vérifier que les scripts tournaient bien) et maintenant les listes en python n’ont plus de secret pour nous.

Sur un autre sujet, nous supplions l’équipe de NumWorks d’augmenter la mémoire allouée aux scripts python sur la N0100 et la N0110. Ne pas pouvoir écrire un script de plus de 4ko est une absurdité !

Projets

Un générateur aléatoire de calcul mental en python pour…

Si les exercices répétitifs d’entrainement étaient tombés en disgrâce dans les précédents programmes scolaires, les nouveaux programmes de mathématiques les réintroduit, tout du moins en ce qui concerne les rituels de calcul mental en classe de seconde.

L’acquisition de ces réflexes est favorisée par la mise en place d’activités rituelles, notamment de calcul (mental ou réfléchi, numérique ou littéral). Elle est menée conjointement avec la résolution de problèmes motivants et substantiels, afin de stabiliser connaissances, méthodes et stratégies.

Extrait du programme de mathématiques, classe de seconde, 2019

Le script que nous avons conçu permet de pratiquer du calcul mental numérique, directement sur sa calculatrice, sans que les élèves n’aient la possibilité de tricher sur leur voisin et tout en proposant une correction personnalisée à chaque élève !

Un précédent script réalisé en mode texte

Un précédent script avait été codé en mode console, et il gérait un menu, lui aussi codé avec des print() et des input().

Fonctionnel, il manquait toutefois d’ergonomie, et le décalage du texte en temps réel dans le console pouvait perturber l’apprentissage.

Réécriture pour profiter de la couche graphique

Avec la sortie de la version 13.2.0 d’Espilon, le logiciel qui anime la NumWorks permet de disposer d’un tas python (heap) de 31ko et de fonctions natives tel que keydown() qui permet de récupérer le code de la touche pressée.

Une conception graphique minimaliste et intuitive a donc été pensée et codée pour sublimer ce générateur aléatoire de calculs.

Un script compatible avec notre menu graphique

En parallèle, nous avons développé Un menu en python pour les jeux sur la numworks et ce script exploite les possibilités de ce menu graphique.

RéglageOptions
ModeClassique , Rapide
Opération(s)+ , – , x , / , + – , x / , + – x , + – x /
Difficultéfacile, modéré, difficile, expert
Répétition20, 42, 50, 100, 120

Classique vs Rapide

Le mode classique interrompt le script et le chronomètre pour afficher si il y a une erreur, et indiquer quelle était la bonne réponse.

Le mode rapide est un mode d’entrainement intensif sans perturbation, que vous fassiez juste ou faux les calculs s’enchaînent et vous ne pourrez pas analyser vos erreurs.

Dans tous les cas, une fois la série de calcul terminée, un écran de synthèse résume le travail réalisé.

Quelques portions de code commentées

Le code qui génère le menu est documenté dans l’article associé : Un menu en python pour les jeux sur la numworks

Pour pouvoir être lu par notre script, la difficulté doit être représentée par un nombre.
Ainsi, on crée un code qui récupère un nombre en fonction de l’index de la première lettre dans un tableau.

["Difficulté", "  modéré", "difficile", "expert", "facile"],
dif = ["f", "m", "d", "e"].index(dif[0])

Ce dif sera un indice qui sera utilisé pour interroger la table de difficulté :

da = [1, 9]
db = [10, 19]
dc = [1, 10]
dd = [dc, [2, 10]]
diff = {"+": [[da] * 2, [db, da], [db, da], [db] * 2],
        "-": [[da] * 2, [db, da], [[10, 20], [10, 20]], [db] * 2],
        "*": [[dc] * 2, [dc] * 2, [[2, 10], [11, 20]], [[1, 25], [1, 25]]],
        "/": [dd, dd, dd, [[1, 20], [2, 20]]]}
def draw_line(x, y, clr, *ts) :

kandinsky ne dispose pas d’une fonction permettant de tracer des lignes. Or elle dispose d’une fonction qui allume un pixel d’une certaine couleur. Voici donc notre fonction pour tracer une ligne.

def draw_line(x, y, clr, *ts):
    for t in ts:
        d = list(map(lambda n: n // abs(n) if n != 0 else 0, t[0]))
        for i in range(t[1]):
            set_pixel(x + i * d[0], y + i * d[1], clr)
        x += i * d[0]
        y += i * d[1]

Quelques explications :
La fonction prend un couple (x,y) de départ, un couleur et des trajectoires (ts)

Ces trajectoires sont de la forme ([dx,dy],l)

d = list(map(lambda n: n // abs(n) if n != 0 else 0, t[0]))

Cette ligne permet d’obtenir une liste contenant uniquement des -1, 0, 1.

Améliorations possibles

Un mode d’apprentissage automatique si on dispose d’une mémoire de stockage permanente utilisable par python.

Un mode examen (Nécessite de « crypter » qq portions du code) : Le professeur génère un code unique, l’élève saisit ce code et fait une série aléatoire mais paramétré par le professeur. Un bon élève doué en programmation pourra toutefois bypasser le code et avoir tout juste sans rien faire !

Télécharger cette application

En l’état actuel, vous ne pouvez pas tester ce script directement depuis le workshop, car l’équipe de développement de la NumWorks n’a pas encore mappé les touches du clavier de l’ordinateur sur leur simulateur en ligne.

Quelques touches seulement sont actives sur le workshop, les 4 flèches, la touche Entrée et les touches Retour Arrière, Majuscule.

Ceci vous permet donc uniquement de tester le menu de cette application mais pour tester le générateur de calcul, il faudra charger le script sur la calculatrice.

Calculez bien !

Vous pouvez réagir à cet article sur le topic tiplanet.org de cette news : 
Snake, calcul mental, et interface lancement jeux Python

Quelques captures d’écrans

Projets

Convertisseur de texte en binaire ou héxadécimal

Ce projet est un convertisseur de texte en une écriture binaire ou bien hexadécimal. Une chaine de caractère est codée soit en binaire, soit en hexadécimal.

Présentation du programme

Le programme commence simplement par demander a l’utilisateur si il souhaite convertir son message en binaire ou en héxadécimal , pour cela nous avons utilisé une boucle en while :

def menu():
    print("Souhaitez vous transcrire votre message en binaire ou hexadécimal ?")
    print("1. binaire")
    print("2. hexadécimal")
    choix = 0
    while choix==0:
        choix = int(input("="))
    if choix==1 :
        fonction1()
    elif choix==2 :
        fonction2()
    else :
            menu()

Nous avons donc crée une fonction appelée menu() que nous avons définie. A l’intérieur le programme demande à l’utilisateur en quel langage il souhaite convertir son message et il lui montre les deux possibilités ( ici 1.binaire et 2.hexadécimal ) . On crée une valeur appelé choix qui représente le choix de langage de l’utilisateur , tant que cette valeur est égal a 0 le programme va demander à l’utilisateur de lui affectée une valeur. Alors si la valeur et égal à 1 le programme exécutera la fonction1() , si la valeur est égal a 2 le programme exécutera la fonction2() et si l’utilisateur ne rentre pas une de ces deux valeurs le programme lui affiche a nouveau la fonction menu() pour que l’utilisateur puisse relire les choix proposés rentrer une valeur reconnaissable par le programme.

Il faut ensuite demander à l’utilisateur le message qu’il souhaite convertir , mais il faut aussi découper son message caractères par caractères pour pouvoir ensuite convertir chaque caractères en son équivalent en binaire ou hexadécimal. Nous avons donc crée une fonction appelée split() (divise en anglais) :

def split(word):
    return list(word)
word = input(print("Faites-moi part de votre message secret :"))

La commande list découpe la valeur de word caractère par caractère et transforme le message on une liste de caractères. Et on demande à l’utilisateur de rentrer son message.

Retour ligne automatique

Après il ne nous reste plus qu’a définir les fonctions 1 et 2 :

def fonction2():
    print(hex(int.from_bytes(word.encode(), 'big'))[2:])
 
def fonction1():
    d = word.encode()
    for i in d:
        print(bin(i)[2:])

La fonction1() sert à convertir le message de l’utilisateur en binaire. On crée une valeur nommée d dans laquelle on code le message de l’utilisateur grâce à la commande .encode qui va convertir la valeur de word (donc convertir chaque caractère de la liste) en son équivalent se trouvant dans UNICODE (un système qui classes tous les caractères de toutes les langues répertoriées et qui leurs attribue une un code ). On affiche ensuite chaque caractères de d converti avec la commande bin qui converti un code UNICODE en binaire , et on rajoute [2 :] pour supprimer deux caractères écrit qui sont normalement utilisés pour dire en quel langage s’affiche la valeur converti par bin.

La fonction2 sert à convertir message de l’utilisateur en hexadécimal . On a utilisé ici une autre manière qui fonctionne de même que pour celle de la fonction1 , on code le message de l’utilisateur avec .encode , on luit demande de convertir cela en hexadécimal avec la commande hex , on lui dit de bien commencer par la début avec ’big’, et encore une fois on supprime les deux premiers caractères codés grâce à [2 :] .

Etat final du projet

def fonction2():
    print(hex(int.from_bytes(word.encode(), 'big'))[2:])
 
def fonction1():
    d = word.encode()
    for i in d:
        print(bin(i)[2:])
 
def split(word):
    return list(word)
word = input(print("Faites-moi part de votre message secret :"))
 
def menu():
    split(word)
    print("Souhaitez vous transcrire votre message en binaire ou hexadécimal ?")
    print("1. binaire")
    print("2. hexadécimal")
    choix = 0
    while choix==0:
        choix = int(input("="))
    if choix==1 :
        fonction1()
    elif choix==2 :
        fonction2()
    else :
            menu()
         
menu()

Conclusion

C’est un programme assez simple qui permet de comprendre comment utiliser des fonctions , ainsi que l’utilisation de certaines commandes utiles .

Projets

Un mini jeu sur les identités remarquables

Ce projet a pour but d’aider les élèves de seconde et de première à développer, à travers un mini-jeu, les identités remarquables qui sont : (a+b)²,(a-b)² et (a+b)(a-b). A travers ce jeu les élèves en difficulté pourrons développer les identités remarquables plus facilement et donc mieux les comprendre.

Les étapes du programme

Pour réaliser ce programme, nous avons fait ce que nous appelons un « menu ». C’est à dire la base de tout code où toutes les informations nécessaires sont marquées. 
On donne le choix parmi les identités remarquables qui existent et ensuite nous demandons à l’élève celle qu’il veut utiliser.

identité = ["(a+b)²", "(a-b)²", "(a+b)(a-b)"]
print("l'identité remarquable (a+b)² correspond à 0")
print("l'identité remarquable (a-b)² correspond à 1")
print("l'identité remarquable (a+b)(a-b) correspond à 2")
choix = int(input("la forme de ton identité remarquable est :"))

Apres cela nous lui demandons les valeurs de « a » et de « b ».

 a = int(input("a = "))
 b = int(input("b = "))

Nous lui posons donc l’identité remarquable avec les valeurs qu’il nous a donné et nous lui demandons de donner le résultat.

print("tu as choisie l'identité", identité[choix], )
    a = int(input("a = "))
    b = int(input("b = "))
    print("donc IR = (", a, "+", b, ")**2")
    c = (a+b)**2

Si elle est juste alors tout va bien et il peut terminer le programme.

if d == c :
        print("BRAVOOO, tu as réussis du premier coup")

Mais si son résultat est faux alors nous lui proposons de l’aide, en lui développant le calcule (ce qui aide beaucoup) ou bien nous lui donnant la réponse c’est lui qui choisi.

while c!=d :
                print("on a : a²+2*b*a+b²")
                print("alors : ", a**2, "+", 2*a*b, "+", b**2)
                d = int(input("ta réponse="))
                if c==d :
                    print("BRAVOOO!!! tu vois quand tu veux!!!")

Et voila le programme est fini (ou pas).

Pour avoir tout le programme et pouvoir l’utiliser il vous est possible de le télécharger car il est en pièce jointe.

les problèmes rencontrés

Pendant l’écriture du programme nous avons rencontré un certains nombres de problèmes.

Par exemple :

  • en enregistrant sur le drive la police des guillemet avait été modifier ce qui créa un problème sur le programme.
  • Et une fois nous avons eu un problème au niveau d’une boucle qui était infinie et qui ne laissait pas le temps à l’utilisateur de répondre à la question donnée. Mais nous avons résolue le problème en modifiant la boucle qui ne fonctionnait pas très bien.
Projets

Calcul de la quantité de matière, tableau périodique des…

Le tableau périodique des éléments, également appelé tableau de Mendeleïev, classification périodique des éléments ou simplement tableau périodique, représente tous les éléments chimiques, associés à un numéro atomique.
La conception de ce tableau est généralement attribuée au chimiste russe Dmitri Ivanovitch Mendeleïev, qui, en 1869, construisit une table, différente de celle qu’on utilise aujourd’hui mais semblable dans son principe.
On peut également lire sur ce tableau les masses molaires des éléments.

Présentation du projet

Les calculs de quantité de matière étant au programme de seconde et qui sont utilisé régulièrement en travaux pratique de physique-chimie durant les différentes année de lycée. Nous avons souhaité grâce à ce programme vous rendre la tâche plus facile pour calculer simplement des quantités de matière.
Vous pouvez également faire des recherche dans le tableau par exemple en cherchant le symbole d’un élément grâce à son numéro atomique.

Pour ce programme, il était nécessaire de commencer par faire 2 listes. Une première avec tous les symboles atomiques, rangés dans le bon ordres pour que leur place dans la liste soit la même que leur numéro atomique, sachant que dans une liste la première valeur est attribué à 0, nous avons donc mis une valeur nul. Par exemple l’aluminium à le numéro atomique 13, c’est la 14ème valeur de la liste mais attribué au nombre 13 : Magique ! Puis nous avons fait une seconde liste avec exactement le même principe mais cette fois-ci avec les masses molaires des élément à la place des symboles. Grâce à cette organisation, la 14ème valeur de la seconde liste est attribué à la masse molaire de l’aluminium.

# premiere liste pour les symboles des éléments
symbole = ["", "H", "He", "Li","Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg", "Al",  "Si", "P", "S", "Cl", "Ar",
           "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr",
           "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I", "Xe",
           "Cs", "Ba","La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu",
           "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po", "At", "Rn",
           "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md", "No", "Lr",
           "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg"]
 
# seconde liste pour les masse molaires
masseMol = [0, 1, 4, 7, 9, 11, 12, 14, 16, 19, 20, 23, 24, 27, 28, 31, 32, 35, 40,
            39, 40, 45, 48, 51, 52, 55, 56, 59, 59, 64, 65, 70, 73, 75, 79, 80, 84,
            85, 88, 89, 91, 93, 96, 98, 101, 103, 106, 108, 112, 115, 119, 122, 128, 127, 131,
            133, 137, 139, 140, 141, 144, 145, 150, 152, 157, 159, 162, 165, 167, 169, 173, 175,
            178, 181, 184, 186, 190, 192, 195, 197, 201, 204, 207, 209, 209, 210, 222,
            223, 226, 227, 232, 231, 238, 237, 244, 243, 247, 247, 251, 252, 257, 258, 259, 262,
            267, 268, 271, 272, 277, 276, 281, 280]


Nous avons ensuite créé plusieurs petits programmes qui effectues les différentes tâches possibles comme : chercher un symbole dans la liste grâce à son numéro atomique, chercher une masse molaire d’un élément grâce à son symbole puis deux calculs pour chercher une quantité de matière avec soit le symbole de l’élément soit son numéro atomique.

# premiere liste pour les symboles des éléments
symbole = ["", "H", "He", "Li","Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg", "Al",  "Si", "P", "S", "Cl", "Ar",
           "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr",
           "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I", "Xe",
           "Cs", "Ba","La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu",
           "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po", "At", "Rn",
           "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md", "No", "Lr",
           "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg"]
 
# seconde liste pour les masse molaires
masseMol = [0, 1, 4, 7, 9, 11, 12, 14, 16, 19, 20, 23, 24, 27, 28, 31, 32, 35, 40,
            39, 40, 45, 48, 51, 52, 55, 56, 59, 59, 64, 65, 70, 73, 75, 79, 80, 84,
            85, 88, 89, 91, 93, 96, 98, 101, 103, 106, 108, 112, 115, 119, 122, 128, 127, 131,
            133, 137, 139, 140, 141, 144, 145, 150, 152, 157, 159, 162, 165, 167, 169, 173, 175,
            178, 181, 184, 186, 190, 192, 195, 197, 201, 204, 207, 209, 209, 210, 222,
            223, 226, 227, 232, 231, 238, 237, 244, 243, 247, 247, 251, 252, 257, 258, 259, 262,
            267, 268, 271, 272, 277, 276, 281, 280]
Télécharger

Nous avons ensuite créé plusieurs petits programmes qui effectues les différentes tâches possibles comme : chercher un symbole dans la liste grâce à son numéro atomique, chercher une masse molaire d'un élément grâce à son symbole puis deux calculs pour chercher une quantité de matière avec soit le symbole de l'élément soit son numéro atomique.

# définition de chaque fonction pour le menu
 
def fonction1() : #permet de trouver le symbole d'un élément grâce à son numéro atomique
    numero = int(input("Entrez le numero atomique : "))
    print("Le symbole de l'élément est", symbole[numero],".")
 
def fonction2() : #permet de calculer une quantité de matière grâce au numéro atomique
    numero2 = int(input("Entrez le numero atomique : "))
    masse = int(input("Entrez la masse en gramme : "))
    mol = masse/masseMol[numero2]
    print("Il y a", mol,"mol.")
 
 
def fonction3() :  #permet de trouver une masse molaire grâce au symbole de l'élément
    symb1 = input("Entrez le symbole de l'élément:")
    i = 0  
    while i < 113 :
        if symbole[i] == symb1 :
            print("La masse molaire est", masseMol[i],"g.mol-1.")
            break
        i = i + 1
 
 
def fonction4() : #permet de calculer une quantité de matière grâce au symbole de l'élément
    masse2 = float(input("Entrez la masse en gramme : "))
    symb2 = input("Entrez le symbole de l'élément : ")
    i = 0  
    while i < 200 :
        if symbole[i] == symb2 :
            mol2 = masse2/masseMol[i]
            print("Il y a", mol2,"mol.")
            break
        i = i + 1

Comme vous pouvez le voir sur le graphique ci-dessus, le nombre de ligne importe peu sur la qualité d’un programme. Au final, c’est celui qui aura réussi à simplifier le plus son programme avec le moins de lignes qui aura utilisé le plus d’astuces !
Vous pouvez d’ailleurs constater que nous avons modifié le code à plusieurs reprises (3 en réalité) dans le but de le rendre plus court.

Conclusion

Ce programme est simple d’utilisation et peut être utilisé par n’importe quel élève de seconde général ou bien des élève de première et terminale ayant pris spécialité physique-chimie.
Malgré la facilité d’utiliser ce programme il ne peut bien évidemment pas remplacer l’apprentissage des formules mais peut tout de même s’avérer utiles.

Je le veux

Projets

Programme Python multi-fonction constitué d’un jeu, de calculs en…

Script qui permet de faire des conversions et des calculs en rapport avec une fonction. Il contient aussi un quiz.

Lors de l’execution du script, vous serez demandé d’introduire un identifiant et un mot de pass. Si celui-ci est correct, Le message « Bienvenue – Accès autorisé » s’affichera lettre par lettre. Sinon, un script tournera à l’infini spammera « alert intrusion ». Ce system est défini par la fonction « login ». Voici les données qu’il faut rentrer pour accéder au programme :


USERNAME : LJ
PASSWORD : NADIM

#Voici le systeme de login
def login():
    username="LJ"
    password="NADIM"
    print("Enter username : ")
    answer1=input()
    print("Enter password : ")
    answer2=input()
    #Si les données rentré sont correctes, le systeme execute le menu principal
    if answer1==username and answer2==password:
        bonjour="""Bienvenue - Accès autorisé
 
"""
        for char in bonjour:
            sys.stdout.write(char)
            time.sleep(0.2)
        menu1()
    #Si les données rentré sont fausses, le systeme spam un msg  
    else:
        i = 0
        while i < i + 1:
            print("alert intrusion")
 
            i = i + 1

Le script est constitué de 10 fonctions :

- Le login (Défini par : login ) Retour ligne manuel
- Le menu principal (Défini par : menu1Retour ligne manuel
- Le menu des fonctions (Défini par : menu2Retour ligne manuel
- La fonction qui demande deux points sur une droite (Défini par : demande_de_pointsRetour ligne manuel
- L’option 1 qui donne le coefficient directeur et là décris (Défini par : option_1Retour ligne manuel
- L’option 2 qui donne le milieu I (Défini par : option_2Retour ligne manuel
- L’option 3 qui donne la distance des deux points (Défini par : option_3Retour ligne manuel
- L’option 4 qui donne l’équation de la droite (Défini par : option_4Retour ligne manuel
- Le menu des conversions informatiques (Défini par : menu_conversions_informatiqueRetour ligne manuel
- Le quiz (Défini par : jeu)

Explication de chaque fonctions :

LE MENU PRINCIPAL : Il propose l’option de continuer vers le menu des fonctions, vers le menu des conversions informatique et vers le jeu ou de quitter le programme.

#Le menu principal est composé de 3 options de continuation et une option qui "éteint" le scripte
def menu1():
    print("""
 
{MAIN MENU}""")
    choice = input("""
A: Les fonctions
B: Les conversions informatiques
C: Jeu
D: Quitter
 
                     Veuillez entrer votre choix: """)
    if choice == "A" or choice =="a":
        demande_de_points()
    elif choice == "B" or choice =="b":
        menu_conversions_informatique()
    elif choice == "C" or choice =="c":
        jeu()
    elif choice=="D" or choice=="d":
        exit()
    else:
        print("VOUS NE DEVEZ QUE CHOISIR ENTRE A B C D!")
        print("Veuillez réessayer")
        menu1()

LA DEMANDE DE POINTS : Si vous choisissez de continuer vers le menu des fonctions, le nom de deux points et leurs coordonnées vous serons demander. Ces donnés seront utilisés pour l’option 1, 2, 3 et 4 du menu des fonctions.

#Cette fonction est executé avant que le menu des fonctions le soit. Il demande les coordonées de deux points sur une droite
def demande_de_points():
    global X1, X2, Y1, Y2, premier_point, deuxieme_point
    premier_point=input('Quel est le nom de ton premier point?')
    deuxieme_point=input('Quel est le nom de ton deuxieme point?')
    X1=int(input('Abscisse de '+ premier_point  +'= '))
    Y1=int(input('Ordonnée de '+ premier_point +'= '))
    X2=int(input('Abscisse de '+ deuxieme_point  +'= '))
    Y2=int(input('Ordonnée de '+ deuxieme_point +'= '))
    menu2()

LE MENU DES FONCTIONS : Il propose le coef directeur et la direction de la droite, de donner le milieu I des deux points, de donner leur distance et de calculer l’équation de la droite.

#Voici le menu des fonctions qui effectue des calculs en rapport avec la fonction affine
def menu2():
    print("""
 
{MENU DES FONCTIONS}""")
    choice = input("""
A: Coef directeur et direction
B: Milieu I
C: Distance deux points
D: Equation de droite
E: Retour
 
Veuillez entrer votre choix: """)
 
    if choice == "A" or choice =="a":
        option_1()
    elif choice == "B" or choice =="b":
        option_2()
    elif choice == "C" or choice =="c":
        option_3()
    elif choice=="D" or choice=="d":
        option_4()
    elif choice=="E" or choice=="e":
        menu1()
    else:
        print("VOUS NE DEVEZ QUE CHOISIR ENTRE A B C D E!")
        print("Veuillez réessayer")
        menu2()

L’OPTION 1 : Elle calcule le coefficient directeur avec les variables globals X1, X2, Y1, Y2 et là décris, meme si elle est parallel à l’axe des abscisses (Si X1=X2).

#1ere option du menu des fonctions. Il calcul le coefficient directeur et nous décris son sens
def option_1():
    global X1, X2, Y1, Y2    
    if X1==X2:
        print("La courbe est parallèle à l'axe des ordonnées")
        time.sleep(3)
    elif Y1==Y2:
        print("La courbe est parallèle à l'axe des abscisses")
        time.sleep(3)
    else:
        coef_1=(Y2-Y1)
        coef_2=(X2-X1)
        coefficient_directeur=Fraction(coef_1,coef_2)
        print('Le coefficient directeur est', coefficient_directeur)
   
        if coefficient_directeur<0:
            print('La courbe est strictement décroissante')
            time.sleep(3)
       
        elif coefficient_directeur>0:
            print('La courbe est strictement croissante')
            time.sleep(3)
   
    menu2()

L’OPTION 2 : Elle calcule les coordonnées de I ((X1+X2)/2 ;(Y1+Y2)/2)

#2ieme option du menu des fonctions. Il calcul le milieu I des deux points sur la droite
def option_2():
    global X1, X2, Y1, Y2, premier_point, deuxieme_point
    milieu_coor1=(X1+X2)/2
    milieu_coor2=(Y1+Y2)/2
    print("""
 
""""Les coordonées de I sont ","(",milieu_coor1,";",milieu_coor2,")")
    time.sleep(3)
    menu2()

L’OPTION 3 : Elle calcule la distance des points avec « sqrt » importé de « math ». Soit sqrt((X2-X1)**2+(Y2-Y1)**2))

#3ieme option du menu des fonctions. Il calcul la distance de deux points
def option_3():
    global X1, X2, Y1, Y2, premier_point, deuxieme_point
    from math import sqrt
    distance_de_deux_points=print(str(premier_point),str(deuxieme_point),"=",sqrt((X2-X1)**2+(Y2-Y1)**2))
    time.sleep(3)
    menu2()

L’OPTION 4 : Elle calcule l’équation de la fonction grace aux coordonnées demandés.

#4ieme option du menu des fonctions. Il calcul l'équation de droite
def option_4():
    global X1, X2, Y1, Y2, premier_point, deuxieme_point
    if X1==X2 or (Y2-Y1)/(X2-X1)==0:
        print("f(x)=",Y1 )
        time.sleep(3)
        menu2()
    else:
        m=int(((Y2-Y1)/(X2-X1)))
        p=(m*X1-Y1)*(-1)
        print("f(x)=",m,'x+',p)
        time.sleep(3)
        menu2()

LE MENU DES CONVERSIONS INFORMATIQUE : Il peut passer les nombres décimaux vers l’octal, le décimal, le binaire et pass le binaire vers le décimal sur 1 octet. Nous avons décider de ne faire q’une seul fonction pour cette catégorie.

#Voici le menu des conversions_informatiques qui effectue des calculs en rapport avec: Le decimal, le binaire, l'hexadecimal, l'octal
def menu_conversions_informatique():
    print("""
 
{Les conversions_informatiques}""")
    choice = input("""
A: Decimal vers octal
B: Decimal vers binaire
C: Decimal vers hexadecimal
D: Binaire vers decimal sur 8 bits
E: Retour
 
Veuillez entrer votre choix: """)
 
    if choice == "A" or choice =="a":
        nombre_decimal=int(input('Votre nombre en base 2?'))
        print(nombre_decimal,"en base 8 est", oct(nombre_decimal))
        time.sleep(3)
       
    elif choice == "B" or choice =="b":
        nombre_decimal=int(input('Votre nombre en base 2?'))
        print(nombre_decimal,"en base 10 est", bin(nombre_decimal))
        time.sleep(3)
       
    elif choice == "C" or choice =="c":
        nombre_decimal=int(input('Votre nombre en base 2?'))
        print(nombre_decimal,"en base 16 est", hex(nombre_decimal))
        time.sleep(3)
       
    elif choice == "D" or choice =="d":
        print("Ce programme marche seulement avec 8 bits")
        binaire=input("Quel sont les 8 bits de votre nombre binaire?")
        print("""
""")
        if len(binaire)!=8:
            print("Donnez les 8 bits de votre nombre SVP")
            time.sleep(1.5)
            menu_conversions_informatique()
           
        else:
            bit_1=int(binaire[0])*2**0
            bit_2=int(binaire[1])*2**1
            bit_3=int(binaire[2])*2**2
            bit_4=int(binaire[3])*2**3
            bit_5=int(binaire[4])*2**4
            bit_6=int(binaire[5])*2**5
            bit_7=int(binaire[6])*2**6
            bit_8=int(binaire[7])*2**7
           
            print("Votre nombre décimal est ",(bit_1 + bit_2 + bit_3 + bit_4 + bit_5 + bit_6 + bit_7 + bit_8))
           
        time.sleep(3)
    elif choice == "E" or "e":
        menu1()
       
    else:
        print("VOUS NE DEVEZ QUE CHOISIR ENTRE A B C D E!")
        print("Veuillez réessayer")
        menu1()

LE QUIZ : Il comporte 8 questions et calcule ton score en pourcentage. Il fait 46% du script.

#Voici un quiz qui calcul ton score
def jeu():
    score=0
    print("Voici le quiz")
    time.sleep(2)
 
 
    rep_1=input("""En quelle année le premier jeu vidéo a-t-il été créé ?
A: En 1856
B: En 1962
C: En 2005
""")
    if rep_1=="B" or rep_1=="b":
        print("BRAVO")
        score=score+1
        print("score=", score)
        time.sleep(1.5)
    elif rep_1=="A" or rep_1=="a" or rep_1=="C" or rep_1=="c":
        print("FAUX")
        print("score=", score)
        time.sleep(1.5)
    else:
        print("""
Il fallait choisir entre A, B ou C
""")
   
    rep_2=""
    rep_2=input("""Quelle année voit l'invention de la "Game Boy" ?
A: En 1969
B: En 1979
C: En 1989
""")
    if rep_2=="C" or rep_2=="c":
        print("BRAVO")
        score=score+1
        print("score=", score)
        time.sleep(1.5)
    elif rep_2=="B" or rep_2=="b" or rep_2=="A" or rep_2=="a":
        print("FAUX")
        print("score=", score)
        time.sleep(1.5)
    else:
        print("""
Il fallait choisir entre A, B ou C
""")
   
    rep_3=""
    rep_3=input("""Quand es-que la DS est sortis?
A: En 2002
B: En 2005
C: En 2008
""")
    if rep_3=="B" or rep_3=="b":
        print("BRAVO")
        score=score+1
        print("score=", score)
        time.sleep(1.5)
    elif rep_3=="A" or rep_3=="a" or rep_3=="C" or rep_3=="c":
        print("FAUX")
        print("score=", score)
        time.sleep(1.5)
    else:
        print("""
Il fallait choisir entre A, B ou C
""")
   
    rep_4=""
    rep_4=input("""Quelle était la nationalité de Ralph Baer ?
A: Anglaise
B: Allemande
C: Italienne
""")
    if rep_4=="B" or rep_4=="b":
        print("BRAVO")
        score=score+1
        print("score=", score)
        time.sleep(1.5)
    elif rep_4=="A" or rep_4=="a" or rep_4=="C" or rep_4=="c":
        print("FAUX")
        print("score=", score)
        time.sleep(1.5)
    else:
        print("""
Il fallait choisir entre A, B ou C
""")
   
    rep_5=""
    rep_5=input("""D'où vient "Nintendo" ?
A: Du Japon
B: De la Chine
C: D'Europe
""")
 
    if rep_5=="A" or rep_5=="a":
        print("BRAVO")
        score=score+1
        print("score=", score)
        time.sleep(1.5)
    elif rep_5=="B" or rep_5=="b" or rep_5=="C" or rep_5=="c":
        print("FAUX")
        print("score=", score)
        time.sleep(1.5)
    else:
        print("""
Il fallait choisir entre A, B ou C
""")
       
    rep_6=""
    rep_6=input("""En écriture binaire on utilise les symboles:
A: 0 et 1
B: -1 et 1
C: 1 et 2
""")
 
    if rep_6=="A" or rep_6=="a":
        print("BRAVO")
        score=score+1
        print("score=", score)
        time.sleep(1.5)
    elif rep_6=="B" or rep_6=="b" or rep_6=="C" or rep_6=="c":
        print("FAUX")
        print("score=", score)
        time.sleep(1.5)
    else:
        print("""
Il fallait choisir entre A, B ou C
""")
 
    rep_7=""
    rep_7=input("""Un groupement de 8 bits s'appelle:
A: Une brochette
B: Un quintet
C: Un octet
""")
 
    if rep_7=="C" or rep_7=="c":
        print("BRAVO")
        score=score+1
        print("score=", score)
        time.sleep(1.5)
    elif rep_7=="A" or rep_7=="a" or rep_7=="B" or rep_7=="b":
        print("FAUX")
        print("score=", score)
        time.sleep(1.5)
    else:
        print("""
Il fallait choisir entre A, B ou C
""")
       
    rep_8=""
    rep_8=input("""On peut coder sur un octet:
A: 256 valeurs différentes
B: 255 valeurs différentes
C: 356 valeurs différentes
""")
 
    if rep_8=="B" or rep_8=="b":
        print("BRAVO")
        score=score+1
        print("score=", score)
        time.sleep(1.5)
    elif rep_8=="A" or rep_8=="a" or rep_8=="C" or rep_8=="c":
        print("FAUX")
        print("score=", score)
        time.sleep(1.5)
    else:
        print("""
Il fallait choisir entre A, B ou C
""")
       
       
    pourcentage=(100*score/8)
    print("Tu as eu",pourcentage,"% de bonnes réponses")
    if pourcentage==100:
        print("BRAVO! Un score parfait")
   
    elif pourcentage==0:
        print("Tu doit mieux faire")
 
    elif 0<pourcentage<=20:
        print("C'est bof bof")
 
    elif 20<pourcentage<=50:
        print("Tu peux faire mieux")
   
    elif 50<pourcentage<=80:
        print("C'est bien")
 
    elif 80<pourcentage<100:
        print("Avec un peu d'effort tu arriveras au 100%")
       
    time.sleep(3)
    menu1()

Certaine fonctions contiennent des moyens d’ »anti-bug », c’est à dire si l’utilisateur rentre une donnée fausse il serait prévenu pour qu’aucune erreur s’affiche.

Pour ce servir de certaine fonctions, comme sys.stdout.write(), time.sleep() ou Fraction(). Nous avons importer les modules suivants :

import sys
import time
from fractions import *

A la fin du programme, nous avons du mettre :

login()
menu1()
menu2()
demande_de_points()
option_1()
option_2()
option_3()
option_4()
menu_conversions_informatique()
jeu()

Afin de d’exécuter chaque fonctions.

Télécharger le programme :

Projets

Le jeu du pendu en Python

Le Pendu est un jeu consistant à trouver un mot en devinant quelles sont les lettres qui le composent. Dans cet article, nous allons analyser ensemble un jeu du Pendu, fait en Python. Contrairement aux apparences, ce programme peut être très dur a réaliser, surtout pour les non-initiés.

L’article comme le code produit ci-dessous sont largement améliorable. Ce jeu inclus quelques petits bugs non résolus.

Introduction

Tout d’abord, qu’est ce qu’on attend d’un jeu du Pendu, en Python :

  • L’ordinateur choisit un mot au hasard dans une liste, un mot de huit lettres maximum. – Le joueur tente de trouver les lettres composant le mot.
  • À chaque coup, il saisit une lettre.
  • Si la lettre figure dans le mot, l’ordinateur affiche le mot avec les lettres déjà trouvées. -Celles qui ne le sont pas encore sont remplacées par des barres (_).
  • Le joueur a 6 chances. Au delà, il a perdu.

Le début du code

 print("Bienvenue dans le jeu du Pendu")
play=int(input("Tape 1 si tu veux jouer ! \n "))
if play == 1 :  
    prénom=input("Quel est ton nom ?")
    print("\n")
    print("Salut", prénom)
    import random
    liste_mots=["laitue", "hareng", "jambon", "pharynx", "phoque", "langue",
                "stylo","agent","fromage","whisky","billet","boyaux",
                "laser","joystick","crane","joyeux","cahier","camping","argent",
                "rivage","physique",]

Dans cette première partie de code, il ne faut SURTOUT pas oublier le import random, car on utilise beaucoup d’aléatoire dans ce petit jeu.
Sinon, par grand chose d’important a relever, a part la liste de mot que le jeu va utiliser pour le jeu.

Initialisations

 score = 0
    print("Tu as 6 vies")
    print("\n")
    vie = 6

La non plus, c’est pas super intéressant…
On définit juste les variables des vies et du score

while play == 1 :
        vie = 6
        mot=(liste_mots[random.randint(0,21)])
        longueur=len(mot)
        barre=["_ "]
        barre=barre*longueur
        grandeur=longueur

Attention : Ça se corse…
Avec la ligne « mot=(liste_mots[random.randint(0,21)]) », le programme choisi un mot au hasard dans la liste de mots du début.

Dans le jeu du Pendu, les lettres qui n’ont pas été trouvés sont remplacées par des barres (_), et c’est ce qu’on règle cette portion :
longueur=len(mot) calcule le nombre de lettres du mot choisi, puis barre=barre*longueur affiche le nombre de « _ » en fonction du nombre de lettres.
On l’affiche sous forme de liste, car ce sera beaucoup plus facile pour la suite du programme.
La variable « grandeur » est la même que « longueur », sauf que « grandeur » va (aussi) servir pour la suite du programme

Le jeu

  while vie!=0 and grandeur!=0 :
            lettre_choisi = input("Choisi une lettre  ")
            print("\n")
            if lettre_choisi in mot :
                print("Bravo!")
                if lettre_choisi in barre:
                    print ("Tu l'as déja dit !")
                    resultat = ' '.join(barre)
                    print(resultat)
                else:
                    position=int(mot.index(lettre_choisi))
                    barre.pop(position)
                    barre.insert(position,lettre_choisi)
                    resultat = ' '.join(barre)
                    print(resultat)
                    grandeur=grandeur-1

Tiens tiens, on retrouve « grandeur » !
En fait, grandeur sert a dire au programme quand le joueur a trouvé toute les lettres, car si le mot fait par exemple 7 lettres, on pourra logiquement trouver la bonne lettre 7 fois.
Ensuite, le programme nous demande de choisir une lettre (désolé pour la faute d’orthographe « lettre_choisi » ), et si la lettre est dans le mot, alors le programme continue.

Voila la principale difficulté du programme :L’affichage du mot
En effet, il faut afficher le mot avec toutes les lettres qu’on a trouvées.
Tout d’abord, on repére la position de la lettre trouvée avec « position=int(mot.index(lettre_choisi)) », puis on insère la lettre choisie dans la liste « barre » (_ _ _ _ _ _ _) a la bonne position. On supprime aussi une (_) pour que le mot reste a la bonne longueur avec « barre.pop(position) ».
Enfin, on transforme la liste en chaîne de caractère pour que l’affichage soit plus clair, pour finir dans la variable « résultat »

Avant de continuer, je voudrai vous montrer ce qui se passe si on met une lettre qu’on a déjà mise :
C’est exactement comme auparavant, sauf que grandeur ne diminue pas, et qu’il n’y a pas besoin d’afficher une lettre de plus, car elle a déjà été affichée

Trouver toutes ces formules m’ont causé BEAUCOUP de problèmes, donc j’espère que ce sera clair pour vous.

Sinon, si la lettre choisie n’est pas dans le mot, alors :

            else:
                print("Raté")
                if grandeur==longueur :
                    print(longueur*"_ ")
                else:
                    print (resultat)
                vie=vie-1
                print("Il te reste",vie,"vies")
                print("\n")

Sur cette partie, si le joueur se trompe des la première lettre, le programme ne peut pas afficher la variable « résultat », car elle n’existe pas encore. Le programme affiche donc seulement le mot sous forme de barre (_). Dans tout les cas, une vie est retirée.

La fin du jeu

   if vie==0 :
            print("Tu as perdu")
        elif grandeur==0 :
            print("Bravo ! Tu as trouvé le mot !")
            score=score+5
            print("Tu a gagné 5 points !")
        replay=int(input("Tape 1 pour rejouer, et sur 2 si tu veux quitter le jeu   "))
        if replay != 1 :
            break
    print(prénom,"vous avez un score de ",score)

Evidemment, si vos vies tombent à 0, vous perdez.
Si vous gagnez, vous gagnez 5 points. A 50 points vous avez une surprise….
Vous pouvez rejouer en tapant 1, et vous quittez le programme en tapant 2

Voila, j’espère vous avoir aidés a comprendre ce petit programme !
N’hésitez pas a le personnaliser, avec vos propres fonctions, ou avec quelques easters eggs sympathiques !

Le code entier est téléchargeable en bas de la page !