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.
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, …
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:
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:
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.
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.
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 :
importos
Il est possible d’importer plusieurs modules :
importosimportsys
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.
Comment accéder à la liste des objets contenus dans un module ?
On peut utiliser la fonction dir :
>>>importos>>>dir(os)
Comment obtenir l’aide d’un module ?
On peut utiliser la fonction help :
>>>importos>>>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.
>>>fromosimportname>>>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é ?
Il existe une façon encore plus dangereuse d’utiliser l’expression from ... import ... :
>>>fromosimport*
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 :
>>>importmatplotlib.pyplotasplt>>>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
Dans le fichier demo.py :
"""
Un module de démonstration.
"""# Fonctions du moduledefb()->str:"""
Affiche b.
""""return"b"defa()->str:"""Affiche a."""return"a"# Attributs (variables) du modulec=2d=2if__name__=="__main__":# test des fonctions du moduleassertb()=="b"# place des assert
Dans l’interpréteur intéractif, lancé depuis le dossier dans lequel on a enregistré le module demo.py :
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 :
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
>>>whileTrue:try:x=int(input("Entrer un nombre entier :"))breakexceptValueError: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())exceptIOErroraserr:print("I/O Erreur : {0}".format(err))exceptValueError:print("Je ne suis pas parvenu à convertir en entier la donnée.")finally:f.close()
Utilisation de else
>>>try:f=open("fichier.txt",'r')exceptIOError :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
>>>defdivision(x,y):try:resultat=x/yexceptZeroDivisionError:print("Division par zero !")else:print("Le resultat est {0}".format(resultat))finally:print("Je suis toujours présent !")>>>division(2,1)Leresultatest2Jesuistoujoursprésent!>>>division(2,0)Divisionparzero!Jesuistoujourspré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.
É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.
Appeler ces fonctions depuis un autre programme.
Physique, Chimie et Informatique > Terminales Spé. NSI > Modularité et robustesse du code
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:
Importation des modules ;
Définitions des fonctions ;
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+360×100t)n
où C est le montant du capital considéré le jour de l’examen, C0 le
montant initial du capital, t le taux d’intérêt (en pourcentage) et n 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:
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 :
defmontant_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.
"""
defmontant_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é.
"""
defjours_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.
"""
deftaux_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).
Placer un commentaire au début du module qui décrit son fonctionnement.
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.
É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 :
On place 10 000 euros à 7 % d’intérêt. Quelle est la valeur du montant au
bout d’une année ?
On place 10 000 euros à 7 % d’intérêt. Au bout de quelle durée ce
montant est-il doublé ?
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)
"""importsysfrommathimportlogdefmontant_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))**nexcept:print("Un des arguments passé à la fonction est incorrect. Fin du programme.")sys.exit(1)returnCdefmontant_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)returnC0defjours_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)returnndeftaux_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)returntif__name__=="__main__":C=2.2133983053266699C0=2.0t=5.000000000000782n=730# Test des fonctionsassertC==montant_actuel(C0,t,n)assertC0==montant_initial(C,t,n)assertn==jours_ecoules(C0,C,t)assertt==taux_annuel(C0,C,n)
Physique, Chimie et Informatique > Terminales Spé. NSI > Modularité et robustesse du code
La somme des inverses des carrés des nombres entiers converge vers 6π2.
k=1∑∞k21=6π2
On utilise cette formule pour trouver une approximation de π.
1
2
3
4
5
6
7
8
9
10
11
importmathdefterme(k:int)->float:return1/(k**2)defapproxpi(n:int)->float:s=0# utilise les termes jusqu’à 1/n**2 inclusforkinrange(n):s=s+terme(k)returnmath.sqrt(s*6)
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
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 et v de l’espace, de coordonnées respectives (u1,u2,u3) et (v1,v2,v3), est le nombre réel u1v1+u2v2+u3v3.
Le code suivant permet de calculer des produits scalaires. Il est testé sur des vecteurs de l’espace choisis au hasard :
importrandomfromtypingimportTupledefscalaire(v1:Tuple[int],v2:Tuple[int])->float:"""
Calcule le produit scalaire des deux vecteurs v1 et v2.
"""s=0forkinrange(len(v1)):s=s+v1[k]*v2[k]returnsdefrandom_vect(n:int)->tuple:"""
Génère un vecteur de taille n contenant des entiers non nuls
entre -10 et 10
"""v=[]foriinrange(n):val=random.randint(-10,10)ifval!=0:v.append(val)returntuple(v)defmain():foriinrange(20):print(scalaire(random_vect(3),random_vect(3)))main()
Prises séparément, les deux fonctions semblent opérationnelles :
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.
Sur la ligne en question, qu’est-ce qui pourrait avoir provoqué l’erreur ?
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.
Expliquer l’erreur. Pourquoi ne se produit-elle pas toujours au même moment ?
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".
Pour chacune des propositions suivantes, proposer un test qui montre que la fonction ne répond pas au cahier des charges de l’énoncé.
Proposer un ensemble complet de tests pour la fonction que l’on veut créer (on nomme cette fonction valeur).
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 a, b et n et calcule le reste de la division par n de ab ;
– pgcd qui prend en paramètres les entiers a et b et renvoie le plus grand diviseur commun de a et b (définition du pgcd) ;
– decomposition qui prend un entier positif n en paramètre et renvoie la liste de ses facteurs premiers ainsi que leur multiplicité.
Créer le module avec les trois fonctions proposées.
Proposer des dosctrings pour le module et les trois fonctions décrites. Annoter les fonctions avec les annotations de type.
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 p divise n. Si oui, on recommence l’algorithme pour n//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 72 est plus grand que 29 (fin)
On obtient la décomposition attendue : 2088=23×32×29.
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
Créer un module dont l’API est la suivante :
>>>help(aires)Helponmoduleaires:NAMEairesDESCRIPTIONFournituredefonctionscalculantlessurfacesdediversesfiguresgéométriques.FUNCTIONSdisque(rayon:float)->floatRenvoiel'aire du disque de rayon r.rectangle(largeur:float,longueur:float)->floatRenvoiel'aire d'unrectangledecôtéslargeuretlongueur.triangle(base:float,hauteur:float)->floatrenvoiel'aire d'untriangledebasebaseetdehauteurhauteur.DATApi=3.14159FILE/home/runner/aires/aires.py
Créer, de la façon qui semblera la plus pertinente, un jeu de tests des fonctions, dans ce module.
Écrire un programme principal qui utilise ce module.
Expliquer quelle est la différence entre les deux spécifications suivantes :
defdisque(rayon:float)->float:"""
Renvoie l'aire du disque de rayon r.
"""
et
defdisque(rayon:float)->float:"""
Renvoie l'aire du disque de rayon r.
HYPOTHÈSE: r > 0
"""
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.
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.
defdisque(rayon:float,dec:int=-1)->float:"""
Renvoie l'aire du disque de rayon r.
"""aire=pi*rayon*rayonifdec>=0:aire=round(aire,dec)returnaire
En déduire comment se comportent, en Python, les paramètres d’une fonction auxquels on attribue des valeurs dans la signature.
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.
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.