1BCPST1 Décembre 2017
Mathématiques TP d’informatique n
o3 II – Éléments de programmation
3o) Fonctions
a) Définition et premiers essais
Python contient un nombre important de fonctions prédéfinies, ce qui n’empêche pas l’utilisateur de créer ses propres fonctions. Cela peut-être une fonction numérique, mais plus généralement une application (c’est-à-dire un procédé qui à une variable associe une autre variable, tous les types gérés par Python étant possibles).
Exemple 1 :
Un professeur au système de notation très complexe dispose de notes s’écrivant sous forme décimale. Il souhaite arrondir ses notes au demi-point le plus proche, et il écrit pour cela une fonction qui automatise le procédé : def arrondi(n):
"Cette fonction renvoie l’arrondi d’une note au demi-point le plus proche"
return round(2∗n)/2
Vous allez tester cette fonction directement dans le shell : après avoir tapé la première ligne et appuyé sur la touche Entrée, vous constaterez que l’invite de commande principaleIn [x]:devient une invite de commande secondaire . . .:. Avant de taper la chaîne de caractère de la ligne 2, il faudra appuyer sur la touche tabulation pour que la ligne soit indentée (toujours le principe des blocs d’instructions que l’on reconnaît grâce à leur indentation).
On fait de même pour la ligne suivante, et une fois la fonction terminée on valide par Entrée jusqu’à ce qu’on retombe sur l’invite de commande principale.
Il est alors possible d’utiliser la fonction comme n’importe quelle autre fonction, en l’appelant par son nom et en lui fournissant une valeur entre des parenthèses (qui sera affectée à la variablenlors de l’exécution des lignes de commande écrites dans la fonction). Testezhelp(arrondi)dans le shell pour observer l’un des intérêts de la présence de la ligne 2 dans l’exemple 1.
Observons bien les différents éléments d’une fonction, facultatifs ou non : la définition d’une fonction commence systématiquement par le motdef, suivi du nom de la fonction puis entre parenthèses la liste des paramètres qui seront fournis à la fonction par l’utilisateur. Cette liste est facultative, une fonction pouvant tout à fait ne nécessiter aucun paramètre. Les « : » conduisent ensuite à la création de blocs indentés délimitant les instructions qui seront exécutées à chaque appel de la fonction.
La première ligne est facultative, elle permet de documenter la fonction, ce qui est vital pour les fonctions des- tinées à être réutilisées dans le futur. On écrit ensuite un algorithme qui permettre d’atteindre le but recherché.
Le motreturnn’est pas indispensable : on l’inclut si l’on souhaite que la fonction renvoie une valeur, qui puisse être utilisée ensuite comme n’importe quelle variable (on pourra par exemple écrirex=arrondi(2.3)). Une fonc- tion peut aussi se contenter d’afficher quelque chose à l’aide de la commandeprint. Attention : l’utilisation de returnmet fin à la fonction, toutes les lignes suivantes seront ignorées (ce qui peut être parfois bien pratique...
mais aussi dangereux, notamment sireturnse situe dans une boucle).
Exemple 2 : La fonction racine carrée (présente dans Python) pourrait être définie de 2 façons : def sqrt(x):
return x∗ ∗(1/2) ou:
def racine(x):
print(x∗ ∗(1/2))
Tester ces deux fonctions pour calculerp
2, observer la différence. Répéter le test pour le calcul dep 2+p
2, la différence devrait être encore plus visible...
Page 1/4
1BCPST1 Décembre 2017 Remarque : Notons (etn’oublions plus jamais) que dans la définition d’une fonction qui corresponde au sens mathématique du terme (fonction qui prend une valeur et en renvoie une autre), il ne doit pas y avoir de commande inputcar l’utilisateur est obligé d’entrer un nombre lors de l’appel de la fonction, faute de quoi un message d’erreur s’affiche, et pas de commandeprintnon plus (sauf éventuellement pour afficher des messages d’erreurs, mais dans ce casreturnfait ça tout aussi bien).
Une fois définie, une fonction peut être utilisée autant de fois qu’on le souhaite, elle peut même être incluse dans la définition d’une autre fonction. Les tests précédents ont été réalisés directement dans le shell, mais vous avez pu constater à quel point la définition d’une fonction n’était pas des plus pratiques.
Il est donc intéressant de pouvoir le faire par l’intermédiaire de l’éditeur de scripts, afin de sauvegarder des fonctions qui pourront être retrouvées et réutilisées aux séances suivantes. Pour cela, il suffit d’écrire les dif- férentes lignes de définition de la fonction dans l’éditeur, et de sauvegarder tout cela dans un fichier et d’exécuter le fichier : une fois exécuté, la fonction est définie dans Python (il faut donc bien penser à exécuter après chaque modification de la fonction).
EXERCICE1:Tables de multiplication
1o) Créer une fonction tablequi affiche en ligne les 100 premiers multiples (non nuls) d’un entier donné et rien d’autre. Précisons une option de la commandeprint qui permet d’éviter le retour systématique à la ligne : la dernière chose présente dans les parenthèses de la commande doit être,end=’ ’
2o) Créer une fonction qui affiche les 10 premiers multiples (non nuls) des 10 premiers entiers impairs, avec la présentation suivante :
Table de 1 : 1 2 3 4 5 6 7 8 9 10 Table de 3 : 3 6 9 12 15 18 21 24 27 30 etc...
Remarque : Dans le cas où l’on souhaite que la fonction renvoie plusieurs résultats, on peut tout mettre dans une liste qui sera le résultat renvoyé par la fonction :
def arrondi(n):
"Cette fonction renvoie l’arrondi d’une note au demi-point le plus proche et l’écart entre note et arrondi"
a=round(2∗n)/2 return[a,abs(a−n)]
Tester cette fonction avec par exemplearrondi(13.424). Avec vos souvenirs sur les listes, sans modifier la fonctionarrondi, comment faire en sorte de n’afficher que la note arrondie de 13.424 (en restant dans le shell) ? EXERCICE2:Comptage de caractères
Définir une fonctionCompteCar(car, chaine)qui compte le nombre de fois où l’on rencontre le caractère cardans la chaîne de caractèreschaine.
b) Gestion des variables
Les variables définies en argument de la fonction sont des variables dites locales : comme vous venez sûrement d’utiliser votre fonctionCompteCar de l’exercice 2, essayez dans le shell de faire afficher la variablecar, ou la variable de votre fonction qui vous a servi de compteur, ce qui vous en dira plus sur la commandereturnet sur la gestion des variables dans une fonction. Qu’à cela ne tienne, en supposant par exemple que votre compteur s’appelaiti, (re)définissez vous-même cette variable i en lui donnant une valeur arbitraire dans le shell, puis relancez la fonctionCompteCar: la valeur de la variableia-t-elle été modifiée ?
Enfin, penchons-nous sur la notion de variable globale, à l’aide des exemples suivants, à tester dans le shell (ne pas oublier la tabulation permettant de réaliser une indentation) :
Page 2/4
1BCPST1 Décembre 2017 Exemple 3 :
In [1]: def testvar():
...: a=-5
...: return([a,b]) ...:
In [2]: a,b=-1,2 In [3]: testvar() In [4]: print(a,b)
Exemple 4 :
In [1]: def testvar(a):
...: a=a+5 ...: b=4
...: return([a,b]) ...:
In [2]: a,b=-1,2 In [3]: testvar(a) In [4]: print(a,b)
À la lumière de ces exemples, essayez de bien comprendre ce qui se passe avec les variables dans une fonction, voire de l’expliquer si vous y parvenez...
Ce fonctionnement peut paraître curieux voire pénible, mais il est au contraire plutôt avantageux en pratique : nul besoin de se préoccuper des noms de variables utilisés dans les fonctions, étant donné que ces variables n’ont pas d’existence propre en dehors de la fonction. Dans le cas où vous voudriez absolument qu’une fonction modifie une variable globale (une variable définie en dehors de la fonction), il faut utiliser la commandeglobal qui permet de changer de statut la variable concernée. Retestez l’exemple 4 précédent en insérant la ligne suiv- ante immédiatement après la ligne de définition de la fonction (attention, une variable donnée en paramètre ne pouvant être déclarée comme globale, il faut reprendre l’exemple 4 avec une fonctiontestvarne prenant aucun paramètre) :
... global a c) Modules
Dans le cas où on a besoin de plusieurs fonctions pour un programme plus complexe, il suffit de les sauvegarder dans un même fichier, portant l’extension « .py ». On rend ensuite accessible les fonctions dans le shell soit en exécutant le-dit fichier, soit grâce à la commande suivante :
from nom de votre fichier sans l’extension import*
Ceci permet en fait de définir ce que l’on appelle un module, qui pourra contenir autant de fonctions qu’on le souhaite.
Avant de vous lancer de manière effrénée dans les exercices suivants, il est important de faire le point sur les règles d’or à retenir pour tester une fonction ou un script lorsqu’on a fini de le « déboguer », c’est-à-dire lorsqu’il ne renvoie plus de messages d’erreur :
– tester avec des valeurs pour lesquelles on sait ce qui va arriver, où l’on sait ce que la fonction ou le script doit produire (déterminer le résultat attenduavantl’exécution de l’algorithme) ;
– éviter les cas trop simples dans un premier temps, éviter de s’en tenir à des cas très particuliers où le résultat fourni serait correct par miracle ;
– en présence d’une disjonction de cas, tester tous les cas ;
– ne pas oublier à la fin de tester les cas particuliers, voire pathologiques.
EXERCICE3:Factorielle, le retour
Écrire une fonctionfactoriellequi renvoie la factorielle d’un entier, et qui renvoie un message d’erreur si le nombre fourni en argument n’est pas un entier (on pourra réutiliser les scripts des TP 1 ou 2). Dans la foulée, écrire une fonctionbinomequi renvoie le coefficient du binôme associé aux nombres fournis (n’hésitez pas à réutiliser vos scripts précédents).
EXERCICE4:Trinôme
Écrire une fonction qui renvoie les solutions de l’équationax2+bx+c=0.
Dans le cas où la fonction à définir est spécifique à l’algorithme que l’on est en train d’écrire, si elle n’a pas
Page 3/4
1BCPST1 Décembre 2017 vocation à être réutilisée, on se contente de d’inclure cette fonction au début du script, avant le programme prin- cipal. Un programme Python se présente donc habituellement sous la forme suivante :
##################################
# Programme Test #
# Auteur : un illustre inconnu #
##################################
#Ce programme ne fait pas grand chose mais il est joliment écrit
#################################################################
# Importation de modules externes indispensables import turtle,numpy
#################################################################
# Définition locale de fonctions def arrondi(n):
"Cette fonction a déjà été documentée précédemment"
a=round(2*n)/2 return [a,abs(a-n)]
#################################################################
# Corps principal du programme
print(’Bonjour à tous, soyez prêts à vivre une expérience inoubliable avec ce programme’) t=input(’Entrez un texte qui ne servira à rien’)
n=0
while n<11:
n+=1
print(’la note sur 20 attribuée à ce programme vaut’,arrondi(n/10)[1])
print("N’hésitez pas à relancer ce programme s’il vous a plu, et à le diffuser autour de vous") EXERCICE5:Dichotomie
Écrire une fonctiondichotomiequi permette de trouver une valeur approchée d’une solution d’une équation du type f(x)=ksur un intervalle [a,b]. La fonction dichotomie devra prendre comme arguments : une fonction (f), les bornes de l’intervalle (aetb), la valeur (k) dont on cherche un antécédent parf, et la précision souhaitée.
Rappelons (?) le principe de la dichotomie : soit f une fonction continue sur un intervalle [a , b], telle que f(a)<f(b). On suppose quek∈£
f(a);f(b)¤
, et on cherche à déterminerc∈[a;b] tel que f(c)=k. On définit pour cela deux suites (un) et (vn) : on part deu0=aetv0=bet on noted0=u0+v0
2 (le milieu de l’intervalle...). Si f(d0)≤k, alors on poseu1=d0etv1=v0, et sinon on poseu1=u0etv1=d0. On poursuit la méthode précédente en partant cette fois de l’intervalle [u1, v1] pour définiru2etv2 en s’appuyant sur le milieu de l’intervalle. On s’arrête dès que l’écart entre les bornes de l’intervalleunetvnest inférieur à la précision souhaitée.
On s’appuiera en premier sur la fonction racine carrée pour tester la dichotomie (voir la remarque ci-dessous pour une explication sur comment fournir en argument d’une fonction quelque chose qui est une fonction).
Remarque : Parmi les variables fournies en argument dans une fonction que l’on définit, il peut tout à fait y avoir une fonctionf. Dans ce cas, lors de l’appel à la fonctiondichotomie, il suffira quefdésigne soit une fonction connue de Python(sin,sqrt, etc...), soit une fonction définie par l’utilisateur, comme la fonctioncube:
def cube(a) return a**3
Page 4/4
