Projets
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
Sommaire
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.
Cet article a été écrit par des élèves du lycée Louis Pasteur.
Ils étudiaient alors la spécialité NSI, en classe de 1ère.
Promotion 2019 – 2020