Aller au contenu principal
Physique, Chimie et Informatique > Terminales Spé. NSI

Modularité et robustesse du code

Au programme

Contenus Capacités attendues Commentaires
Modularité - Utiliser des API (Application Programming Interface) ou des bibliothèques.
- Exploiter leur documentation.
- Créer des modules simples et les documenter.
- Mise au point des programmes.
- Gestion des bugs.
- Dans la pratique de la programmation, savoir répondre aux causes typiques de bugs : problèmes liés au typage, effets de bord non désirés, débordements dans les tableaux, instruction conditionnelle non exhaustive, choix des inégalités, comparaisons et calculs entre flottants, mauvais nommage des variables, etc. On prolonge le travail entrepris en classe de première sur l’utilisation de la spécification, des assertions, de la documentation des programmes et de la construction de jeux de tests. Les élèves apprennent progressivement à anticiper leurs erreurs.

Documents

15 sept. 2020

Sous-sections de Modularité et robustesse du code

Physique, Chimie et Informatique > Terminales Spé. NSI > Modularité et robustesse du code

Modules et exceptions

Ce chapitre se concentre sur les modules de Python et sur les modalités d’importation des données des modules dans l’environnement de travail.

À retenir

L’objectif de ce document est de souligner l’importance d’un code modulaire, c’est à dire d’un code qui :

  • puisse être utilisé dans plusieurs programmes ;
  • puisse être documenté précisément ;
  • soit suffisamment compact pour être étudié avec soin et en particulier testé.

Qu’est-ce qu’un module ?

À retenir

Un module permet d’organiser logiquement le code Python.

  • Quand la taille du code augmente, il peut être pratique de le diviser en entités organisées qui peuvent continuer à interagir.
  • Un module permet aussi de se créer une «  boite à outils » contenant des fonctions appelées depuis plusieurs programmes.
  • Finalement, un module permet de bénéficier du travail déjà effectué, maximisant ainsi la réutilisabilité du code.

Modules et fichiers

À retenir

Si les modules représentent un moyen d’organiser logiquement le code Python, les fichiers permettent quant à eux d’organiser physiquement le code.

À cette fin, chaque fichier est considéré comme un module individuel, et réciproquement. Le nom de fichier d’un module est le nom du module auquel on ajoute l’extension .py.

Un module peut contenir tout objet Python: variables, fonctions, classes, …\ldots

Chemin de recherche et recherche de fichiers

L’importation de modules requiert un processus nommé chemin de recherche . C’est une procédure de recherche dans un ensemble de répertoires (dossiers) du système de fichiers — le résultat de cette recherche dépend donc de l’installation de Python et du système d’exploitation utilisé — pour trouver le fichier module:

>>> import sys
>>> print(sys.path)
['', '/Users/mats/anaconda/lib/python35.zip', 
'/Users/mats/anaconda/lib/python3.5', 
'/Users/mats/anaconda/lib/python3.5/plat-darwin', 
'/Users/mats/anaconda/lib/python3.5/lib-dynload', 
'/Users/mats/anaconda/lib/python3.5/site-packages', 
'/Users/mats/anaconda/lib/python3.5/site-packages/Sphinx-1.3.1-py3.5.egg', 
'/Users/mats/anaconda/lib/python3.5/site-packages/aeosa', 
'/Users/mats/anaconda/lib/python3.5/site-packages/setuptools-19.4-py3.5.egg']

Dans le cas où la recherche d’un module échoue, une exception est levée par l’interpréteur :

>>> import xxx
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named 'xxx'

Puisque le chemin de recherche consiste à construire une liste de répertoires (dossiers), il est possible de la modifier. La méthode de liste append() permet d’importer un module situé dans un répertoire absent du chemin de recherche:

>>> sys.path.append('/home/utilisateur/dossier-modules')
Avertissement

Il n’est pas nécessaire de modifier le chemin de recherche si le fichier module se trouve dans le même répertoire que le fichier source contenant le code qui importe le module.

Portée des variables et espaces de noms

À retenir

