Modularité et API : exercices corrigés de Terminale NSI

On dispose du module geometrie.py donné dans le rappel, avec la fonction aire_rectangle(largeur, longueur) qui renvoie le produit des deux paramètres.

Un programme principal contient :

import geometrie

resultat = geometrie.aire_rectangle(4, 7)
print(resultat)

1. Pourquoi faut-il écrire geometrie. devant le nom de la fonction ?
2. Quelle valeur est affichée ?

Un module annuaire.py contient le code suivant :

_contacts = {}

def ajouter(nom, numero):
    """Enregistre le numéro associé au nom."""
    _contacts[nom] = numero

def chercher(nom):
    """Renvoie le numéro associé au nom, ou None s'il est inconnu."""
    return _contacts.get(nom)

def _normaliser(texte):
    return texte.strip().lower()

1. Quelles fonctions forment l'interface que le module propose aux autres programmes ?
2. Que représentent _contacts et _normaliser ?
3. Un programmeur écrit annuaire._contacts["Léa"] = "0102030405" depuis son programme principal. Pourquoi est-ce une mauvaise idée ?

Le module boutique.py propose :

def prix_ttc(prix_ht, taux):
    """Prix toutes taxes comprises, taux en pourcentage."""
    return prix_ht * (1 + taux / 100)

def total_ttc(liste_prix_ht, taux):
    """Somme des prix TTC d'une liste de prix hors taxes."""
    total = 0
    for p in liste_prix_ht:
        total = total + prix_ttc(p, taux)
    return total

Un programme appelle boutique.total_ttc([50, 20, 10], 20).

1. Quelle est la valeur renvoyée, en euros ?
2. La fonction total_ttc utilise prix_ttc : pourquoi est-ce un avantage de ne pas avoir recopié la formule ?

Un module pile.py définit une classe Pile dont l'interface est :

• Pile() : crée une pile vide ;
• empiler(x) : ajoute x au sommet ;
• depiler() : retire et renvoie l'élément du sommet ;
• est_vide() : renvoie True si la pile est vide.

Un programme exécute :

from pile import Pile

p = Pile()
p.empiler(5)
p.empiler(8)
p.empiler(3)
a = p.depiler()
p.empiler(4)
b = p.depiler()
c = p.depiler()

1. Quelle est la valeur de c à la fin ?
2. Que contient la pile à la fin ?

Voici deux versions d'un module compteur.py.

Version A

_n = 0

def incrementer():
    global _n
    _n = _n + 1

def valeur():
    return _n

Version B

_traces = []

def incrementer():
    _traces.append(1)

def valeur():
    return len(_traces)

Un programme appelle trois fois incrementer() puis affiche valeur().

1. Que s'affiche-t-il avec la version A ? Avec la version B ?
2. Le programme doit-il être modifié quand on passe de A à B ?
3. Donne un cas où la version A serait préférable.

On veut manipuler un texte que l'on peut modifier caractère par caractère. Un module texte_modifiable.py conserve le texte sous forme de liste de caractères, et propose :

• creer(chaine) : renvoie la liste des caractères de chaine ;
• inserer(t, i, c) : insère le caractère c à la position i ;
• supprimer(t, i) : retire le caractère situé à la position i ;
• remplacer(t, i, c) : remplace le caractère situé à la position i par c ;
• vers_chaine(t) : renvoie le texte sous forme de chaîne.

On exécute :

import texte_modifiable as tm

t = tm.creer("banane")
tm.inserer(t, 0, "r")
tm.remplacer(t, 1, "c")
tm.supprimer(t, 6)
tm.inserer(t, 3, "o")
print(len(t))
print(tm.vers_chaine(t))

1. Quelle est la longueur affichée ?
2. Quel texte est affiché ?