Étiquette : Calcul

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.

version_2.py_Télécharger

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.