La portée d’un identificateur est la portion du programme à laquelle sa déclaration s’applique. On emploie également le terme de visibilité .

Les variables définies dans une fonction ont une portée locale, celles définies au plus haut niveau d’un module ont une portée globale.

À retenir

Les variables globales présentent une caractéristique notable : à moins qu’elles n’aient été détruites, leur durée de vie est égale à celle du script qui s’exécute. En revanche, les variables locales, comme le bloc de pile dans lequel elles résident, sont temporaires et ne «  vivent » que le temps pendant lequel les fonctions dans lesquelles elles sont définies sont actives.

>>> chaine_globale = "Salut"
>>> def bonjour():
…     chaine_locale = "la planète"
…     print(chaine_globale + chaine_locale)
>>> bonjour()
Salut la planète
>>> print(chaine_locale)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'chaine_locale' is not defined
> Durée de vie des variables locales et globales.
Avertissement

Dans le cas où une variable locale porte le même nom qu’une variable globale, c’est la variable locale qui est utilisée. Python cherche d’abord dans l’espace de nom local avant de chercher dans l’espace de nom global.

>>> chaine = "Bonjour"
>>> def au_revoir():
…     chaine = "Au revoir"
…     print(chaine)
>>> au_revoir()
Au revoir

Il est donc possible de «  masquer » une variable globale, en utilisant une variable locale de même nom.

Info

Lorsque l’interpréteur Python importe un module, les règles de portée s’appliquent : si l’import se situe au niveau du module, sa portée est globale, s’il se situe dans une fonction, sa portée est locale.

Import de modules

L’instruction import

À retenir

L’import d’un module nécessite l’emploi de l’instruction import. La syntaxe est la suivante :

import os

Il est possible d’importer plusieurs modules :

import os
import sys

Lorsque l’interpréteur rencontre un import, le chemin de recherche est utilisé pour accéder au module. Si celui-ci est trouvé, il est importé. Comme annoncé ci-dessus, les règles de portée s’appliquent : si l’import se situe au niveau du module, sa portée est globale, s’il se situe dans une fonction, sa portée est locale.

Avertissement

L’appel import amène le module dans l’espace de nom, pas les objets qu’il contient. La notation . doit être utilisée afin d’utiliser ces objets.

>>> import os
>>> print(name)
Traceback (most recent call last):
NameError: name 'name' is not defined
>>> print(os.name)
posix
Comment accéder à la liste des objets contenus dans un module ?

On peut utiliser la fonction dir :

>>> import os
>>> dir(os)
Comment obtenir l’aide d’un module ?

On peut utiliser la fonction help :

>>> import os
>>> help(os)
> Résultat de l'importation du module `os`. Aucune référence à l'attribut `name` n'existe dans l'espace de nom global.

Comment obtenir la liste de tous les modules importés par un programme ?

>>> dir()

L’expression from … import

À retenir

Il est possible d’importer des objets particuliers d’un module dans le programme. L’objet appartient alors réellement à l’espace de nom du programme.

>>> from os import name
>>> print(name)
posix

Remarque

Ce type d’import peut présenter de réels dangers dans un programme dont le nombre de lignes est important et dont le développement s’effectue sur une longue durée. Que se passe-t-il si, dans le programme principal, un attribut ou une fonction portent le même nom que l’élément importé ?

>>> def sinc(x):
...     return 'coucou'*x
... 
>>> sinc(3)
'coucoucoucoucoucou'
>>> from pylab import sinc
>>> sinc(2)
-3.8981718325193755e-17

Remarque

Il existe une façon encore plus dangereuse d’utiliser l’expression from ... import ... :

>>> from os import *

Tous les objets contenus dans le module sont alors ajoutés à l’espace de nom globale du programme.

Avertissement

Éviter le plus possible la forme d’importation : from nom_module import * !

L’instruction import … as

Il arrive que l’on souhaite importer un module ou un attribut de module portant un nom déjà employé dans l’application, ou que ce nom ne convienne pas parce qu’il est trop long. On peut changer le nom lié localement du module et procéder ensuite comme avec le nom complet :

