Exercice : 401 : Python - Calculs - Tests

Objectifs

Concepts clés abordés

  1. Variables en Python : affectation, typage dynamique, manipulations (float, string, int).

  2. Input et affichage : utilisation de print() pour afficher des résultats, formattage avec str() ou f-strings (plus moderne).

  3. Calculs simples : opérations arithmétiques de base.

  4. Contrôles conditionnels :

    • if, else, elif pour gérer différentes situations.

    • Vérification de la validité des données (valeurs attendues).

    • Utilisation de l'indentation pour délimiter les blocs.

  5. Gestion d’erreurs et exceptions :

    • Structure try-except pour traiter les erreurs d'exécution.

    • Différenciation des types d’erreurs (TypeError, ZeroDivisionError).

    • Validation préventive des données avec if.

  6. Test de cohérence des données : vérifier si les valeurs entrées sont dans un intervalle attendu.

  7. Commentaires dans le code : utiliser # et ''' pour commenter/desactiver du code, ou documenter.

  8. Documentation et bonnes pratiques : structuration claire, gestion des erreurs, validation des données.

  9. Conditions de validation : exemple avec la fiabilité R(t) et le TRG (taux de défaillance).

Pré-requis

Disposer d'un environnement de développement en python : cf la procédure N ° T-0037 : PythonAnywhere

Affecter une variable

Afficher une variable : print()

Convertir une variable de type float en string : str ()

Votre dossier de travail pour stocker vos fichiers est app/fiab/

Question

Mettre en place un programme app/fiab/401-1.py qui affiche la fiabilité observée R(t) avec en entrée le nombre de composants N(t=0) et le nombre de composants en fonctionnement à l'instant t :

N0, Nt et Rt sont les noms de variable à utiliser :

  • Affecter N0 à 1000

  • Affecter Nt à 490

  • Calculer Rt

  • Afficher Rt

  • Afficher le texte suivant : La fiabilité est de {Rt} % (voir ci-contre)

Solution

py_cor
1
# code 401-1 : Calcul de fiabilité observée R(t)
2
# R(t) = N(t) / N(0)
3
4
# Initialisation des données
5
N0 = 1000  # Nombre initial de composants
6
Nt = 490   # Nombre de composants fonctionnels à l'instant t
7
8
# Calcul de la fiabilité
9
Rt = Nt / N0
10
print(Rt)
11
12
# Affichage formaté avec f-string (Python 3.6+)
13
mess = f"La fiabilité est de {Rt*100:.2f} %"
14
print(mess)
15
16
# Note : .2f limite l'affichage à 2 décimales
Faire des tests (if else elif)
Tester la validité des données en ajoutant l'affichage d'une variable err si le trg n'est pas compris entre 0 et 1
1
tu = 103
2
to = 100
3
trg = tu/to
4
# on met la variable err à VRAI (true) si le trg n'est pas compris entre 0 et 1
5
err = not ((trg>=0) and (trg<=1))
6
print (err)
Faire des tests en modifiant les valeurs de tu et to pour vérifier que l'on affiche true ou false si il y a une incohérence
Avec un test sur la variable err, on affiche un message adapté à l'utilisateur. Il faut donc ajouter le code ci-dessous
1
if err :
2
    print (f"❌ Erreur avec tu = {tu} hrs et to = {to} hrs")
3
else :
4
    print (f"✓ Le TRG est de {trg*100:.2f} % avec tu = {tu} hrs et to = {to} hrs")
