Étiquette : Maths

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.
Projets

Entrainement au calcul mental en Python

Ce script génère des additions et multiplications aléatoires et permet de s’entraîner sur le calcul mental.

Projet NSI 1 : Le calcul mental :

Ce projet consiste à créer un programme en python faisant travailler le calcul mental. Nous sommes en 1ère spécialité NSI au lycée Louis Pasteur à l’année 2019/2020.

Introduction : Python :

Python est un langage de programmation interprété. C’est à dire un programme qui exécute les programmes écrits avec un langage informatique. Python est un langage épuré car il possède moins de construction syntaxique que les autres langages. Il est disponible sur tablettes, ordinateurs, ou encore calculatrice.

But et présentation du programme :

Ce programme de calcul mental permet de se perfectionner et de s’entrainer au calcul via différents niveaux adaptés à tout le monde. Il est pratique car il permet d’avoir une correction et un score et de ne pas se préoccuper à trouver des calculs. Ce programme est destiné à tous les niveaux (plus particulièrement aux élèves de seconde qui doivent savoir maîtriser ces notions.).

Ce programme est constitué de 5 niveaux regroupant le calcul d’additions, de soustractions et de multiplication. Chaque niveau est constitué de 20 questions et d’une correction. Ce programme permet aussi à un élève de seconde de s’initier au langage python en l’exécutant et d’essayer de le comprendre grâce à la petite présentation du programme ci-dessous.

Décortication du programme :

Tout d’abord la console nous demande de choisir un niveau dans le menu proposé.

# La fonction menu !
def menu():
    print("Choisis un niveau")
    print("1. Addition niveau 1") 
    print("2. Addition niveau 2")
    print("3. Multiplication niveau 1")
    print("4. Multiplication niveau 2")
    print("5. Final avec toutes les opérations posssibles")
    choix = 0
    while choix==0:
        choix=int(input())
    if choix==1:
        additionniveau1()
    elif choix==2: 
        additionniveau2()
    elif choix==3:
        multiplicationniveau1()
    elif choix==4:
        multiplicationniveau2()
    elif choix==5:
        final()
    elif choix==9:
        print("Au revoir !")
        exit
    else: 
        menu() 
    if choix!=9:
        menu() 

menu()