>>> import matplotlib.pyplot as plt
>>> plt.plot(x,y)

Import vs chargement

À retenir

Un module n’est incorporé dans l’espace de nom global qu’une seule fois, quel que soit le nombre de fois où il est importé.

Exemple de création d’un module

  1. Dans le fichier demo.py :
"""
Un module de démonstration.
"""

# Fonctions du module
def b() -> str:
    """
    Affiche b.
    """"
    return "b"

def a() -> str:
    """Affiche a."""
    return "a"

# Attributs (variables) du module
c = 2
d = 2

if __name__ == "__main__":              # test des fonctions du module
    assert  b() == "b"                  # place des assert
  1. Dans l’interpréteur intéractif, lancé depuis le dossier dans lequel on a enregistré le module demo.py :
>>> import demo
>>> print(demo.b())
"b"
>>> print(demo.c)
2

Mécanisme de gestion des exceptions

Lorsqu’un problème intervient lors de l’exécution d’un programme (division par zéro, tentative d’ouverture d’un fichier qui n’existe pas, erreur de syntaxe, etc.), l’interpréteur passe dans un mode particulier dans lequel il stoppe l’exécution du programme en cours et affiche une erreur :

>>> 7 / 0
Traceback (most recent call last):
ZeroDivisionError: integer division or modulo by zero

>>> f = open('monfichier.txt','r')
Traceback (most recent call last):
IOError: [Errno 2] No such file or directory: 'monfichier.txt'

>>> 3 + message
Traceback (most recent call last):
NameError: name 'message' is not defined

>>> while True print('Coucou !')
Traceback (most recent call last):
File "tm_python", line 1

>>> while True print('Coucou !')
                   ^
SyntaxError: invalid syntax
Message d’erreur

Le message affiché contient le traceback, c’est à dire la pile d’appel — le chemin parcouru par l’interpréteur pour atteindre l’erreur (soit la liste des fonctions traversées pour atteindre l’erreur).
Ce message comporte le type d’exception levée (ZeroDivisionError, IOError, NameError, SyntaxError, etc.) et un message qui décrit le problème rencontré.

Remarque

Dans le cas d’une erreur de syntaxe, le message d’erreur indique même où est détectée l’erreur à l’aide d’une flèche (en fait, elle se trouve généralement juste avant l’endroit pointé par la flèche).

À retenir

Pour éviter que le programme ne se termine définitivement ou qu’il se termine sans que la raison n’en soit explicite, il est conseillé de gérer les exceptions.

Exemple : Gestion des entrées du clavier

>>> while True:
    try:
        x = int(input("Entrer un nombre entier :"))
        break
    except ValueError:
        print("Oups ! Ce n'est pas un nombre. Nouvelle tentative")
À retenir

Le gestion des exceptions repose sur quelques mots clés : try, except, else et finally et sur une liste de types d’exceptions dont la liste peut être consultée dans la documentation en ligne de Python :

  • try : le bloc de code qui suit ce mot clé est exécuté séquentiellement. En cas de problème, l’exécution est interrompue et l’interpréteur passe au bloc d’instructions suivant le mot clé except.
  • except NomErreur : ce bloc d’instructions est exécuté si une erreur a été détectée dans le bloc try et si son type correspond à NomErreur. Plusieurs clauses except peuvent être utilisées. Il n’est pas nécessaire d’indiquer le type de l’erreur (tous les types sont alors traités de façon identique).
  • else : cette directive permet d’isoler dans la partie try la ou les instructions qui peuvent poser problème. Toutes les instructions suivantes (qui ne doivent donc être exécutées que si aucun problème intervient) peuvent être placées dans le bloc else.
  • finally : le bloc qui suit est exécuté dans tous les cas de figure, qu’une exception ait été levée ou pas. C’est donc ici que l’on peut s’assurer qu’un fichier ouvert dans le bloc try est correctement fermé, quoi qu’il arrive.

Exemple : Prise en compte de plusieurs erreurs

