Étiquette : Calcul

Projets

Jeux de Calcul Mental chronométré en python

Êtes-vous bon en calcul mental ? Ce script en python vous propose de tester vos capacités à travers différents niveaux de difficulté, et tout cela chronométré !

Objectif

L’objectif de ce projet est de tester mes capacités en python et de mobiliser les notions vues en python en spécialité NSI (and, or, not, …etc). De plus, cela à pour but de proposer un outil pour s’entraîner au calcul mental. Je pense aussi l’adapter plus tard pour la calculatrice Numworks, ce qui donnera la possibilité d’y jouer dessus.

Projet

Le choix du langage pour ce projet est assez simple : python. C’est un langage assez simple à maitriser et adapté pour l’idée de mon jeux. Il propose aussi des bibliothèques assez intéressantes pour sa réalisation notamment time et random.

Analyse du code

Analysons le code.

Dans un premier temps on importe différentes bibliothèques qui vont nous être utilise. Nous utilisons la bibliothèque random pour générer des valeurs aléatoires pour diversifier les calculs ainsi que le module time.

import math
from random import *
from time import time
from art import text2art

operateurs1 = ["+","-"]
operateurs2 = ["+","-","x"]])

Subséquemment, vous pouvez aussi voir une bibliothèque art avec le module text2art qui nous sert à convertir du texte en ascii art et donc à sublimer par exemple le menu.

La première liste sert uniquement au niveau 1 qui est censé être le plus simple, on se limite donc à des additions/soustractions tandis que la deuxième liste est destinée au niveaux 2 et 3.

Passons maintenant au menu.

def menu(): # Interface du début
    titre1 = text2art("NSI : Calcul \t mental") # Titre en ascii art
    print(titre1)
    
    print("Il y a 3 niveaux:") # Présente les différents niveaux 
    print("1-Niveau facile")
    print("2-Niveau intermédiaire") 
    print("3-Niveau difficile")
    
    choix = int(input("\nAlors, qu'allez vous choisir :\n"))
    
    while choix not in [1, 2, 3]:  # Empêche toutes valeurs autre que 1, 2 ou 3
        input("Veuillez choisir un chiffre :\n")
    
    if choix == 1: # Renvoie au niveau choisie
        niveau1()
        
    if choix == 2:
        niveau2()
        
    if choix == 3:
        niveau3()

menu()

On commence par présenter les différents niveaux avec des print() et aussi un titre en ascii art grâce au module text2art(). Vous allez voir que tout au long du code que nous allons utiliser des input() qui permettent à l’utilisateur de rentrer des valeurs ou une chaîne de caractère.

Ici, la boucle à la ligne 12 est nécessaire pour que l’utilisateur entre quelque chose de valable, la logique est simple : tant que qu’il n’a pas rentrer une valeur valable on réitère la question et dès lors qu’il tapera 1,2 ou 3 le script pourra continuer.

Enfin, on ajoute des conditions avec if pour le rediriger le joueur sur le niveau choisi. Passons maintenant à la structure d’un niveau.

def niveau2(): # Deuxième niveau
    score = 0
    compteur =  0
    while compteur < 10:
        indice_aleatoire = randint(0,len(operateurs1)-1)
        generation1 = randint(2,4)
        generation2 = randint(11,42)
        generation3 = randint(300,600)
        generation4 = randint(384,666)  # Plus de génération car on ajoute des multiplications
        
        if indice_aleatoire == 2:
            print("\nPeux tu calculer", str(generation1), operateurs1[indice_aleatoire], str(generation2), "? Tu as 7 secondes.")
        else:
            print("\nPeux tu calculer", str(generation4), operateurs1[indice_aleatoire], str(generation3), "? Tu as 7 secondes.")
        
        depart_temps = time() # Calcule le temps
        rep = int(input("\nMa réponse : "))
        
        fin_temps = time()-depart_temps

Nous allons ici prendre pour exemple le niveau 2 (intermédiaire), mais les autres niveaux ne sont pas si différents que ça. On va diviser le niveau en 3 parties :

  • La génération du calcul et la réponse de l’utilisateur
  • La correction de la réponse
  • Félicite le joueur en fonction de son score

Dans un premier temps, on commence par initialiser le score et le compteur qui correspond au nombre de question, donc ici 12 questions. Le compteur s’incrémente à chaque fin de question d’où l’utilisation de while.

