Fonctions, assertions et docstring en Python
Premiers pas avec les fonctions
Pourquoi des fonctions ?
Dans la partie précédente, nous avons terminé par un petit programme qui demande à un·e utilisateur·trice de donner un nombre entier entre 1 et 10, et qui vérifie la saisie jusqu'à ce que l'utilisateur·trice ait effectué une saisie correcte. Voici un exemple simple d'implémentation de ce programme, tel que celui que vous avez proposé :
saisie = input("Entrez un nombre entre 1 et 10 :")bksl-nlwhile not(saisie in [ "1", "2", "3","4", "5", "6", "7", "8", "9", "10" ]) :bksl-nl saisie = input("Entrez un nombre entre 1 et 10 :")bksl-nlnb = int(saisie)bksl-nlprint(f"Vous avez saisi {nb}")bksl-nl
Un blocage ?
Quels sont les problèmes pouvant être posé par ce programme ?
-
En premier lieu, les lignes 1 et 3 sont des répétitions (des copiés-collés). Or en informatique, on essaye le plus possible de respecter le principe DRY : Don't Repeat Yourself. Une méthode pour corriger ce point pourrait être la suivante :
repeter = True while repeter : saisie = input("Entrez un nombre entre 1 et 10 : ") if saisie in [ "1", "2", "3","4", "5", "6", "7", "8", "9", "10" ] : nb = int(saisie) repeter = False print(f"Vous avez saisi {nb}")
-
Dans un second temps, le code fonctionne dans ce cas précis, mais n'est pas adaptable à d'autres situations. En effet, on doit saisir dans la liste toutes les possibilités pouvant être saisies, ce qui rend le code peu adaptable à une situation du style « Saisir un nombre entier entre -1000 et 1000 ». Il faut donc modifier complètement la logique de ce programme. Entre autres, il faut découper le code en plusieurs morceaux :
- On commencera d'abord à tester si quelque chose a bien été saisi, sinon il faut reposer la question.
- Il faut ensuite tester si la suite de caractères saisie correspond bien aux caractères des entiers, et rien qu'à ceux-ci. On pourrait aussi tester si le premier caractère est un signe « - », pour prendre en compte les entiers négatifs.
- Enfin, une fois certain que la saisie est bien un entier, on la trans-type, puis on regarde si la condition d'encadrement est correcte.
Le code suivant donne toutes ces étapes :
repeter = True # Booléen servant à exécuter la boucle while repeter : # Tant que repeter est vrai saisie = input("Entrez un nombre entre 1 et 10 : ") if saisie != "" : # On ne travaille que si la saisie est une chaine non vide ######## ON TESTE SI LA SAISIE EST CELLE D'UN ENTIER ####### est_un_entier = True # On suppose que c'est un entier indice_depart = 0 # et que le premier caractère est un chiffre if saisie[0] == "-" :# si le premier caractère est un signe "-", indice_depart = 1# On regardera chaque caractère à partir de l'indice 1 for caractere in saisie[indice_depart : len(saisie)] : # Pour chaque caractère if caractere not in "0123456789" : # Si ce n'est pas un chiffre est_un_entier = False # Alors la saisie n'est pas un entier ###### ON TESTE SI IL EST ENTRE 1 et 10 ####### if est_un_entier : # nb = int(saisie)# Trans-typage if 1<= nb <= 10 : # Si les conditions sont remplies repeter = False # On arrête la boucle print(f"Vous avez saisi {nb}") # Juste là pour montrer la saisie
Application 1 : Multiplier les codes
Imaginons maintenant un programme qui demande trois fois à l'utilisateur·trice d'entrer un tel nombre, puis qui vérifie si les trois nombres correspondent à une configuration de Pythagore (c'est-à-dire \(a^2 + b^2 = c^2\)).
Vous devez vous inspirer du programme précédent pour compléter le programme ci-dessous afin d'obtenir trois nombres entiers nb1
, nb2
et nb3
saisis par l'utilisateur·trice :
Un programme avec notre niveau actuel en Python pourrait être le suivant :
repeter = True
while repeter :
saisie1 = input("Entrez un nombre entre 1 et 10 : ")
if saisie1 != "" :
est_un_entier = True
indice_depart = 0
if saisie1[0] == "-" :
indice_depart = 1
for caractere in saisie1[indice_depart : len(saisie1)] :
if caractere not in "0123456789" :
est_un_entier = False
if est_un_entier :
nb1 = int(saisie1)
if 1<= nb1 <= 10 :
repeter = False
repeter = True
while repeter :
saisie2 = input("Entrez un nombre entre 1 et 10 : ")
if saisie2 != "" :
est_un_entier = True
indice_depart = 0
if saisie2[0] == "-" :
indice_depart = 1
for caractere in saisie2[indice_depart : len(saisie2)] :
if caractere not in "0123456789" :
est_un_entier = False
if est_un_entier :
nb2 = int(saisie2)
if 1<= nb2 <= 10 :
repeter = False
repeter = True
while repeter :
saisie3 = input("Entrez un nombre entre 1 et 10 : ")
if saisie3 != "" :
est_un_entier = True
indice_depart = 0
if saisie3[0] == "-" :
indice_depart = 1
for caractere in saisie3[indice_depart : len(saisie3)] :
if caractere not in "0123456789" :
est_un_entier = False
if est_un_entier :
nb3 = int(saisie3)
if 1<= nb3 <= 10 :
repeter = False
if nb1**2 + nb2**2 == nb3**2 or nb2**2 + nb3**2 == nb1**2 or nb3**2 + nb1**2 == nb2**2 :
print(f"({nb1}, {nb2}, {nb3}) est un triplet de Pythagore")
else :
print(f"({nb1}, {nb2}, {nb3}) n'est pas un triplet de Pythagore)
Mauvaise pratique
Si ce code fait le travail demandé, il n'en est pas moins de mauvaise qualité pour plusieurs raisons :
- Il est long, avec des répétitions. Plus un code est long, plus il prend de place en mémoire, alors qu'on cherche plutôt à minimiser ce facteur. Et surtout, plus un code est long, moins il est lisible !
- Le copié-collé force quand même à repasser sur chacune des parties pour modifier le nom des variables (sinon les valeurs seraient écrasées). Ainsi toute modification dans la structure du code doit être réécrite à chaque fois que le morceau de code est copié. Dans notre exemple, ce n'est que trois fois, le risque d'erreurs est minime, mais pour un plus grand nombre de répétitions, il est très facile d'oublier une modification.
Première fonction
Définition d'une fonction
On va donc améliorer non seulement la lisibilité de notre code, mais aussi son efficacité et sa simplicité, en utilisant une fonction.
Définition : fonction
Une fonction est un bloc de code nommé (c'est-à-dire possédant un nom dans l'espace de noms, comme toute autre variable) et qui :
- n'est pas exécuté au moment de sa définition ;
- mais peut être appelé plusieurs fois dans le code par l'intermédiaire de son nom, suivi d'une paire de parenthèses. Ces appels (call en anglais) exécuteront alors l'intégralité du code à chaque appel, et renverra une valeur de retour, c'est-à-dire un objet qui pourra être utilisé normalement dans la partie de code ayant appelé la fonction.
Pour notre exemple :
En regardant la première ligne, qu'on appelle la signature de la fonction :
def ask_user_int() -> int:
- La fonction est introduite par le mot clé
def
, suivi du nom de la fonction puis d'un couple de parenthèses()
, ce qui rend l'objet appelable (callable en anglais). - la notation
-> int
est un type hint, autrement dit un indice de type, qui indique que la valeur renvoyée par la fonction sera de typeint
. Les type hints sont facultatifs en Python, mais strictement nécessaires dans d'autres langages (Java
,C
,C++
, etc). - Les deux points définissent un bloc de code qui est repéré par une indentation, tout comme on définit des blocs dans des structures conditionnelles ou des boucles.
On fait appel à cette fonction en appelant le nom ask_user_int()
, ce qui déclenche le bloc de code, puis crée un objet de retour correspondant à la valeur saisie par l'utilisateur.
Oubli des parenthèses
Dans le cas d'un oubli des parenthèses lorsqu'on appelle une fonction, on obtient dans le terminal le message suivant :
>>> ask_user_int
<function ask_user_int at 0xe8c1a0>
Qui signifie simplement que le nom ask_user_int
fait référence à une fonction dont l'adresse dans la mémoire de l'ordinateur est donnée sous forme hexadécimale.
Pour les cracks
Notez que ask_user_int
est juste un nom, l'objet correspondant est stocké dans l'espace des objets. On peut donc écrire les choses suivantes :
>>> demande_entier=ask_user_int
>>> demande_entier()
Utilisation de la valeur de retour
Comme tout objet, la valeur de retour d'une fonction doit elle-même être stockée dans une variable afin de ne pas être ramassée par le garbage collector.
Exemple
>>> entier = ask_user_int()
>>> print(f'La racine carrée du nombre {entier} est {entier**(1/2)}')
L'interpréteur Python évalue la ligne entier = ask_user_int()
:
- Il commence par appeler le code correspondant à La fonction
ask_user_int()
. - Le code de la fonction demande une saisie à l'utilisateur, et une fois l'instruction
return
atteinte, l'instructionask_user_int()
est remplacée à l'endroit de l'appel par la valeur saisie par l'utilisateur, converti en objet de type int. - L'objet est ensuite stocké dans une variable nommée
entier
, et peut alors être utilisé en dehors de la fonction.
Factorisation du code de Pythagore
Le code du programme de vérification de Pythagore peut alors être factorisé (ce qui signifie globalement qu'on réduit sa taille en évitant les répétitions), afin de respecter le principe DRY :
#### Zone des fonctionsbksl-nlbksl-nldef askpy-unduserpy-undint() -> int:bksl-nl repeter = Truebksl-nl while repeter :bksl-nl saisie = input("Entrez un nombre entre 1 et 10 : ")bksl-nl if saisie != "" :bksl-nl estpy-undunpy-undentier = Truebksl-nl indicepy-unddepart = 0bksl-nl if saisie[0] == "-" :bksl-nl indicepy-unddepart = 1bksl-nl for caractere in saisie[indicepy-unddepart : len(saisie)] :bksl-nl if caractere not in "0123456789" :bksl-nl estpy-undunpy-undentier = Falsebksl-nl if estpy-undunpy-undentier :bksl-nl nb = int(saisie)bksl-nl if 1<= nb <= 10 :bksl-nl repeter = Falsebksl-nl return nbbksl-nl### Code principalbksl-nlbksl-nlnb1 = askpy-unduserpy-undint()bksl-nlnb2 = askpy-unduserpy-undint()bksl-nlnb3 = askpy-unduserpy-undint()bksl-nlif (nb1py-strpy-str2 == nb2py-strpy-str2 + nb3py-strpy-str2) or (nb2py-strpy-str2 == nb1py-strpy-str2 + nb3py-strpy-str2) or (nb3py-strpy-str2 == nb2py-strpy-str2 + nb1py-strpy-str2) :bksl-nl print("C'est une configuration de Pythagore !")bksl-nlelse :bksl-nl print("Ce n'est pas une configuration de Pythagore !")bksl-nl
Ce qui a l'avantage d'être vraiment plus clair.
Exercices
Application 2
Créer une fonction nommée table7
qui renvoie la table de multiplication de 7 avec un multiplicateur allant de 0 à 10, sous la forme d'une chaîne de caractères comme ci-dessous :
"7x0=0 \n 7x1=7 \n 7x2=14 ..."
Indication : le symbole \n
, insère un saut de ligne dans une chaîne de caractères.
def table7() -> str:
table = ''
for i in range(11) :
table += f'7x{i} = {7*i} \n'
return table
Augmenter la capacité des fonctions : les paramètres obligatoires
Premiers
L'exemple de la fonction ask_user_int
est assez limité. Dans l'absolu, on pourrait souhaiter que la fonction demande un nombre entier entre 2 valeurs variables, par exemple entre 1 et 100 ou bien entre -10 et 10.
Pour ce faire, il faut, dans la définition de la fonction, préciser des paramètres qui seront des objets transmis et nommés initialisés à certaines valeurs lors de l'appel à la fonction :
Exemple :
La fonction ask_user_int
utilise maintenant deux paramètres borne_min
et borne_max
, dont les type hints indiquent que ce doit être deux entiers.
Une fois la fonction définie, on peut l'appeler en lui passant des **arguments, c'est-à-dire des valeurs qui seront affectées aux paramètres :
>>> ask_user_int(1,100)
>>> ask_user_int(-10,10)
Erreurs d'appels et notion de précondition
Avec le code actuel de la fonction ask_user_int
, on peut rencontrer un certain nombre de difficultés. Testez les commandes suivantes dans la console
ask_user_int()
L'erreur signalée est de type TypeError
, et le message d'erreur nous dit qu'il manque 2 arguments lors de l'appel, et que ces arguments sont borne_min
et borne_max
.
ask_user_int(45)
L'erreur signalée est de type TypeError
, et le message d'erreur nous dit qu'il manque 1 argument lors de l'appel, et que cet argument est borne_max
. Cela signifie aussi que le nom borne_min
a bien reçu la valeur 45
.
ask_user_int(0.5,2.5)
Aucun véritable erreur n'est levée par Python, bien que les type hints demandent des arguments de type int
. Comme dit précédemment, ces indications sont facultatives (à destination des programmeur·euse·s), et ici les transgresser ne pose pas vraiment de problème.
ask_user_int(30,10)
Ici, la fonction tourne en boucle et il est impossible de saisir une réponse qui amènera à l'instruction return
. En effet, lors de l'appel à la fonction, on a :
borne_inf
initialisé à30
;borne_sup
initialisé à10
;- pour atteindre l'instruction
return
, il faudrait que l'utilisateur·trice ait saisi·e un nombrenb
à la fois supérieur à30
et inférieur à10
, ce qui est impossible.
On essayera donc le plus possible de créer des tests dans les fonctions permettant de tester des préconditions, c'est-à-dire des tests vérifiant les propriétés nécessaires concernant les arguments, par exemple ici que les arguments sont bien de type entier, et que borne_inf
est bien inférieur ou égal à borne_sup
. Ces tests seront vu dans la partie concernant les assertions.
Factoriser le code, 2ème saison
On a vu que factoriser le code, c'est réduire la taille d'un code en évitant les répétitions (principe DRY). Mais en fait, c'est aussi séparer le code en fonctions autonomes respectant une certaine logique interne. Par exemple, dans le code de notre fonction ask_user_int
, il y a deux parties bien distinctes :
- la première est de vérifier que la saisie est bien celle d'un entier ;
- la seconde est de vérifier les conditions d'encadrement du nombre saisi.
On pourrait alors souhaiter séparer le code en deux fonctions :
-
créer une fonction
is_integer
, dont la signature serait :qui utilise comme paramètredef is_integer(word : str) -> bool :
word
, une chaine de caractère, et qui renvoie un booléenTrue
siword
est transtypable en entier, etFalse
sinon. -
puis conserver la fonction
ask_user_int
telle qu'elle est définie actuellement.
On obtiendrait alors le code suivant :
def ispy-undinteger(word : str) -> bool :bksl-nl estpy-undunpy-undentier = Truebksl-nl indicepy-unddepart = 0bksl-nl if word[0] == "-" :bksl-nl indicepy-unddepart = 1bksl-nl for caractere in word[indicepy-unddepart : len(word)] :bksl-nl if caractere not in "0123456789" :bksl-nl estpy-undunpy-undentier = Falsebksl-nl return estpy-undunpy-undentierbksl-nlbksl-nlbksl-nldef askpy-unduserpy-undint(bornepy-undmin : int, bornepy-undmax : int) -> int:bksl-nl repeter = Truebksl-nl while repeter :bksl-nl saisie = input(f"Entrez un nombre entre {bornepy-undmin} et {bornepy-undmax} : ")bksl-nl if saisie != "" :bksl-nl estpy-undunpy-undentier = ispy-undinteger(saisie)bksl-nl if estpy-undunpy-undentier :bksl-nl nb = int(saisie)bksl-nl if bornepy-undmin<= nb <= bornepy-undmax :bksl-nl repeter = Falsebksl-nl return nbbksl-nl
Vous noterez que la fonction is_integer
est utilisée au sein de la fonction ask_user_int
.
Applications
Application 3
Créer une fonction table_multi(m : int)-> str
qui prend un argument entier m
et écrit la table de multiplication de ce nombre, avec un multiplicateur allant de 1 à 10.
Application 4 : motif dans une chaine
Créer une fonction trouve_chaine(motif : str, texte : str) -> bool
qui prend deux arguments, un motif
( une chaine de caractères ) et un texte
( une autre chaine de caractères ) et qui renvoie True
si le motif
est présent dans la chaine
, quel que soit la casse du motif ou celle de la chaine, et False
sinon. Vous pouvez tester avec les lignes suivantes :
assert trouve_chaine('Toto', 'Toto va à la plage')==True, 'Meme casse pas trouvée'
assert trouve_chaine('Totos', 'Toto va à la plage')==False, 'Chaine non présente trouvée'
assert trouve_chaine('TOTO', 'Toto va à la plage')==True, 'Problème de majuscules dans le motif'
assert trouve_chaine('toto', 'TOTO va à la plage')==True, 'Problème de minuscules dans le motif'
assert trouve_chaine('ToTo', 'OtOtO va à la plage')==True, 'Que dire ?'
Augmenter la capacité des fonctions : les arguments optionnels
Notre fonction ask_user_int
commence à être intéressante. Mais nous pourrions souhaiter personnaliser le message de la question, sans pour autant avoir envie de le changer systématiquement.
C'est tout à fait possible en Python, grâce aux paramètres optionnels. Il s'agit de paramètres dont le nom est donné dans la signature, mais avec une valeur par défaut. Ainsi :
def ispy-undinteger(word : str) -> bool :bksl-nl estpy-undunpy-undentier = Truebksl-nl indicepy-unddepart = 0bksl-nl if word[0] == "-" :bksl-nl indicepy-unddepart = 1bksl-nl for caractere in word[indicepy-unddepart : len(word)] :bksl-nl if caractere not in "0123456789" :bksl-nl estpy-undunpy-undentier = Falsebksl-nl return estpy-undunpy-undentierbksl-nlbksl-nlbksl-nldef askpy-unduserpy-undint(bornepy-undmin : int, bornepy-undmax : int, nom :str = "Inconnu") -> int:bksl-nl repeter = Truebksl-nl while repeter :bksl-nl saisie = input(f"{nom}, entrez un nombre entre {bornepy-undmin} et {bornepy-undmax} : ")bksl-nl if saisie != "" :bksl-nl estpy-undunpy-undentier = ispy-undinteger(saisie)bksl-nl if estpy-undunpy-undentier :bksl-nl nb = int(saisie)bksl-nl if bornepy-undmin<= nb <= bornepy-undmax :bksl-nl repeter = Falsebksl-nl return nbbksl-nl
Ainsi, la fonction ci-dessus possède trois paramètres :
- deux paramètres obligatoires,
borne_min
etborne_max
, de typeint
; - un paramètre optionnel,
prenom
, de typestr
, dont la **valeur par défaut est la chaineInconnu
.
Il est à noter qu'impérativement les paramètres obligatoires doivent être placés avant les paramètres optionnels.
On peut alors appeler la fonction des différentes manières suivantes (à tester) :
ask_user_int(0, 10)
ask_user_int(0, 10, nom='Toto')
ask_user_int(25, 40, nom='foo')
Application 5 : paramètres optionnels
Compléter la fonction table_multi
afin qu'elle utilise deux paramètres optionnels, la valeur de départ, fixée à 0 initialement, et la valeur d'arrivée du multiplicateur, fixée à 10 initialement.
def table_multi(nb : int, depart : int = 0, fin : int =10) -> str :
table = ''
for i in range(depart, fin+1) :
table += f'{nb}}x{i} = {nb*i} \n'
return table
Application 6 : paramètres optionnels
Réécrire la fonction trouve_chaine
afin qu'elle utilise un paramètre booléen optionnel verif_casse
, afin de déterminer si le motif
est présent dans le texte
en vérifiant la casse ou non. Par défaut le paramètre sera False
. Vous pouvez utiliser les tests ci-dessous :
### Cette cellule est une cellule vous permettant de tester votre fonction
##les assertions suivantes sont les même que précédemment
assert trouve_chaine('Toto', 'Toto va à la plage')==True, 'Meme casse pas trouvée'
assert trouve_chaine('Totos', 'Toto va à la plage')==False, 'Chaine non présente trouvée'
assert trouve_chaine('TOTO', 'Toto va à la plage')==True, 'Problème de majuscules dans le motif'
assert trouve_chaine('toto', 'TOTO va à la plage')==True, 'Problème de minuscules dans le motif'
assert trouve_chaine('ToTo', 'OtOtO va à la plage')==True, 'Que dire ?'
# Mais on rajoute celles-ci :
assert trouve_chaine('Toto', 'Toto va à la plage',verif_casse = True )==True, 'Meme casse pas trouvée'
assert trouve_chaine('TOTO', 'TOTO va à la plage',verif_casse = True )==True, 'Meme casse pas trouvée'
assert trouve_chaine('Totos', 'Toto va à la plage',verif_casse = True)==False, 'Chaine non présente trouvée'
assert trouve_chaine('TOTO', 'Toto va à la plage',verif_casse = True)==False, 'Problème de majuscules dans le motif'
assert trouve_chaine('toto', 'TOTO va à la plage',verif_casse = True)==False, 'Problème de minuscules dans le motif'
assert trouve_chaine('ToTo', 'OtOtO va à la plage',verif_casse = True)==False, 'Que dire ?'
def trouve_chaine(motif : str,texte : str, verif_casse : bool =False) -> bool :
if verif_casse==True :
return motif in texte
else :
return motif.lower() in texte.lower() :
Commenter son code : les docstrings
Commenter son code
Une bonne habitude, à prendre immédiatement, est celle de commenter son code, c'est-à-dire d'expliquer l'implémentation de votre code sous la forme de commentaires, écrits en français (ou mieux, en anglais). Les commentaires sont des lignes non-lues par l'interpréteur Python, commençant par le symbole dièse #
.
Ces explications sont importantes, car vous vous rendrez vite compte que vous serez parfois incapable de comprendre un code que vous avez écrit vous-même quelques semaines voir quelques jours auparavant !
Alors imaginez celui qui doit lire votre code, mais qui ne l'a pas écrit...
Les concepteur·trice·s de Python ont créé une fonction spécifique permettant d'obtenir des informations sur les autres objets : la fonction help
.
Testez par exemple la commande help(print)
dans la console suivante, puis essayez avec d'autres objets de Python.
La fonction help
va chercher dans l'objet passé en argument sa docstring, littéralement chaine de documentation, qui est une chaine de caractères crée par le ou la codeur·euse présentant l'utilisation de la fonction, ses paramètres obligatoires, ses paramètres optionnels, etc... Une docstring est construite comme une chaine de caractères non nommée présentée immédiatement après la déclaration de la fonction, comme dans l'exemple ci-dessous :
def somme(a, b) :bksl-nl """ fonction qui renvoie la somme des arguments a et b, bksl-nl en vérifiant si a et b sont bien du même type, bksl-nl et qui renvoie None sinon.bksl-nl Par exemple :bksl-nlbksl-nl somme(4, 3) renvoie 7bksl-nlbksl-nl somme(4, "3") renvoie Nonebksl-nl bksl-nl """bksl-nl if type(a) == type(b) :bksl-nl return a+bbksl-nl else :bksl-nl return Nonebksl-nl
La fonction somme
contient donc une docstring - introduite par trois guillemets (pour permettre les sauts de lignes). Celle-ci décrit l'effet de la fonction, de manière exacte.
On peut alors accéder à la docstring d'une fonction en utilisant la fonction built-in help
: testez par exemple help(somme)
.
Les docstrings
Une docstring est essentielle pour comprendre l'utilité d'une fonction ! Vous devrez en utiliser le plus souvent possible !
Notion de portée des variables
Au sein d'un même programme, les variables définies n'ont pas systématiquement la même portée. La portée d'une variable, c'est l'espace des objets/noms (on parle aussi de monde) dans lequel est défini cette variable.
En utilisant le site Python Tutor, nous allons essayer de comprendre cette notion de portée des variables.
Variables globales
Dans l'exemple ci-dessus, la variable gvar
est définie dans l'espace de nom global (global frame). Elle est accessible en lecture depuis l'intérieur de la fonction f
. On parlera alors de variable globale.
Variables locales
Dans l'exemple ci-dessus, la variable gvar2
est définie dans l'espace des noms associé à la fonction f
, et qui est créé au moment de l'appel à cette fonction (frame f). Cet espace est détruit par le garbage collector dès que l'exécution de la fonction est terminé (une fois la valeur de return
renvoyée dans l'espace appelant). Il devient donc impossible d'utiliser la variable gvar2
puisqu'elle a disparue. gvar2
est une variable locale à la fonction f
.
Changer la valeur d'une variable globale
Regardons maintenant le code suivant :
Le code précédent déclenche une erreur UnboundLocalError
en ligne 3. Cela signifie que l'interpréteur Python ne peut pas effectuer la ligne gvar=gvar+2
car il cherche une variable gvar
qu'il peut modifier. Or une variable définie hors d'une fonction ne peut pas être modifiée par celle-ci.
Il est par contre possible de travailler sur une copie de la variable souhaitée (uniquement dans le cas des types primitifs int
, float
, str
...), en utilisant une fonction ayant un argument. Il faudra par conséquent retourner la valeur changée* pour qu'elle soit effective. Par exemple comparez les deux scripts suivants :
Ici on constate qu'en fait il y a deux variables a
:
- une en dehors de la fonction, qui n'est pas modifiée. C'est une variable globale.
- une à l'intérieur de la fonction, qui peut être modifiée, mais qui ne change pas la variable globale. C'est une variable locale à la fonction.
La fonction f
ne renvoyant aucune donnée, la variable locale a
est détruite après la fin de la fonction f
.
Ici on a rajouté deux lignes :
return a
qui permet à la fonction de renvoyer la valeur modifiée ;a = f(a)
La valeur renvoyée par l'appelf(a)
est affecté au nom de variablea
. L'opération effectuée à l'intérieur de la fonction se retrouve répercutée sur la variable globalea
.
Tests, assertions et module Doctest
Préconditions
Comme nous l'avons vu pour la fonction ask_user_int
, il est souvent nécessaire de tester des préconditions sur les arguments d'une fonction, pour s'assurer que celle-ci fonctionnera bien selon le schéma voulu.
Une méthode pour tester les préconditions est d'utiliser des assertions.
L'instruction assert
de Python fonctionne de la manière suivante :
assert trouve_chaine('Toto', 'Toto va à la plage')==True, 'Meme casse pas trouvée'
L'instruction assert
teste un booléen, ici trouve_chaine('Toto', 'Toto va à la plage')==True
. Il peut alors se produire deux cas :
- soit le booléen est
True
, auquel cas l'interpréteur passe à la ligne suivante (il ne se passe rien de visible) ; - soit le booléen est
False
, auquel cas l'interpréteur arrête le code en levant une erreur de typeAssertionError
et affiche la chaine de caractère passée en second argument, ici'Meme casse pas trouvée'
.
Correction de la fonction ask_user_int
def ask_user_int(borne_min : int, borne_max : int, nom : str ='Inconnu' ) -> int :
""" Fonction demandant un entier compris entre borne_nf et borne_sup.
personnalisation du message avec le paramètre optionnel nom.
renvoi un objet de type entier.
"""
assert type(borne_inf) == int and type(borne_sup) == int, "Erreur de type sur borne_inf et borne_sup"
assert type(nom) == str, "Erreur de type sur nom"
assert borne_inf <= borne_sup , "borne_inf n'est pas inférieure à borne_sup"
repeter = True
while repeter :
...# Le code ici n'est pas changé
Testez maintenant cette fonction avec de mauvaises valeurs pour les arguments.
Réfléchir avant d'agir : écrire les tests avant la fonction
Lorsqu'on écrit une fonction, il est très important d'avoir une idée précise de ce que la fonction doit renvoyer, y compris dans les cas extrêmes ou cas spécifiques.
Par exemple, on pourrait considérer une fonction coefficient_directeur
qui donne le coefficient directeur d'une droite quand on lui passe en argument les coordonnées de deux points \(A\) et \(B\).
Je rappelle que le calcul du coefficient directeur de la droite \((AB)\) se fait par l'intermédiaire de la formule :
Ainsi nous aimerions que la fonction travaille avec 4 arguments de type entiers xA, yA, xB, yB
, qu'elle renvoie le coefficient directeur de \((AB)\) sous la forme d'un flottant si ce coefficient existe, et qu'elle renvoie None
quand il n'existe pas. On, définit ici ce qu'on appelle une interface de la fonction :
def coefficient_directeur(xA : int, yA : int, xB : int, yB : int) -> float :
""" Renvoie le coefficient directeur de la droite (AB) telle que :
A (xA ; yA) et B(xB ; yB), et les coordonnées de A ety B sont entières.
Dans le cas ou le coefficient directeur n'existe pas, renvoie None
"""
...
On souhaite donc prévoir en avance différents cas de fonctionnement de la fonction, et on aimerait vérifier que les calculs effectués par la fonction correspondent bien à ces cas.
Par exemple, nous aimerions que la fonction vérifie le test suivant :
>>> coefficient_directeur(2, 4, 3, 7)
3.0
Écrire des tests
- Écrire 5 tests prenant en compte tous les cas possibles d'utilisation de la fonction, en supposant que les types fournis en argument soient bien des entiers.
- Compléter la fonction
coefficient_directeur
afin qu'elle remplisse le rôle qui lui est demandé.
A venir !
Tester avec le module doctest
Pyhton étant user friendly, il permet au programmeur de tester automatiquement, grâce au module doctest
.
Un module Python est un fichier (ou un ensemble de fichiers) qui comporte(nt) des objets et des fonctions qui peuvent être ajoutés aux fonctionnalité de base de Python. Il en existe un très grand nombre, tous étant spécialisés dans un domaine. On trouve par exemple :
- le module math, qui contient beaucoup de fonctions mathématiques ;
- le module turtle, qui permet de dessiner géométriquement ;
- le module pygame, qui est un module permettant de gérer les différents éléments d'un jeu vidéo ;
- le module panda, qui est utilisé pour faire du traitement de données ;
- le module flask, qui permet de créer une application web
- ...
Un module doit être chargé en mémoire une fois (de préférence au début du code), par l'intermédiaire de la commande :
import nom_du_module
Mais non, ca ne se fait pas que comme ça !
Oui, vous avez raison, mais ce n'est pas le cas de ce cours, nous verrons l'import de modules plus tard dans l'année...
Le module doctest, lui, permet d'intégrer à la docstring un ensemble de tests qui sont vérifiés par l'appel de la fonction testmod du module doctest.
Par exemple, copiez-collez le code suivant dans un fichier :
# Zone d'import des modules
import doctest # On charge en mémoire le module doctest
# Zone de déclaration des fonctions
def times2(n : object) -> object:
"""
Fonction qui multiplie par 2, selon le type d'objet
>>> times2(4)
8
>>> times2(5.4)
10.8
>>> times2('a')
'aa'
"""
return 2*n
# Zone du script global
doctest.testmod() # Lance les tests des fonctions déclarées
L'appel à la fonction doctest.testmod()
déclenche les trois tests présents dans la doctsring, et vérifie que les résultats de la fonctions correspondent à ceux fournit dans la docstring.
Application 7 : Ajouter une fonction et des tests
Créez une fonction times3
qui multiplie un objet par 3, en écrivant les tests correspondants.
A venir !
Je me servirai de doctests ou bien d'assertions pour estimer la justesse de vos fonctions et de vos programmes. Une bonne idée serait de TOUJOURS fournir un jeu d'exemple avant de se lancer dans la construction d'une fonction.
Exercices
Dans tous les exercices suivants, on devra écrire pour chacune des fonction des assertions permettant de tester les préconditions.
Pour tester vos fonctions avec les jeux fournis, n'oubliez pas :
- d'importer le module avec
import doctest
; - de lancer les tests avec
doctest.testmod()
;
Vous pourrez créer un seul fichier contenant l'ensemble des fonctions ci-dessous.
-
Ecrire une fonction qui renvoie le maximum de deux nombres
ìnt
donnés :def maxi(a : int,b :int) -> int : """ Fonction qui renvoie le maximum de deux nombres de type int. >>> maxi(12,3) 12 >>> maxi(-5,9) 9 >>> maxi(6,6) 6 """
-
Écrire une fonction qui renvoie le minimum de deux nombres
int
donnés :def mini(a : int, b : int ) -> int : """ Fonction qui renvoie le minimum de deux nombres >>> mini(12,3) 3 >>> mini(-5,9) -5 >>> mini(6,6) 6 """
-
Écrire une fonction qui renvoie le maximum de trois nombres
int
donnés :def maxi3(a : int, b : int, c : int) -> int : """ Fonction qui renvoie le maximum de trois nombres >>> maxi3(5,12,3) 12 >>> maxi3(-5,-7,2) 2 >>> maxi3(6,6,6) 6 >>> maxi3(5,7,7) 7 """
-
Écrire une fonction qui renvoie le nombre intermédiaire dans trois nombres
int
donnésdef intermediaire(a : int, b : int, c : int) -> int : """ Fonction qui renvoie le nombre intermédiaire deux nombres >>> intermediaire(12,8,3) 8 >>> intermediaire(-5,9,0) 0 >>> intermediaire(7,7,7) 7 >>> intermediaire(7,4,7) 7 >>> intermediaire(4,4,7) 4 """
-
Écrire une fonction qui supprime tous les caractères qui ne sont pas des lettres (majuscules ou minuscules, sans accents) d'une chaine de caractères donnée.
def rienQueDesLettres(chaine) : """ >>> rienQueDesLettres(' toto ') 'toto' >>> rienQueDesLettres('123Toto456') 'Toto' >>> rienQueDesLettres("Et!C'est Toto ?") 'EtCestToto' """
-
Écrire la fonction coefficient_directeur qui vérifie les conditions ci-dessous
def coefficient_directeur(xA,yA,xB,yB) : """Fonction renvoyant le coefficient directeur de la droite (AB) en connaissant les coordonnées des points A et B, ou None si c'est impossible >>> coefficient_directeur(0,0,1,5) 5 >>> coefficient_directeur(0,0,2,10) 5 >>> coefficient_directeur(3,4,4,6) 2 >>> coefficient_directeur(3,4,4,6) 2 >>> coefficient_directeur(3,4,4,4) 0 >>> coefficient_directeur(3,4,4,3) -1 >>> coefficient_directeur(3,4,3,7)==None True >>> coefficient_directeur(3,4,3,4)==None True >>> coefficient_directeur(4,4,3,4)==None False """ ###VOTRE CODE ICI
-
Écrire une fonction - et le jeu de test correspondant, qui calcule l'ordonnée à l'origine d'une droite \((AB)\), en prenant en paramètres les coordonnées des points \(A\) et \(B\) comme la fonction précédente, et qui renvoie None si c'est impossible.
-
Écrire une fonction - et le jeu de test qui va avec, qui renvoie l'équation réduite de la droite \((AB)\), en prenant en paramètres les coordonnées des points \(A\) et \(B\) comme dans les fonctions précédentes.
-
Écrire une fonction - et le jeu de test qui va avec, qui teste si une chaine de caractère en paramètre est trans-typable en un nombre flottant, puis une fonction
ask_user_float
qui demande à un·e utilisateur·trice de saisir un nombre flottant compris entre deux bornes minimum et maximum flottantes, et ce de manière dumbproof.