>>> try:
        f = open("fichier.txt", 'r')
        s = f.readline()
        i = int(s.strip())
    except IOError as err:
        print("I/O Erreur : {0}".format(err))
    except ValueError:
        print("Je ne suis pas parvenu à convertir en entier la donnée.")
    finally:
        f.close()

Utilisation de else

>>> try:
        f = open("fichier.txt",'r')
    except IOError&nbsp;:
        print("Je ne parviens pas à lire le fichier.")
    else:
        n = f.readlines()
        print("Le fichier comporte {0} lignes.".format(n))
    finally:
        f.close()

Les exceptions dans la définition d’une fonction

>>> def division(x, y):
    try:
        resultat = x / y
    except ZeroDivisionError:
        print("Division par zero !")
    else:
        print("Le resultat est {0}".format(resultat))
    finally:
        print("Je suis toujours présent !")

>>> division(2, 1)
Le resultat est 2
Je suis toujours présent !

>>> division(2,0)
Division par zero !
Je suis toujours présent !

Tout fichier manipulé doit être correctement fermé. Il n’est donc pas envisageable d’utiliser la fonction open sans gérer les exceptions. Utiliser les instructions try, except et finally peut cependant apparaître contre-productif (cela fait beaucoup de code pour une action courante). with permet de manipuler les fichiers en étant certain qu’ils seront fermés correctement, quoi qu’il arrive.

>>> with open("fichier.txt",'r') as f:
        for ligne in f:
            print(ligne)

Application

Exercice
  1. Écrire un module nommé convert_temp contenant les fonctions réalisant les conversions entre des températures exprimées en degrés Celsius, degrés Fahrenheit et Kelvin : C2F, F2C, C2K, K2C, F2K and K2F.

  2. Appeler ces fonctions depuis un autre programme.

Physique, Chimie et Informatique > Terminales Spé. NSI > Modularité et robustesse du code

Capitalisation d'une valeur

Cette séance a pour objectif de vous familiariser avec la création et la manipulation de modules.

Info

Comme il est maintenant de tradition vous diviserez le code de votre programme principal en trois parties:

  1. Importation des modules ;
  2. Définitions des fonctions ;
  3. Partie principale (lieu d’appel des fonctions).

Vous documenterez aussi systématiquement vos fonctions (une aide sera fournie dans les questions relatives à la définition de chacune de ces fonctions).

En mathématique, on démontre qu’un capital placé à un certain taux d’intérêt évolue selon la formule :

C=C0(1+t360×100)nC = C_{0} \left( 1 + \dfrac{t}{360 \times 100} \right)^n

où CC est le montant du capital considéré le jour de l’examen, C0C_{0} le montant initial du capital, tt le taux d’intérêt (en pourcentage) et nn le nombre de jours écoulés depuis le dépôt.

Remarque

Pour une durée de placement exprimée en jours, l’usage fait que l’intérêt est calculé sur la base de l’année financière ou commerciale comptant 360 jours et non pas l’année civile de 365 jours (ou 366 jours). Par ailleurs, lorsque la durée est exprimée en jours, les mois sont comptés à leur nombre exact de jours.

Selon le problème à résoudre on peut bien évidemment aussi écrire:

C0=C(1+t360×100)−nC_{0} = C \left( 1 + \dfrac{t}{360 \times 100} \right)^{- n}n=ln⁡(CC0)ln⁡(1+t360×100)n = \frac{\ln \left( \dfrac{C}{C_{0}} \right)}{\ln \left( 1 + \frac{t}{360 \times 100} \right)}t=360×100((CC0)1/n−1)t = 360 \times 100 \left( \left( \dfrac{C}{C_{0}} \right)^{1 / n} - 1 \right)
  1. Créer un module, nommé capitalisation, qui contient les quatre fonctions montant_actuel, montant_initial, jours_ecoules et taux_annuel qui implémentent les quatre expressions données ci-dessus.
    Les spécification des fonctions sont les suivantes :
def montant_actuel(C0: float, t: float, n: int) -> float:
    """
    Cette fonction calcule, à partir du montant initial, du taux
    d'intérêt et de la durée de dépôt, le montant actuel.
    """