On génère ensuite un indice aléatoire pour choisir entre tous les opérateurs et des nombres pour les calculs. Si cela tombe sur une multiplication on va multiplier des nombres par des petites valeurs (entre 2 et 4), sinon on fait l’addition ou soustraction de deux nombres entre environ 300 à 600.

Enfin, on lance le chrono avec le module time(), on demande alors la réponse et on arrête le chrono pour savoir le temps passé.

if operateurs2[indice_aleatoire] == "+": # Détermine l'opérateur pour la correction
    resultat = generation4 + generation3
elif operateurs2[indice_aleatoire] == "-":
    resultat = generation4 - generation3
elif operateurs2[indice_aleatoire] == "x":
    resultat = generation1 * generation2
else:
    resultat = None
        
if resultat is not None and resultat == rep and fin_temps <=7: # Correction en fonction du résultat et du temps mis
    print("Bravo, tu as donné la bonne réponse dans le temps imparti. Ton temps:", fin_temps)
    score += 1
elif resultat is not None and resultat == rep and fin_temps > 7:
    print("Tu as donné la bonne réponse mais pas dans le temps imparti. Ton temps:", fin_temps)
            
else:
    print("\nAh...apparemment tu t'es trompé, réessaye !")
    
suite = input("\nPrêt pout ma suite ? o/n\n")  # Demande si l'utilisateur est prêt
if suite.lower() != "o":
    break
compteur += 1

Dans un deuxième temps, on détermine l’opérateur pour effectuer la correction avec la réponse de l’utilisateur. Il y a 3 cas possibles :

  • La réponse est correcte et a été donnée dans le temps imparti (dans ce cas la le score s’incrémente)
  • La réponse est correcte mais n’a pas été donnée dans le temps imparti
  • La réponse est incorrecte et n’a pas été donnée dans le temps imparti

Ensuite, on demande si l’utilisateur est prêt pour passer à la suite. Ici, on utilise la méthode .lower() qui permet d’éviter que le script plante si l’utilisateur a mis un « o » ou un « n » en majuscule.

Puis on incrémente le compteur comme nous l’avons expliqué précédemment.

if score > 4:
    print("\nBravo tu as répondu à tous les calculs et tu a au moins la moyenne, ton  score est de", score) # Donne le score et félicite le joueur
    gg = text2art("gg")
    print(gg)
else:
    print("\nTon score est de", score,", ce n'est pas fameux ! Je te conseille d'acheter ma formation pour seulemment 773€/mois") # Peut être que je vais la prendre cette formation finalement

Dans un troisième temps, à la fin de toutes les questions, on obtient plusieurs grades de félicitation en fonction du score du joueur.

On retrouve aussi l’utilisation tu module text2art() qui permet de dire bien joué.

Conclusion

Le projet était assez plaisant à faire et il a permis de tester mes capacités en python tout en mobilisant des notions vues en spé NSI notamment not, and, or, les boucles, …etc. Ce script peut aussi être adapté sur la numworks dans l’avenir, ce qui peut être sympa.

Télécharger le script

Projets

Convertisseur de distances

Ce projet a été réalisé par des élèves en spécialité NSI du Lycée Louis Pasteur. Ils sont également les auteurs de ce compte rendu. Pour en savoir plus : Les projets en spécialité NSI

Présentation

Ce projet a été réaliser par Chausi Ursuegui T. et Cymbler N. en classe de première G3 dans le cadre de leur enseignement de spécialité NSI (numérique et sciences de l’informatique), au lycée Louis Pasteur à Avignon .
Avec comme matériel un ordinateur équipé du logiciel Thonny.

Descriptif du projet

Ce projet est un programme écrit en Python qui sert dans plusieurs domaine à convertir n’importe quelle distance allant du Pico mètre jusqu’au Téra mètre. Nous avons décider de faire ce programme car de nombreux étudiants de tout âge rencontre ce problème particulièrement en physique chimie .

Notre programme

d = int(input("Indiquez la distance: "))
print("pm / nm / µm / mm / cm / dm / m / dam / km / hm / M / G / T")
u_d = input("Indiquez l'unité de départ: ")
print("pm / nm / µm / mm / cm / dm / m / dam / km / hm / M / G / T")
 
if u_d =="Tm":
    d_Tm = d
    d_Gm = d * 1000
    d_Mm = d *1000000
    d_km = d * 1000000000
    d_hm = d * 10000000000
    d_dam = d * 100000000000
    d_m = d * 1000000000000
    d_dm = d * 10000000000000
    d_cm = d * 100000000000000
    d_mm = d * 1000000000000000
    d_µm = d * 1000000000000000000
    d_nm = d * 1000000000000000000000
    d_pm = d * 1000000000000000000000000
 
