402 : Python bases - boucles - fonctions
Boucle
Pour laisser l'utilisateur saisir la valeur d'une variable, il faut utiliser la fonctions input
input retourne une chaîne de caractère (string) qu'il faut convertir en numérique flottant (float)
mess = "Saisir une valeur numérique"
valeurS = float(input(message))
print(valeurS)
Testez plusieurs fois ce code en entrant du texte : toto par exemple, puis 2.5, puis 4.
Si l'utilisateur ne saisit pas une valeur cohérente avec les traitements à suivre, il faut soit, redémarrer le programme, soit prévoir dans le code une boucle tant que la valeur saisie n'est pas satisfaisante.
# boucler la demande de to et tu tant que l'un des deux est nul
err = True
while err:
to = float(input ("to ? (0 pour inconnu) : "))
tb = float(input ("tb ? (0 pour inconnu) : "))
err = (to==0) and (tb==0)
print (tu,to)
On notera ici que l'on ne teste pas la saisie de données qui vont provoquer une erreur d'exécution (type de données incompatible, division par zéro, etc ...)
On demandera simplement à l'utilisateur de saisir une donnée numérique différente de 0 pour sortir de la boucle. Saisir la chaîne toto provoquera un arrêt brutal du programme.
Problème posé.
Construire un programme qui effectue les tâches suivantes :
demander à l'utilisateur la valeur de N0
boucler tant que Nt est différent de 0
calculer et afficher Rt dans la boucle
Question
« étape 1 »
: On teste le traitement principal dans un fichier nommé 402_01_v1.py
Dans l'exercice précédent, on sait calculer R(t) à partir de données dites constantes. On peut garder ce code (le recopier sans modifier le premier programme qui avait son propre objectif). On pourrait enlever des lignes inutiles, mais ici, c'est une bonne base pour ce que l'on a à faire.
Testez le pour être sûr qu'il fonctionne.
# 402_01_v1. py --> repris du code 401-1.py
N0 = 1000
Nt = 490
Rt = Nt/N0
print(Rt)
mess = "La fiabilité est de " + str(Rt*100) + " %"
print(mess)
Dans un premier temps, on va garder les lignes N0=1000 et Nt = 490, et se concentrer sur la boucle. Mettre en place la condition de sortie de la boucle avec la variable err qui peut être testée juste après l'affectation de Nt=490.
On est sûr que l'on doit avoir err à false car Nt est bien différent de 0
Indice
On testera err avec la comparaison de Nt avec la valeur 0
On affiche la valeur de la variable booléenne err
Solution
# code 401-1
N0 = 1000
err = True
Nt = 490
err = (Nt == 0)
print(err)
'''
Rt = Nt/N0
print(Rt)
mess = "La fiabilité est de " + str(Rt*100) + " %"
print(mess)
'''
REMARQUE : du code est mis en commentaires pour ne pas exécuter le calcul de R(t) si on teste Nt=0. On n'a que l'affichage de la variable err
Question
« étape 2 »
: saisie par l'utilisateur de Nt (402_01_v2.py)
on demande la valeur de Nt à l'utilisateur avec la fonction python input
Solution
N0 = 1000
Nt = int(input("Survivants à un instant t quelconque ? : "))
err = (Nt == 0)
print(err)
Testez plusieurs fois avec des valeurs de 0 1000 et -100 par exemple
Question
« étape 3 »
: la boucle avec sortie si pas d'erreur (402_01_v3.py)
On initialise err = True avant le début de la boucle, on teste la boucle while avec la variable err qui est forcément à vrai de sorte que l'on est assurée que la boucle soit exécutée au moins une fois.
Même si votre code est juste, testez Nt avec 0 et 20 pour vérifier que la boucle fonctionne bien.
Lisez le code corrigé.
Solution
N0 = int(input("N à t=0 ? :"))
err = True
while err:
print("début itération")
Nt = int(input("Survivants à un instant t quelconque ? : "))
err = (Nt == 0)
print(err)
print ("Fin de boucle")
Question
« étape 4 »
: la boucle avec sortie si pas d'erreur (402_01_v4.py)
Si nous avons une erreur, il ne faut pas calculer Rt, sinon le programme sera interrompu. Exécutez le calcul de Rt seulement si err est à false dans la boucle. Affichez Rt
Solution
# Mettre un # devant l'une des deux lignes selon ce que l'on souhaite faire
# N0 = int(input("N à t=0 ? :")) # pour la version finale
N0=1000 # pour les tests
err = True
while err:
print("début itération")
Nt = int(input("Survivants à un instant t quelconque ? : "))
err = (Nt == 0)
if not err:
Rt=Nt/N0
print(Rt)
print ("Fin de boucle")
Tant que l'on teste, on n'est pas obligé de demander N0 à l'utilisateur et on peut laisser N0=1000. Mettre une des deux lignes en commentaire est intéressant
Question
« étape 5 »
: une boucle avec calcul répétitif de la fiabilité et sortie quand l'utilisateur va saisir 0 (402_01_v5.py)
On va maintenant sortie de la boucle quand Nt sera égal à zéro.
On continue la boucle en calculant Rt seulement quand Nt>0 et Nt<=N0, car une fiabilité négative est impossible.
Vous pouvez là aussi y aller en deux sous-étapes. D'abord, sortir de la boucle quand Nt sera nul, puis ensuite laisser la boucle défiler si il y une erreur sur la saisie de Nt.
Solution
# N0 = int(input("N à t=0 ? :"))
N0 = 1000
continuerboucle = True
while continuerboucle:
Nt = int(input("Survivants à un instant t quelconque ? : "))
continuerboucle = (Nt!=0)
if continuerboucle:
err = (Nt <= 0 or Nt > N0)
if not err:
Rt=Nt/N0
print(Rt)
print ("Fin")
Une variable de type compteur : (402_01c_ex.py)
Il est intéressant dans une boucle de connaître savoir ce qui se passe au niveau du nombre d'itérations. Observons le code ci-dessous.
# boucler la demande de to et tu tant que l'un des deux est nul
err = True
i = 0
while err:
i = i + 1
print("itération n°"+str(i))
to = float(input ("to ? (0 pour inconnu) : "))
tb = float(input ("tb ? (0 pour inconnu) : "))
err = (to==0) and (tb==0)
print (tu,to)
Avec la variable i initialisé à 0 avant le début de la boucle, on va à chaque fois qu'une nouvelle itération est démarrée, ajouter 1 à la variable i.
Dans les exercices qui vont suivre, lorsque l'on va introduire les listes , les tableaux, les dictionnaires, il faudra accéder à un et un seul élément, et c'est avec une variable itérative qu'il sera possible de gérer un ensemble de TTF dans le cadre d'observations de durées de vie, mais aussi de traiter une défaillance avec son rang i, une période de rang i, etc ...
Ici, on affiche le nombre d'itération au fur et à mesure, mais on peut se contenter d'afficher la variable en sortie de boucle.
Question
Reprise du code 402-01_v5.py.
Avec la variable i, comptez le nombre d'itérations du programme.
Avec la variable iNbR, on veut compter uniquement les itérations pour lesquelles le calcul de la fiabilité a pu se faire.
Solution
# N0 = int(input("N à t=0 ? :"))
N0 = 1000
continuerboucle = True
i=0
iNbR=0
while continuerboucle:
i=i+1
print("itération n°"+str(i))
Nt = int(input("Survivants à un instant t quelconque ? : "))
continuerboucle = (Nt!=0)
if continuerboucle:
err = (Nt < 0 or Nt > N0)
print(err)
if not err:
iNbR=iNbR+1
print("Calcul de fiabilité n° "+ str(iNbR))
Rt=Nt/N0
print(Rt)
print ("Fin")
Question
Construire une variante 1 du programme précédent qui permette à l'utilisateur de calculer uniquement 3 fois la fiabilité et que la boucle s'arrête.
Faire de même avec une boucle for : chercher comment utiliser la boucle for
Les Fonctions
Vous avez l'habitude d'utiliser des fonctions tableur qui retournent une valeur lorsque vous transmettez à cette fonction des arguments
On remarque que lorsque l'on doit interagir avec l'utilisateur et qu'il faut contrôler la cohérence des données, le code peut vite devenir long et si il faut en plus dupliquer ce code à chaque valeur à saisir, le code va vite y perdre en lisibilité ainsi qu'en testabilité.
Analyser et essayer de comprendre le code de la fonction finput[1]: n'hésitez pas demander des explications complémentaires
Tester cette fonction :
le code de la fonction doit être présent dans un fichier mod1.py.
créer un autre fichier 402-test-finput.py dans le même dossier que mod1.py.
Dans le fichier 402-test-finput.py, copier les lignes ci-dessous
from mod1 import finput
tu = finput("tu","95")
to = finput("to","100",False)
Question
Appliquez dans les codes précédents la fonction finput pour saisir N0 et Nt
Question
Construire une fonction fR qui calcule R(t)
Solution
def fR(Nt,N):
R=Nt/N
return R
N0=1000
Nt1=500
Nt2=700
Rt1=fR(Nt1,N0)
Rt2=fR(Nt2,N0)
print(str(Rt1)+ "-" + str(Rt2)
Question
Construire une fonction fLambda qui calcule
Les arguments seront
dN pour dN(t)
Ndeb pour N(t)
dt pour dt
Solution
def fLambda(Ndeb,dN,dt):
lbd = dN/Ndeb/dt
return lbd
Question
Construire une fonction fLambda qui calcule
Les arguments seront
Ndeb pour N(t)
Nfin pour N(t+dt)
tdeb pour t
tfin pour t+dt
On pourra utiliser des variables intermédiaires dt et dN pour calculer lambda=dN/Ndeb/dt
Solution
def fLambda(Ndeb,Nfin,tdeb,tfin):
dt = tfin-tdeb
dN = Ndeb-Nfin
lbd = dN/Ndeb/dt
return lbd