NOTER l'importance du symbole : qui marque le début des blocs if et else
NOTER que chaque bloc est indenté avec la touche TAB pour que l'instruction à exécuter fasse bien partie du bloc.
Ci-contre, en cliquant sur les flèches des lignes 5 et 7, vous pouvez d'ailleurs replier les blocs pour être conscient du rôle joué par l'indentation.
« En C/C++, on utilise les accolades {} pour marquer les débuts/fins de bloc ainsi que le ; pour marquer la fin d'une instruction »
« Python n'oblige pas déclarer les variables en préalable à une affectation »
Question
Vous pouvez continuer à travailler avec le même fichier .py en mettant le code que vous ne souhaitez plus exécuter avec des tripe cotes (''') en début et fin du code concerné
# est utilisé pour commenté une ligne (il peut donc être utilisé pour empêcher l'exécution d'un print par exemple)
Appliquez la méthode à votre calcul de la fiabilité en y ajoutant le fait que la valeur N0 ne peut pas être égale à 0 puisque la division par 0 donnerait une erreur.
Pour être sûr que votre code fonctionne bien, vous devrez tester les 3 cas possibles avec Nt = 490, puis N0 = 0 puis N0 = -2
Vous testerez N0 = "toto". Que se passe t-il ? comment tester ce cas ?
Solution
1
# code 401-2 : Calcul de fiabilité avec validation des données
2
3
N0 = 1000   # Nombre initial de composants
4
Nt = -2     # Valeur de test (invalide)
5
6
# Validation 1 : N0 doit être strictement positif (CORRECTION: tester N0, pas Nt)
7
err1 = (N0 <= 0)
8
9
if err1:
10
    mess = f"❌ Erreur : N0 ({N0}) doit être strictement positif"
11
else:
12
    # Calcul de la fiabilité
13
    Rt = Nt / N0
14
    
15
    # Validation 2 : R(t) doit être dans [0, 1]
16
    err2 = Rt < 0 or Rt > 1
17
    
18
    if err2:
19
        mess = f"❌ Erreur : La fiabilité ({Rt:.3f}) doit être comprise entre 0 et 1"
20
        mess += f"\n   Vérifiez vos valeurs : N0={N0}, Nt={Nt}"
21
    else:
22
        mess = f"✓ La fiabilité est de {Rt*100:.2f} %"
23
24
print(mess)
Gérer les exceptions
Dans l'exercice précédent, le programme est interrompu avec un message d'erreur.
Jusque là, nous avions testé des incohérences (TRG ou R(t) non compris entre 0 et 1) ou anticipé sur le risque d'une erreur (division par 0)
Avec python, il est possible d'essayer si une instruction peut s'exécuter et mettre en place des traitements adaptés selon différents cas :
  • pas d'erreur
  • présence d'une erreur
1
tu = 95
2
to = "toto"
3
try:
4
    to = tu/to
5
    print("Ok pas d'erreur")
6
except :
7
    print("Impossible de faire le calcul de tu/to")
Tester ce code avec to = 100, to = 90, to = 0, to = "toto"
On peut faire mieux en récupérant la nature de l'erreur
1
tu = 95
2
to = 100
3
trg = 0.99 # Pour initialiser le trg calculé plus loin en float.
4
try:
5
    trg = tu/to
6
    print("Ok pas d'erreur")
7
except TypeError:
8
    print("Merci d'utiliser des chiffres")
9
except ZeroDivisionError:
10
    print("Merci de ne pas utiliser le 0")
Tester ce code avec to = 100, to = 90, to = 0, to = "toto"
Vous remarquerez que l'incohérence des données (cas trg non compris entre 0 et 1) n'est pas évalué ici, car cela ne déclenche pas une erreur d'exécution, il fut donc faire un test traditionnel avec if comme nous l'avons vu précédemment.
Question
Mettre en oeuvre les exceptions et les tests pour afficher les erreurs et incohérences lors du calcul de R(t)
Solution
1
# code 401-3 : Calcul de fiabilité avec gestion d'exceptions
2
3
N0 = 1000   # Testez avec : 1000, 0, "toto"
4
Nt = 490    # Testez avec : 490, 1200, "abc"
5
6
try:
7
    # Tentative de calcul
8
    Rt = Nt / N0
9
    
10
    # Validation de cohérence (ne déclenche pas d'exception)
11
    err = Rt < 0 or Rt > 1
12
    
13
    if err:
14
        mess = f"⚠️  Incohérence : La fiabilité ({Rt:.3f}) doit être comprise entre 0 et 1"
15
        mess += f"\n   Valeurs utilisées : N0={N0}, Nt={Nt}"
16
    else:
17
        mess = f"✓ La fiabilité est de {Rt*100:.2f} %"
18
        
19
except TypeError as e:
20
    # Erreur de type (ex: "toto" / 100)
21
    mess = f"❌ Erreur de type : Utilisez des nombres, pas du texte"
22
    mess += f"\n   Détail technique : {e}"
23
    
24
except ZeroDivisionError:
25
    # Division par zéro
26
    mess = f"❌ Erreur mathématique : N0 ne peut pas être égal à 0"
27
    mess += f"\n   Division par zéro impossible"
28
    
29
except Exception as e:
30
    # Autres erreurs imprévues
31
    mess = f"❌ Erreur inattendue : {type(e).__name__}: {e}"
32
33
print(mess)