if u_d =="Gm":
    d_Tm = d / 1000
    d_Gm = d
    d_Mm = d * 1000
    d_km = d * 1000000
    d_hm = d * 10000000
    d_dam = d * 100000000
    d_m = d * 1000000000
    d_dm = d * 10000000000
    d_cm = d * 100000000000
    d_mm = d * 1000000000000
    d_µm = d * 1000000000000000
    d_nm = d * 1000000000000000000
    d_pm = d * 1000000000000000000000
 
if u_d =="Mm":
    d_Tm = d / 1000000
    d_Gm = d / 1000
    d_Mm = d
    d_km = d * 1000
    d_hm = d * 10000
    d_dam = d * 100000
    d_m = d * 1000000
    d_dm = d * 10000000
    d_cm = d * 100000000
    d_mm = d * 1000000000
    d_µm = d * 1000000000000
    d_nm = d * 1000000000000000
    d_pm = d * 1000000000000000000
 
if u_d =="km":
    d_Tm = d / 1000000000
    d_Gm = d / 1000000
    d_Mm = d / 1000
    d_km = d
    d_hm = d * 10
    d_dam = d * 100
    d_m = d * 1000
    d_dm = d * 10000
    d_cm = d * 100000
    d_mm = d * 1000000
    d_µm = d * 1000000000
    d_nm = d * 1000000000000
    d_pm = d * 1000000000000000
 
if u_d =="hm":
    d_Tm = d / 10000000000
    d_Gm = d / 10000000
    d_Mm = d / 10000
    d_km = d / 10
    d_hm = d
    d_dam = d * 10
    d_m = d * 100
    d_dm = d * 1000
    d_cm = d * 10000
    d_mm = d * 100000
    d_µm = d * 100000000
    d_nm = d * 100000000000
    d_pm = d * 100000000000000
 
if u_d =="dam":
    d_Tm = d / 100000000000
    d_Gm = d / 100000000
    d_Mm = d / 100000
    d_km = d / 100
    d_hm = d / 10
    d_dam = d
    d_m = d * 10
    d_dm = d * 100
    d_cm = d * 1000
    d_mm = d * 10000
    d_µm = d * 10000000
    d_nm = d * 10000000000
    d_pm = d * 10000000000000
 
if u_d =="m":
    d_Tm = d / 1000000000000
    d_Gm = d / 1000000000
    d_Mm = d / 1000000
    d_km = d / 1000
    d_hm = d / 100
    d_dam = d / 10
    d_m = d
    d_dm = d * 10
    d_cm = d * 100
    d_mm = d * 1000
    d_µm = d * 1000000
    d_nm = d * 1000000000
    d_pm = d * 1000000000000
 
if u_d =="dm":
    d_Tm = d / 10000000000000
    d_Gm = d / 10000000000
    d_Mm = d / 10000000
    d_km = d / 10000
    d_hm = d / 1000
    d_dam = d / 100
    d_m = d / 10
    d_dm = d
    d_cm = d * 10
    d_mm = d * 100
    d_µm = d * 100000
    d_nm = d * 100000000
    d_pm = d * 100000000000
 
if u_d =="cm":
    d_Tm = d / 100000000000000
    d_Gm = d / 100000000000
    d_Mm = d / 100000000
    d_km = d / 100000
    d_hm = d / 10000
    d_dam = d / 1000
    d_m = d / 100
    d_dm = d / 10
    d_cm = d
    d_mm = d * 10
    d_µm = d * 10000
    d_nm = d * 10000000
    d_pm = d * 10000000000
 
if u_d =="mm":
    d_Tm = d / 1000000000000000
    d_Gm = d / 1000000000000
    d_Mm = d / 1000000000
    d_km = d / 1000000
    d_hm = d / 100000
    d_dam = d / 10000
    d_m = d / 1000
    d_dm = d / 100
    d_cm = d / 10
    d_mm = d
    d_µm = d * 1000
    d_nm = d * 1000000
    d_pm = d * 1000000000
 
if u_d =="µm":
    d_Tm = d / 1000000000000000000
    d_Gm = d / 1000000000000000
    d_Mm = d / 1000000000000
    d_km = d / 1000000000
    d_hm = d / 100000000
    d_dam = d / 10000000
    d_m = d / 1000000
    d_dm = d / 100000
    d_cm = d / 10000
    d_mm = d / 1000
    d_µm = d
    d_nm = d * 1000
    d_pm = d * 1000000
 