def montant_initial(C: float, t: float, n: int) -> float:
    """
    Cette fonction calcule, à partir du montant actuel, du taux
    d'intérêt et de la durée de dépôt, le montant initial déposé.
    """
def jours_ecoules(C0: float, C: float, t: float) -> float:
    """
    Cette fonction calcule, à partir du montant initial, du montant
    actuel et du taux d'intérêt, la durée écoulée en jours.
    """
def taux_annuel(C0: float, C: float, n: int) -> float:
    """
    Cette fonction calcule, à partir du montant initial, du montant
    actuel et de la durée de dépôt (en jours), le taux annuel.
    """
Avertissement

Penser à gérer les exceptions (le module sys possède une fonction exit qui permet d’interrompre proprement un programme lorsqu’on lui passe le nombre 1 en argument).

  1. Placer un commentaire au début du module qui décrit son fonctionnement.

  2. Incorporer à ce module un bloc if __name__ == '__main__': permettant de tester ces fonctions.
    Choisir les valeurs suivantes pour les variables de test : C = 2.2133983053266699, C0 = 2.0, t = 5.000000000000782, n = 730 et vérifier que chacune des fonctions donne le bon résultat.

  3. Écrire un programme qui importe le module créé. Vérifier que les commentaires intégrés au module sont accessibles à l’aide de la fonction help().

À l’aide de ce programme, répondre aux questions suivantes :

  1. On place 10 000 euros à 7 % d’intérêt. Quelle est la valeur du montant au bout d’une année ?
  2. On place 10 000 euros à 7 % d’intérêt. Au bout de quelle durée ce montant est-il doublé ?
  3. On place 10 000 euros. Au bout de 60 jours, le montant est de 10 042 euros. À quel taux d’intérêt a été placée cette somme ?
Corrigé
"""
Module permettant d'effectuer des calculs de capitalisation

Variables : C est le montant à l'instant considéré, C0 est le
montant initial, t est le taux d'intérêt (en pourcentage) et n
le nombre de jours écoulés depuis le dépôt.

À partir de 3 paramètres, le 4ème peut être calculé à partir de :
    C = montant_actuel(C0, t, n)
    C0 = montant_initial(C, t,n)
    n = jours_ecoules(C0,C,t)
    t = taux_annuel(C0,C,n)
"""

import sys
from math import log


def montant_actuel(C0: float, t: float, n: int) -> float:
    """
    Cette fonction calcule, à partir du montant initial, du taux
    d'intérêt et de la durée de dépôt, le montant actuel.
    """
    try:
        C = C0 * (1 + t / (360 * 100)) ** n
    except:
        print("Un des arguments passé à la fonction est incorrect. Fin du programme.")
        sys.exit(1)
    return C


def montant_initial(C: float, t: float, n: int) -> float:
    """
    Cette fonction calcule, à partir du montant actuel, du taux
    d'intérêt et de la durée de dépôt, le montant initial déposé.
    """
    try:
        C0 = C * (1 + t / (360 * 100)) ** (-n)
    except:
        print("Un des arguments passé à la fonction est incorrect. Fin du programme.")
        sys.exit(1)
    return C0


def jours_ecoules(C0: float, C: float, t: float) -> float:
    """
    Cette fonction calcule, à partir du montant initial, du montant
    actuel et du taux d'intérêt, la durée écoulée en jours.
    """
    try:
        n = log(C / C0) / log(1 + t / (360 * 100))
    except:
        print("Un des arguments passé à la fonction est incorrect. Fin du programme.")
        sys.exit(1)
    return n


def taux_annuel(C0: float, C: float, n: int) -> float:
    """
    Cette fonction calcule, à partir du montant initial, du montant
    actuel et de la durée de dépôt (en jours), le taux annuel.
    """
    try:
        t = 360 * 100 * ((C / C0) ** (1 / n) - 1)
    except:
        print("Un des arguments passé à la fonction est incorrect. Fin du programme.")
        sys.exit(1)
    return t