On peut voir ci-dessus la fonction menu. Grace à « print » un menu va s’afficher. Puis avec la fonction « int(input » l’utilisateur va choisir un niveau grâce à 5 chiffres correspondant aux 5 niveaux. Et avec les conditions « elif et if » notre programme va se reporter au fonction prédéfinies précedemment.

Voici une des fonctions définies :

# Une des 5 fonctions définis !
    print("Niveau1 : Addition avec 1 chiffre")
    nb=1
    score = 0
    while nb<=20:
        aleat1 = random.randint(1, 9)
        aleat2 = random.randint(1, 9)
        print("Combien fait", aleat1, "+",aleat2)
        reponse = int(input("réponse = "))
        nb = nb + 1
        result = (aleat1 + aleat2)
        if reponse==result :
            score = score + 1
        elif reponse!=result :
            score = score + 0
        print("Voici la correction:", result)
    print("Ton score est:", score, "/20")
    if score>=16 :
        print("Bravo tu es experimenté et tu peux passer au niveau 2")
    if score<10 :
        print("C'est pas grave, retente ta chance")
    if score<16 and score>=10:
        print("Tu as un bon niveau mais je te conseille de reessayer. Avant révise un peu.") 

Grace à la fonction random des chiffres et des nombres vont être tirés aléatoirement permettant de générer des calculs aléatoirement.

Ces chiffres et nombres sont 2 variables (aleat1 et aleat2) tirés aléatoirement selon un intervalle de chiffres et nombres selon les niveaux respectifs. Cela va être appliqué au 4 premier niveaux.

Avec « if » qui nous permet d’exécuter le code mais avec des conditions. Si la réponse est juste le +1 va être ajouté au score sinon pas de changement du score. Ce qui fera un résultat final sur 20 grâce à la fonction « while » ; while nous permet de réaliser cette boucle indéfiniment tant que la variable « nb » n’est pas inférieur à 20. Cette boucle va donc se répéter pendant 20 questions.. Aussi à la fin de chaque calcul une correction est proposée encore grâce à « if ». Si le score est supérieur à 16 la compétence est validée, si c’est entre 10 et 15 tu maîtrises moyennement les compétences. Si inférieur à 10 il vaudrait mieux réviser.

# Le script d'une autre fonction !
    print("Niveau5: Final")
    nb=1
    score = 0
    while nb<=20:
        aleat1 = random.randint(1, 15)
        aleat2 = random.randint(1, 15)
        listes = [(aleat1 + aleat2), (aleat1 * aleat2), (aleat1 - aleat2)]
        aleat3 = listes[random.randint(0, 2)]
        if aleat3==(aleat1 + aleat2) :
            print("Combien fait", aleat1, "+", aleat2)
        elif aleat3==(aleat1 * aleat2) :
            print("Combien fait", aleat1, "x", aleat2)
        elif aleat3==(aleat1 - aleat2) :
            print("Combien fait", aleat1, "-", aleat2)
        reponse = int(input("réponse = "))
        nb = nb + 1 
        result = aleat3
        if reponse==result :
            score = score + 1
        elif reponse!=result :
            score = score + 0
        print("Voici la correction:", result)
    print("Ton score est:", score, "/20")
    if score>=16 :
        print("Bravo tu es experimenté et tu maitrise toutes les compétences nécessaires")
    if score<10 :
        print("C'est pas grave, retente ta chance tu vas y arriver. Avant révise un peu.")
    if score<16 and score>=10:
        print("Tu as un bon niveau mais je te conseille de réessayer")

Pour la 5ème fonction nous avons créé une 3ème variable (aleat3) nous permettant de tirer aléatoirement dans une liste prédéfinie (composé des 3 opérations), et grâce encore une fois à la condition « if » pour avoir une opération aléatoire et toujours des chiffres et nombres aléatoires.

Si tu veux t’améliorer en calcul mental clique sur le lien ci-dessous :

Projets

Algorithme sur la forme canonique d’un trinôme du second…

Cet algorithme sert à calculer la forme canonique, les extrémums et le tableau de variation d’un trinôme du second degré.

•Le menu (défini par « menu ») : cette fonction donne accès au menu des 3 autres fonctions.

def menu():
    print("Que voulez-vous chercher : ")
    print("1. Forme canonique")
    print("2. Extremum")
    print("3. Tableau de variation")
    print("9. Menu")
    print("0. Fin")
    choix = int(input("Veuillez rentrer votre choix avec 1, 2, 3, 9 ou : "))
    if choix==0:
        print("Fin")
    elif choix==1:
        canonique()
    elif choix==2:
        extremum()
    elif choix==3:
        variation()
    elif choix==9:
        menu()

•Le calcul de la forme canonique (défini par « canonique ») : cette fonction calcul à l’aide de vos connaissances ou non, la forme canonique d’un trinôme du second degré.

def canonique():
    print("Vous avez fait le choix 1 qui est le calcul de la forme canonique d'un trinome")
    print(a,"x²+",b,"x+",c)
    print("Tout d'abord vous devez connaître les valeurs de alpha, beta et delta ")
    alpha = input("Connaisez vous la formule de alpha ? Si oui veuillez la rentrer : ")
    if alpha == "-b/2a":
        print("C'est bien")
    else: print("Ce n'est pas ça, la formule de alpha est -b/2a ")
    print("On calcule donc alpha = -b/2a = ",alphaa)
    print("Ensuite, il faut connaître la valeur de delta afin de pouvoir calculer beta ")
    delta = input("Connaisez vous la formule de beta ? Si oui veuillez la rentrer : ")
    if delta == "b²-4ac":
        print("C'est bien")
    else: print("Ce n'est pas ça, la formule de delta est b²-4ac ")
    print("On calcule donc delta = b²-4ac = ",deltaa)
    print("Maintenant, on peut calculer beta à l'aide de delta ")
    beta = input("Connaisez vous la formule de beta ? Si oui veuillez la rentrer : ")
    if beta == "-delta/(4a)":
        print("C'est bien")
    else: print("Ce n'est pas ça, la formule de beta est -delta/(4a) ")
    print("On calcule donc beta = -delta/(4a) = ",betaa)
    print("La forme canonique d'une fonction polynome de degré 2 s'écrit sous la forme : a(x-alpha)²+beta")
    print("On a alpha, on a beta, on peut donc mettre cette fonction sous forme canonique")
    if alphaa&lt;0 and betaa&lt;0:
        print("forme canonique : ",a,"(x+",-alphaa,")²-",-betaa)
    if alphaa&lt;0 and betaa>0:
        print("forme canonique : ",a,"(x+",-alphaa,")²+",betaa)
    if alphaa>0 and betaa>0:
        print("forme canonique : ",a,"(x-",alphaa,")²+",betaa)
    if alphaa>0 and betaa &lt;0:
        print("forme canonique : ",a,"(x-",alphaa,")²-",-betaa)
    if b&lt;0 and c&lt;0:
        print("On a maintenant la forme canonique du trinome f(x)=",a,"x²",b,"x",c,)
    if b&lt;0 and c>0:
        print("On a maintenant la forme canonique du trinome f(x)=",a,"x²",b,"x+",c,)
    if b>0 and c>0:
        print("On a maintenant la forme canonique du trinome f(x)=",a,"x²+",b,"x+",c,)
    if b>0 and c&lt;0:
        print("On a maintenant la forme canonique du trinome f(x)=",a,"x²+",b,"x",c,)
        input()

•La détermination et le calcul des extremums (défini par « extremum ») : cette fonction détermine et calcul l’extremum d’un trinôme en fonction de alpha, de beta et du signe de a.

def extremum():
    print("Vous avez fait le choix 2 qui est la détermination de l'extremum de la forme canonique d'un trinome")
    print("La courbe d'un trinome est toujours une parabole, le sens de cette parabole est déduite en fonction du signe de a")
    print("Si a>0, la parabole sera tourner vers le bas et l'extremum sera donc un minimum")
    print("En revanche, si a&lt;0, la parabole sera tourner vers le haut et l'extremum sera donc un maximum")
    if a>0:
        print("Ici, a est positif donc la parabole sera tourner vers le bas et admettra un minimum")
        print("Ce minimum est déduit grâce à alpha et beta où alpha = x et beta = y")
        print("Le minimum de cette fonction est donc admit en x = ",alphaa,"et y = ",betaa)
    if a&lt;0:
        print("Ici, a est négatif donc la parabole sera tourne vers le haut et admettra un maximum")
        print("Ce maximum est déduit grâce à alpha et beta où alpha = x et beta = y")
        print("Le maximum de cette fonction est donc admit en x = ",alphaa,"et y = ",betaa)
        input()

•La détermination du tableau de variation (défini par « variation ») : cette fonction détermine la variation de la courbe en fonction du signe de a.

def variation():
    print("Vous avez fait le choix 3 qui est la construction du tableau de variation de la forme canonique d'un trinome")
    print("Le tableau de variation va donc commencer à -l'infini, admettra la valeur de ",alphaa," pour x, la valeur de ",betaa,"\npour f(x), pour ensuite finir vers +l'infini")
    if a>0:
        print("a>0 donc la fonction est décroissante puis croissante")
    if a&lt;0:
        print("a&lt;0 donc la fonction est croissante puis décroissante")
        input()

Pour la fonction « canonique », l’utilisateur peut rentrer, à l’aide de ses connaissances, les formules de alpha, beta et delta afin de les mémoriser, si il ne les connait, l’algorithme les affiche pour lui et calcul ensuite directement la forme canonique.

Pour la fonction « extremum », l’utilisateur n’a besoin d’aucune connaissance, l’algorithme fera automatiquement les calculs nécessaires tout expliquant le déroulement, de même pour la fonction « variation ».

Lors de l’exécution de l’algorithme, le menu s’affiche et l’utilisateur peut choisir plusieurs options afin de répondre à son propre critère de demande.

Vous pouvez télécharger le code complet ici

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

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

Quiz sur les fonctions en mathématiques en Python

Ce projet est un programme de mathématiques réalisé spécialité NSI (Numérique et Sciences de l’Informatique). Il est organisé sous forme de quiz et réalisé sur le logiciel Thonny.

Présentation du projet

Ce projet permet à un lycéen d’apprendre et de comprendre les différentes fonctions de mathématiques accessibles, généralement, à un élève de seconde (fonction carré, inverse, linéaire, affine et du second degré). Grâce à notre programme, les élèves s’entraînent et cela permet d’évaluer leur niveau. Celui-ci est composé de 11 questions (10 questions sur les fonctions et une question bonus de culture personnelle sur l’histoire des mathématiques). Une fois que l’élève a répondu à toutes les questions, il obtient une note sur 20 points (chaque bonne réponse rapporte 2 points et chaque mauvaise réponse n’apporte ni n’enlève de point).

Supports nécessaires à la réalisation du projet

Afin de réaliser notre projet, nous avons utilisé différents outils :

  • un ordinateur 
  • le logiciel Thonny que l’on peut télécharger sur un ordinateur gratuitement grâce à Internet

Difficultés rencontrées

Tout au long de notre programme, nous avons rencontré diverses difficultés :

  • des problèmes de programmation (dans les lignes de codes)
  • des problèmes dans la publication de cette article
  • des problèmes d’enregistrement qui nous ont parfois coûté de tout recommencer
  • des problèmes d’ordinateur qui surchauffe
  • etc…

Mais malgré toutes ces péripéties, tous nos problèmes ont été résolu avec plus ou moins de difficulté…

Notre programme

import random
score = 0
reponse= int(input("Bienvenue cher utilisateur, prêt à réviser les mathématiques ?\nPour oui, tapez 1 et sinon, tapez 0 : "))
if reponse == 0:
    print("Dommage ! Reviens quand tu seras prêt !")
elif reponse == 1:
    print("C'est parti, commençons !")
    y= input("Quelle est l'équation de f(x) pour une fonction linéaire ? \nf(x)=")
    if y != "ax":
        print("Tu as faux. Mais ne te décourage pas !")
    elif y == "ax":
        print("Bravo ! Continu comme ça.")
        score = score + 2
    chiffre= random.randint(2, 10)
    y2 = str(input("Donne moi l'équation de la fonction linéaire de coefficient directeur {} \nf(x)=".format(chiffre)))
    if y2 != ("{}x".format(chiffre)) :
       print("Tu t'es trompé ! C'est pas grave. Poursuis...")
    elif y2 == ("{}x".format(chiffre)) :
        print("Bravo, tu as raison ! Pousuivons...")
        score = score + 2
    y3= input("Quelle est l'équation de g(x) pour une fonction affine ? \ng(x)=")
    if y3 != "ax+b":
        print("Oh mince, tu as fait une erreur !")
    elif y3 == "ax+b":
        print("Félicitation tu as réussi !")
        score = score + 2
    chiffre2= random.randint(2, 20)
    y4 = str(input("Donne moi l'équation de la fonction affine de coefficient directeur {} et ayant pour ordonnée à l'origine {} \ng(x)=".format(chiffre, chiffre2)))
    if y4 != ("{}x+{}".format(chiffre, chiffre2)) :
        print("Nous avons confiance en toi ! Tu as faux mais tu vas y arriver.")
    elif y4 == ("{}x+{}".format(chiffre, chiffre2)) :
        print("Tu es un génie toi dit donc !")
        score = score + 2
    y5 = input("Quelle est l'équation du second degré h(x) ? \nh(x)=")
    if y5 != "ax²+bx+c" :
        print("Revoie ta leçon ce n'est pas la bonne réponse !")
    elif y5 == "ax²+bx+c" :
        print("Waaaouh quel talent !!")
        score = score + 2
    chiffre3= random.randint(0, 20)
    y6 = str(input("Donne nous l'équation du second degrès pour a= {}, b= {} et c = {} \nh(x)=".format(chiffre, chiffre2, chiffre3)))
    if y6 != ("{}x²+{}x+{}".format(chiffre, chiffre2, chiffre3)):
        print("Tu nous déçois !")
    elif y6 == ("{}x²+{}x+{}".format(chiffre, chiffre2, chiffre3)):
        print("Fantastique !")
        score = score + 2
    y7 = input("Quelle est l'équation de la fonction carré ? \ni(x)=")
    if y7 != "x²" :
        print("Mauvaise réponse !")
    elif y7 == "x²" :
        print ("Bonne réponse !")
        score = score + 2
    y8 = str(input("Quelle est l'équation de la fonction carré pour x= {} (non simplifiée) ? \ni(x)=".format(chiffre)))
    if y8 != ("{}²".format(chiffre)) :
        print("Retente ta chance !")
    elif y8 == ("{}²".format(chiffre)) :
        print("Bien joué !!")
        score = score + 2
    y9 = input("Quelle est l'équation de la fonction inverse ? \nj(x)=")
    if y9 != "1/x" :
        print("Tu vas devoir révisé un peu plus toi...")
    elif y9 == "1/x" :
        print("Bravo ! Tu en a dans la tête toi dit donc...")
        score = score + 2
    y10 = str(input("Quelle est l'équation inverse pour x= {} ? \nj(x)=".format(chiffre)))
    if y10 != "1/{}".format(chiffre) :
        print("C'est pas terrible tout ça")
    elif y10 == "1/{}".format(chiffre) :
        print("Amazing !!")
        score = score + 2
    print("Question bonus...")
    reponsee= input("A quel siècle le mathématicien français François Viète a-t-il proposé une définition des fonctions par des formules et non à partir de tables et de graphiques ? \n")
    if reponsee == "17eme siècle" or reponsee == "17eme":
        print("Waouh ! Quelle personne cultivée es-tu !")
        score = score + 2
    elif reponsee !="17eme siècle" or reponsee !="17eme"  :
        print("Ce n'est pas grave, c'est une question difficile...")
    print("Tu as une note totale de", score, "/20")
    print("Tu as fini ! A bientôt pour de nouvelles aventures...")

Explications du programme

Tout d’abord, avant de commencer l’explication, nous tenons à vous dire, que chaque virgule, parenthèse, alinéa, guillemet ou deux points sont très importants. S’il en manque ne serait-ce qu’un seul, le programme peut totalement « beuguer » et vous marquer « error » de partout (ceci est du vécu…☺).

Les couleurs ci-dessus se mettent automatiquement lorsque vous créez le programme sur Thonny mais celles-ci peuvent vous aider pour voir si vous avez oublié une lettre ou une parenthèse.

Commençons…

Dans un premier temps, il ne faut surtout pas oublier de mettre la ligne de codes 1 :

import random

car c’est grâce à elle que notre programme va nous donner des nombres aléatoires.

Nous l’utilisons à différents endroits mais prenons l’exemple, des lignes de codes suivantes (14, 15, 16 et 18 du programme). Il est écrit.

chiffre= random.randint(2, 10)
y2 = str(input("Donne moi l'équation de la fonction linéaire de coefficient directeur {} \nf(x)=".format(chiffre)))
if y2 != ("{}x".format(chiffre)) :
elif y2 == ("{}x".format(chiffre)) :

Nous avons, à la ligne de codes 14, créé une variable « chiffre » où l’on demande au logiciel de prendre un nombre aléatoire situé entre 2 et 10 compris :

chiffre= random.randint(2, 10)

La virgule, présente entre ces deux chiffres, sert à dire au logiciel de prendre n’importe quel nombre entre ceux-ci.

A la ligne de codes 15, nous utilisons « str » car c’est lui qui va nous permettre de convertir un nombre pris au hasard entre 2 et 10 en un caractère afin que l’on puisse l’utiliser dans la réponse. Les « {} » signifient le nombre aléatoire. Et pour que le logiciel comprenne, il ne faut pas oublier « .format(chiffre) » à l’intérieur des parenthèses pour dire que nous utilisons la variable « chiffre » :

y2 = str(input("Donne moi l'équation de la fonction linéaire de coefficient directeur {} \nf(x)=".format(chiffre)))

A cette même ligne de codes nous utilisons « \n » qui signifie « saut de ligne ».

Grâce à tout cela, nous pouvons voir qu’aux lignes de codes 16 et 18, nous utilisons le chiffre aléatoire donné comme étant un caractère.

Exemple : si le chiffre aléatoire donné est 3, nous pouvons écrire 3x comme réponse pour la fonction linéaire et cela fonctionne pour n’importe quel chiffre aléatoire.

Nous pouvons créer autant de chiffres aléatoires que l’on souhaite tant que toutes les variables sont citées « .format(chiffre, chiffre2, chiffre3) » —> ligne de codes 41 par exemple.

Ensuite, à la ligne de code 2, il est écrit :

score = 0

Ici, nous créons une variable qui se nomme « score » et qui est, au départ, égale à 0. A chaque bonne réponse de la part de l’utilisateur, nous allons marquer « score = score + 2 » (car rappelons-le, chaque bonne réponse rapporte 2 points) comme à la ligne de code 13, ou encore la 20.

Nous allons ensuite créer une deuxième variable, qui se nomme « reponse » à la ligne de codes 3 :

reponse= int(input("Bienvenue cher utilisateur, prêt à réviser les mathématiques ?\nPour oui, tapez 1 et sinon, tapez 0 : "))

Ici nous demandons à l’élève de répondre à une question par des chiffres (s’il est prêt à réviser les mathématiques, il doit taper 1, sinon il doit taper 0).

Nous utilisons « int » et « input » à cette endroit car « input » sert à poser une question à laquelle le logiciel attend une réponse de la part de l’utilisateur et « int » parce que c’est un chiffre qu’il va écrire et non du texte (des caractères).

Après, nous pouvons voir aux lignes de codes 4 et 6 ceci :

if reponse == 0:
elif reponse == 1:

Pourquoi utilisons-nous « if » et « elif » ?

« If » signifie « si » et « elif » veut dire « sinon ». Retour ligne automatique
Ici nous disons au programme que si l’utilisateur répond 0, celui-ci devra écrire « Dommage ! Reviens quand tu seras prêt ! » sinon, si l’utilisateur écrit 1, celui-ci devra écrire « C’est parti, commençons ! ».

Attention : ne pas oublier le deux points à la fin de la ligne de codes de « if » et « elif » !! Après 2 points, il doit toujours y avoir un alinéa.

« Print » signifie imprimer, c’est à dire que l’on demande au logiciel de faire apparaître cette phrase mais que celle-ci n’attend pas de réponse. C’est une affirmation.

Lorsqu’on pose une question (avec « input ») ou qu’on affiche du texte (avec « print »), on met tout le temps le texte entre parenthèses et entre guillemets.

A la ligne de codes 9, il est écrit :

if y != "ax":

Et à la ligne de codes 11, il nous pouvons lire :

elif y == "ax":

 » != » signifie différent et « == » signifie égal (on doit toujours en mettre 2 !)

Puis, aux lignes de codes 73 et 76, nous utilisons « or » qui signifie « ou ». Cela permet de proposer plusieurs réponses justes car le résultat peut, ici, être écrit de deux manières différentes :

if reponsee == "17eme siècle" or reponsee == "17eme":
elif reponsee !="17eme siècle" or reponsee !="17eme"  :

Pour finir, voyons ensemble la ligne de codes 78 :

print("Tu as une note totale de", score, "/20")

A cet endroit, le logiciel donne le score total des points obtenus c’est à dire des bonnes réponses fois deux (car chaque bonne réponse rapporte deux points). On marque donc la phrase, suivi de la variable (qui n’est pas du texte donc celle-ci n’est pas entre guillemets).

Conclusion

Nous espérons que toutes ces explications vous ont aidé et que grâce à cela notre programme est plus compréhensible pour vous. Maintenant, que vous êtes un génie de Python, vous pouvez faire les modifications que vous souhaitez pour vous l’approprier !!

Vous le voulez ? Et bien le voici…