if u_d =="nm":
    d_Tm = d / 1000000000000000000000
    d_Gm = d / 1000000000000000000
    d_Mm = d / 1000000000000000
    d_km = d / 1000000000000
    d_hm = d / 100000000000
    d_dam = d / 10000000000
    d_m = d / 1000000000
    d_dm = d / 100000000
    d_cm = d / 10000000
    d_mm = d / 1000000
    d_µm = d / 1000
    d_nm = d
    d_pm = d * 1000
 
if u_d =="pm":
    d_Tm = d / 1000000000000000000000000
    d_Gm = d / 1000000000000000000000
    d_Mm = d / 1000000000000000000
    d_km = d / 1000000000000000
    d_hm = d / 100000000000000
    d_dam = d / 10000000000000
    d_m = d / 1000000000000
    d_dm = d / 100000000000
    d_cm = d / 10000000000
    d_mm = d / 1000000000
    d_µm = d / 1000000
    d_nm = d / 1000
    d_pm = d
 
u_a = input("Indiquez l'unité d'arrivée: ")
 
if u_a=="Tm":
    print("La distance en Tm est %.2f Tm." % d_Tm)
 
if u_a=="Gm":
    print("La distance en Gm est %.2f Gm." % d_Gm)
 
if u_a=="Mm":
    print("La distance en Mm est %.2f Mm." % d_Mm)
 
if u_a=="km":
    print("La distance en km est %.2f km." % d_km)
 
if u_a=="hm":
    print("La distance en hm est %.2f hm." % d_hm)
 
if u_a=="dam":
    print("La distance en dam est %.2f dam." % d_dam)
 
if u_a=="m":
    print("La distance en m est %.2f m." % d_m)
 
if u_a=="dm":
    print("La distance en dm est %.2f dm." % d_dm)
 
if u_a=="cm":
    print("La distance en cm est %.2f cm." % d_cm)
 
if u_a=="mm":
    print("La distance en mm est %.2f mm." % d_mm)
 
if u_a=="µm":
    print("La distance en µm est %.2f µm." % d_µm)
 
if u_a=="nm":
    print("La distance en nm est %.2f nm." % d_nm)
 
if u_a=="pm":
    print("La distance en pm est %.2f pm." % d_pm)

Description du programme

Voici la première version de notre programme alors nous avons détailler les calcul pour chaque conversions (de m en mm , de km en hm …)et nous avons a la fin écrit une phrases de réponse pour touts les résultats en donnant l’unité donné par l’utilisateur et le résulta demandé .

Fonctionnement du du programme

1-Indiquer le distance a convertir
2-Donner l’unité de départ
3-Donner l’unité d’arrivé
4-Vous avez le résultat

Une version améliorée

Notre programme

d = float(input("Indiquez la distance: "))
print("pm = 0\tnm = 1\tµm = 2\tmm = 3\tcm = 4\tdm = 5\tm = 6\tdam = 7\thm = 8\tkm = 9\tMm = 10\nGm = 11\tTm = 12")
u_d = int(input("Indiquez l'unité de départ: "))
u_a = int(input("Indiquez l'unité d'arrivée: "))
{exposant = [10**-12,10**-9,10**-6,10**-3,10**-2,10**-1,10**0,10**1,10**2,10**3,10**6,10**9,10**12]
prefixe = ["pm","nm","µm","mm","cm","dm","m","dam","hm","km","Mm","Gm","Tm"]}
d_c = d * exposant[u_d] / exposant[u_a]
print(d_c,prefixe[u_a])

Explication du programme

Après avoir fini la version 1 ont a trouvé que c’était beaucoup trop long et nous avons donc voulu le raccourcir .
Ont a donc chercher un moyen et nous avons trouve l’utilité des listes

exposant = [10**-12,10**-9,10**-6,10**-3,10**-2,10**-1,10**0,10**1,10**2,10**3,10**6,10**9,10**12]
prefixe = [« pm », »nm », »µm », »mm », »cm », »dm », »m », »dam », »hm », »km », »Mm », »Gm », »Tm »]

qui regroupe touts les calcul qu’il permette de faire la conversion de distance, et que l’on peut voir dans la version 1. Par contre même si nous sommes passer de 220 lignes a 8 lignes les possibilité sont les même ainsi que le fonctionnement . Nous avons décidé de remplacer int par float pour que vous puissiez convertir des décimaux .