if __name__ == "__main__":
    C = 2.2133983053266699
    C0 = 2.0
    t = 5.000000000000782
    n = 730
    # Test des fonctions
    assert C == montant_actuel(C0, t, n)
    assert C0 == montant_initial(C, t, n)
    assert n == jours_ecoules(C0, C, t)
    assert t == taux_annuel(C0, C, n)
Physique, Chimie et Informatique > Terminales Spé. NSI > Modularité et robustesse du code

Exercices

Enquêter sur une erreur dans un calcul de π\pi

La somme des inverses des carrés des nombres entiers converge vers π26\dfrac{\pi^2}{6}.

∑k=1∞1k2=π26\sum_{k=1}^{\infty} \dfrac{1}{k^2} = \dfrac{\pi^2}{6}

On utilise cette formule pour trouver une approximation de π\pi.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import math

def terme(k: int) -> float:
    return 1 / (k**2)

def approxpi(n: int) -> float:
    s = 0
    # utilise les termes jusqu’à 1/n**2 inclus
    for k in range(n):
        s = s + terme(k)
    return math.sqrt(s * 6)

  1. Lors de l’exécution de approxpi(1000) une exception est levée à l’exécution de la ligne 4. Quel est le type d’exception ?

    a. ValueError
    b. SyntaxError
    c. TypeError d. ZeroDivisionError
    e. IndexError f. NameError

  1. Bien que l’exécution soit interrompue ligne 4, la source de l’erreur est ailleurs
    Expliquer d’où provient l’erreur et proposer un correctif.

Enquêter sur une erreur de calcul de produit scalaire

Le produit scalaire de deux vecteurs u⃗\vec{u} et v⃗\vec{v} de l’espace, de coordonnées respectives (u1,u2,u3)(u_1, u_2, u_3) et (v1,v2,v3)(v_1, v_2, v_3), est le nombre réel u1v1+u2v2+u3v3u_1 v_1 + u_2 v_2 + u_3 v_3.
Le code suivant permet de calculer des produits scalaires. Il est testé sur des vecteurs de l’espace choisis au hasard :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import random
from typing import Tuple

def scalaire(v1: Tuple[int], v2: Tuple[int]) -> float:  
    """
    Calcule le produit scalaire des deux vecteurs v1 et v2.
    """
    s = 0
    for k in range(len(v1)):
        s = s + v1[k] * v2[k]
    return s

def random_vect(n: int) -> tuple:
    """
    Génère un vecteur de taille n contenant des entiers non nuls
    entre -10 et 10
    """
    v = []
    for i in range(n):
        val = random.randint(-10, 10)
        if val != 0:
            v.append(val)
    return tuple(v)

def main():
    for i in range(20):
        print(scalaire(random_vect(3), random_vect(3)))

main()

Prises séparément, les deux fonctions semblent opérationnelles :

>>> scalaire((1, 2, 1), (-1, 3, -2))
3
>>> random_vect(3)
(-6, 2, 8)

Pourtant, lorsqu’on exécute la fonction main(), le programme n’affiche que quelques produits scalaires (ici 12, 118 et −104) puis lève une exception :

>>> main()
12
118
-104
Traceback (most recent call last): 
  File "scal.py", line 28, in <module> 
    main() 
  File "scal.py", line 26, in main 
    print(scalaire(random_vect(3), random_vect(3))) 
  File "scal.py", line 9, in scalaire 
    s = s + v1[k] * v2[k]
IndexError: tuple index out of range
  1. En analysant le traceback donné plus haut, indiquer quel est le type d’exception qui a été levée, et sur quelle ligne de code.

  2. Sur la ligne en question, qu’est-ce qui pourrait avoir provoqué l’erreur ?

  3. Proposer d’ajouter un affichage print(...) à un endroit du programme pour essayer de mettre en évidence la nature du problème, puis exécuter à nouveau le code.

  4. Expliquer l’erreur. Pourquoi ne se produit-elle pas toujours au même moment ?

  5. Proposer un correctif.

Calculer la valeur d’un mot : arithmancie