Conclusion

J’espère que notre programme vous aidera pour toute vos conversions.
Si vous voulez vous pouvez le récupéré et rajouter d’autres unités de votre choix si vous vous en sentez capable.

Projets

Calcul du volume et de la masse des solides

Ce projet a été réalisé par des élèves en spécialité NSI du Lycée Louis Pasteur. Ils sont également les auteurs de ce compte rendu. Pour en savoir plus : Les projets en spécialité NSI

  • Le CVMS est un programme python créé dans le but de faciliter les calculs mathématiques dont l’obtention du résultat nécessite l’usage d’une calculatrice. Il automatise le calcul du volume et de la masse des solides de manière simple, rapide et pratique.
  • Cet algorithme est sous forme de menu, c’est à dire un menu listant des choix reliés à des fonctions. Chaque choix est relié à une fonction définie par la commande def [nom de la fonction].
  • Sept solides, listés au début du programme, sont disponibles. Pour en choisir un, il faut entrer le nombre lui correspondant. Pour obtenir le volume, certaines dimensions du solide sont demandées à l’utilisateur.
    Le programme utilisera la formule mathématique correspondant à la fonction.
  • Suite à cela, le programme propose de calculer la masse du solide
    sélectionné, si l’utilisateur sélectionne « non », le programme se clos. Si il sélectionne « oui », le programme demande d’entrer la masse volumique du solide, le résultat est donné en fonction de cette valeur.
    En dernier lieu, le programme offre à l’utilisateur la possibilité de choisir un nouveau solide.

Si vous souhaitez essayer ce programme, vous pouvez vous rendre sur ce site : trinket.io

Algorithme :

from math import *
print("Calcul du volume et de la masse des solides :")
print()
print("1. boule")
print("2. cube")
print("3. pyramide à base carrée")
print("4. parallélépipède rectangle")
print("5. cylindre droit")
print("6. cône de révolution")
print("7. prisme droit")
 
def boule():  
    print("Vous avez choisi la boule.")
    print()
    a=int(input("Entrez le rayon de la boule (en cm) :"))
    b=4/3*pi*a**3
    print("Le volume de la boule est de",b,"cm3")
    print()
    print("Voulez vous sa masse ?")
    print("1.Oui")
    print("2.Non")
    a=int(input())
    if a==2:
        print("Non ?, tant pis bonne journée...")
        exit
    elif a==1:
        c=int(input("Entrez la masse volumique (en g/cm3) de votre solide : "))
        print()
        print("La masse de votre solide est de " , c*b, "g")
    print()
    print("Pour choisir un nouveau solide, appuyez sur la touche ENTRER")
    input()
 
def cube():
    print("Vous avez choisi le cube.")
    print()
    a=int(input("Saisissez la longueur du côté du cube (en cm) : "))
    b= a**3
    print("Le volume du cube est de",b,"cm3")
    print()
    print("Voulez vous sa masse ?")
    print("1.Oui")
    print("2.Non")
    a=int(input())
    if a==2:
        print("Non ?, tant pis bonne journée...")
        exit
    elif a==1:
        c=int(input("Entrez la masse volumique (en g/cm3) de votre solide : "))
        print()
        print("La masse de votre solide est de " , c*b, "g")
    print()
    print()
    print("Pour choisir un nouveau solide, appuyez sur la touche ENTRER")
    input()
 
def pyramide():
    print("Vous avez choisi la pyramide.")
    print()
    a=int(input("Saisissez la longueur de la base de la pyramide (en cm) : "))
    b=int(input("Saisissez la largeur de la base de la pyramide (en cm) : "))
    c=int(input("Saisissez la hauteur de votre pyramide (en cm) : "))
    d=a*b
    e=d**2*c/3
    print("L'aire de la base de votre solide est de",d,"cm2")
    print()
    print("Le volume de votre pyramide est de",e,"cm3")
    print()
    print("Voulez vous sa masse ?")
    print("1.Oui")
    print("2.Non")
    a=int(input())
    if a==2:
        print("Non ?, tant pis bonne journée...")
        exit
    elif a==1:
        c=int(input("Entrez la masse volumique (en g/cm3) de votre solide : "))
        print()
        print("La masse de votre solide est de " , c*e, "g")
    print()
    print("Pour choisir un nouveau solide, appuyez sur la touche ENTRER")
    input()
 
def parallélépipèderectangle():
    print("Vous avez choisi le parallélépipède rectangle.")
    print()
    a=int(input("Saisissez sa longueur (en cm) : "))
    b=int(input("Saisissez sa largeur (en cm) : "))
    c=int(input("Saisissez sa hauteur (en cm) : "))
    d=a*b*c
    print("Le volume de votre parallélépipède rectangle est de",d,"cm3")
    print()
    print("Voulez vous sa masse ?")
    print("1.Oui")
    print("2.Non")
    a=int(input())
    if a==2:
        print("Non ?, tant pis bonne journée...")
        exit
    elif a==1:
        c=int(input("Entrez la masse volumique (en g/cm3) de votre solide : "))
        print()
        print("La masse de votre solide est de " , c*d, "g")
    print()
    print("Pour choisir un nouveau solide, appuyez sur la touche ENTRER")
    input()
 
def cylindredroit():    
    print("Vous avez choisi le cylindre droit.")
    print()
    a=int(input("Entrez le rayon du cylindre (en cm) :"))
    b=int(input("Entrez la hauteur du cylindre (en cm)"))
    d=pi*a**2*b
    print("Le volume de votre solide est de",d,"cm3")
    print()
    print("Voulez vous sa masse ?")
    print("1.Oui")
    print("2.Non")
    a=int(input())
    if a==2:
        print("Non ?, tant pis bonne journée...")
        exit
    elif a==1:
        c=int(input("Entrez la masse volumique (en g/cm3) de votre solide : "))
        print()
        print("La masse de votre solide est de " , c*d, "g")
    print()
    print("Pour choisir un nouveau solide, appuyez sur la touche ENTRER")
    input()
 
def cônederévolution():    
    print("Vous avez choisi le cône de révolution.")
    print()
    a=int(input("Saisissez la longueur du rayon du cône (en cm) : "))
    b=int(input("Saisissez la hauteur de votre cône (en cm) : "))
    c=pi*a**2
    d=pi*a**2*b/3
    print()
    print("L'aire de la base de votre solide est de",c,"cm2")
    print()
    print("Le volume de votre cône est de",d,"cm3")
    print()
    print("Voulez vous sa masse ?")
    print("1.Oui")
    print("2.Non")
    a=int(input())
    if a==2:
        print("Non ?, tant pis bonne journée...")
        exit
    elif a==1:
        c=int(input("Entrez la masse volumique (en g/cm3) de votre solide : "))
        print()
        print("La masse de votre solide est de " , c*d, "g")
    print()
    print("Pour choisir un nouveau solide, appuyez sur la touche ENTRER")
    input()
 
def prismedroit():
    print("Vous avez choisi le prisme droit.")
    print()
    a=int(input("Saisissez sa longueur (en cm) : "))
    b=int(input("Saisissez sa largeur (en cm) : "))
    c=int(input("Saisissez sa hauteur (en cm) : "))
    d=1/2*a*b*c
    print("Le volume de votre prisme est de",d,"cm3")
    print()
    print("Voulez vous sa masse ?")
    print("1.Oui")
    print("2.Non")
    a=int(input())
    if a==2:
        print("Non ?, tant pis bonne journée...")
        exit
    elif a==1:
        c=int(input("Entrez la masse volumique (en g/cm3) de votre solide : "))
        print()
        print("La masse de votre solide est de " , c*d, "g")
    print()
    print("Pour choisir un nouveau solide, appuyez sur la touche ENTRER")
    input()
 
def menu():
    print()
    print("Entrez le chiffre correspondant à votre solide : ")  
    choix = 0
    while choix==0:
        choix=int(input())
    if choix==1:
        boule()
    elif choix==2:
        cube()
    elif choix==3:
        pyramide()
    elif choix==4:
        parallélépipèderectangle()
    elif choix==5:
        cylindredroit()
    elif choix==6:
        cônederévolution()
    elif choix==7:
        prismedroit()
    elif choix==9:
        print("Abonnez vous : _kami_pedro_")
        exit
    elif choix==666:
        print("Tu vas avoir des problèmes")
        exit
    elif choix==42:
        print("42 est la réponse à La Grande Question sur la vie, l'univers et le reste dans l'œuvre de Douglas Adams Le Guide du voyageur galactique. Il reste alors à déterminer quelle était, précisément, la question.")
    else:
        menu()
    if choix!=9:
        menu()
 
menu()
  • En conclusion, nous pouvons dire que ce programme fut parfois difficile à réaliser mais nous avons finalement réussi à traverser tous les obstacles.
    Nous espérons que ce programme pourra répondre aux attentes de tous les utilisateurs.