On souhaite associer une valeur numérique à une chaîne de caractères. La valeur associée à la chaîne est la somme des valeurs associées à chacun des caractères qui la composent. Aux lettres non accentuées de A à Z, qu’elles soient en minuscules ou en majuscules, on associe leur numéro d’ordre dans l’alphabet, de 1 à 26. À tous les autres symboles (lettres accentuées, chiffres, espaces, ponctuations), on associe la valeur 0.
On rappelle que ord("a") donne le code numérique associé à la lettre "a" passée en paramètre. La chaîne string.ascii_uppercase est définie dans le module string et vaut "ABCDEFGHIJKLMNOPQRSTUVWXYZ".

  1. Pour chacune des propositions suivantes, proposer un test qui montre que la fonction ne répond pas au cahier des charges de l’énoncé.

Proposition 1

def valeur1(chaine):
    s = 0
    for c in chaine:
        if c >= "A" and c <= "Z":
            s = s + ord(c) - ord("A") + 1
    return s

Proposition 2

def valeur2(chaine):
    s = 0
    for c in chaine.upper():
        if c >= "A" and c < "Z":
            s = s + ord(c) - ord("A") + 1
    return s

Proposition 3

import string


def valeur3(chaine):
    s = 0
    for c in chaine.upper():
        if c in string.ascii_uppercase:
            s = s + string.ascii_uppercase.index(c)
    return s
  1. Proposer un ensemble complet de tests pour la fonction que l’on veut créer (on nomme cette fonction valeur).

  2. Proposer le code de cette fonction (il est possible de s’inspirer d’une des versions vues à la question 1. en la corrigeant). Ne pas oublier de vérifier que la fonction écrite passe bien les tests de la question 2.

Module d’arithmétique

Créer un module contenu dans un fichier nommé arithmetique.py. Ce module contient des fonctions sur l’arithmétique des nombres entiers. En particulier :

– expo qui prend en paramètres les entiers aa, bb et nn et calcule le reste de la division par nn de aba^b ;

– pgcd qui prend en paramètres les entiers aa et bb et renvoie le plus grand diviseur commun de aa et bb (définition du pgcd) ;

– decomposition qui prend un entier positif nn en paramètre et renvoie la liste de ses facteurs premiers ainsi que leur multiplicité.

  1. Créer le module avec les trois fonctions proposées.
  2. Proposer des dosctrings pour le module et les trois fonctions décrites. Annoter les fonctions avec les annotations de type.
  3. Ajouter quelques tests sous forme d’assertions.

Algorithme naïf pour la fonction decomposition

La première idée consiste à balayer la liste des nombres premiers en testant si le nombre premier pp divise nn. Si oui, on recommence l’algorithme pour n//pn//p, en ne testant que les diviseurs premiers encore envisageables. On s’arrête quand le nombre premier à tester devient supérieur à la racine carrée du nombre qu’il est censé diviser.
Ainsi pour décomposer 2088 en produit de facteurs premiers

2088 2 2 divise 2088 le quotient est 1044
1044 2 2 divise 1044, le quotient est 522
522 2 2 divise 522, le quotient est 261
261 3 2 ne divise pas 261, mais 3 divise 261 et le quotient est 87
87 3 3 divise 87 et le quotient est 29
29 ni 3, ni 5 ne divisent 29 et 727^2 est plus grand que 29 (fin)

On obtient la décomposition attendue : 2088=23×32×292088=2^3 \times 3^2 \times 29.

Physique, Chimie et Informatique > Terminales Spé. NSI > Modularité et robustesse du code

Fourniture et utilisation d'une API

API

Une API (en anglais « Application programming interface ») est une interface de programmation d’application. Elle est destinée à être utilisée par des programmes. Le principe de ce type d’interface est le même que celui des UI (« User Interface ») ou des GUI (« Graphical User Interface ») destinées elles à un utilisateur humain.

Composée de constantes, de fonctions, de classes, elle sert de lien entre un programme et les programmes qui vont l’utiliser. Elle peut être proposée par un service web avec une documentation décrivant l’utilisation qui permettra la communication et l’échange des données. Il existe, par exemple, plusieurs API de géolocalisation qui peuvent être intégrées à des programmes. Une API est très souvent proposée par une bibliothèque logicielle composée de fonctions destinées à être utilisées dans divers programmes.

Le principe de base est que le fonctionnement interne n’a pas besoin d’être connu du programme utilisateur. Cela nécessite une documentation fournie décrivant précisément son l’utilisation. Ainsi, lors de l’élaboration d’un logiciel il est possible d’utiliser des parties d’autres logiciels, sans connaître leur fonctionnement interne, si l’on sait comment faire interagir ces différentes parties.
Par exemple, pour utiliser une fonction il suffit de connaître sa spécification, c’est à dire son nom, les types de ses paramètres et de la valeur qu’elle retourne et sa documentation. Dans tous les cas, l’utilisateur, un programme ou un humain, se contente de fournir les données demandées et obtient le résultat du traitement.

Travail à réaliser

  1. Créer un module dont l’API est la suivante :
>>> help(aires)
Help on module aires:

NAME
    aires

DESCRIPTION
    Fourniture de fonctions calculant les surfaces
    de diverses figures géométriques.

FUNCTIONS
    disque(rayon: float) -> float
        Renvoie l'aire du disque de rayon r.
    
    rectangle(largeur: float, longueur: float) -> float
        Renvoie l'aire d'un rectangle de côtés largeur 
        et longueur.
    
    triangle(base: float, hauteur: float) -> float
        renvoie l'aire d'un triangle de base base et de 
        hauteur hauteur.

DATA
    pi = 3.14159

FILE
    /home/runner/aires/aires.py
  1. Créer, de la façon qui semblera la plus pertinente, un jeu de tests des fonctions, dans ce module.

  2. Écrire un programme principal qui utilise ce module.

  3. Expliquer quelle est la différence entre les deux spécifications suivantes :

def disque(rayon: float) -> float:
    """
    Renvoie l'aire du disque de rayon r.
    """

et

def disque(rayon: float) -> float:
    """
    Renvoie l'aire du disque de rayon r.

    HYPOTHÈSE: r > 0
    """
  1. On souhaite prendre en charge les cas où l’utilisateur fournirait une dimension négative (erronée donc).
    Modifier le code des fonctions de telle sorte qu’une exception de type ValueError soit levée chaque fois qu’une valeur négative est passée en argument.

Remarque : on pourra se renseigner sur l’utilisation du mot-clé raise.

Stabilité d’une API

Il est important, lorsqu’on souhaite faire évoluer une API, de faire en sorte que les utilisateurs qui l’utilisaient déjà, avant la modification, puissent toujours le faire sans avoir à modifier le programme ou voir celui-ci ne plus fonctionner. Sauf décision volontaire qu’il faudra communiquer aux utilisateurs, l’évolution d’une API doit apporter de nouvelles fonctionnalités sans en retirer.

Par exemple, on pourrait vouloir proposer aux utilisateurs la possibilité d’arrondir le résultat du calcul d’une aire.

  1. Modifier le code des différentes fonctions de façon à ce qu’il ressemble à celui de la fonction disque ci-dessous (la partie sur la levée de l’exception ValueError n’est pas insérée dans le code proposé). Vérifier que le programme écrit à la question 3. fonctionne toujours sans aucune modification.
def disque(rayon: float, dec: int = -1) -> float:
    """
    Renvoie l'aire du disque de rayon r.
    """
    aire = pi * rayon * rayon
    if dec >= 0:
        aire = round(aire, dec)
    return aire
  1. En déduire comment se comportent, en Python, les paramètres d’une fonction auxquels on attribue des valeurs dans la signature.

  2. Dans le programme principal modifier l’appel à la fonction disque de telle sorte que le résultat de son calcul soit arrondi à deux chiffres après la virgule.

  3. Le code utilise la fonction intégrée au langage Python round pour arrondir un float à un certain nombre de chiffres après la virgule.
    Écrire sa propre fonction round en n’utilisant que les opérateurs *, /, +, ** et la fonction int.