Les fonctions sont fondamentales en programmation.
Il s'agit de l'unité de travail permettant la réutilisation et la programmation modulaire.
Nous allons voir dans ce cours en quoi les fonctions sont importantes et comment les définir et les appeler.
La solution naïve consiste à dire qu'il suffit de changer la valeur de a0 puis de relancer le script.
Ce n'est pas vraiment réutilisable : il faut modifier le code source à chaque fois que l'on souhaite tester une nouvelle valeur.
Vous n'avez pas besoin de changer le code source de votre calculatrice pour faire un nouveau calcul.
Il s'agit d'une manière un peu complexe d'afficher 1.
Pour afficher la somme d'une racine carrée et d'une racine cubique, on est obligé d'implémenter 2 fois Newtown-Raphson et de copier-coller nos algorithmes.
On souhaite réutiliser nos algorithmes.
Si on devait recopier chaque algorithme à chaque fois qu'on doit l'appeler avec une valeur particulière, ce sera ingérable.
Pour gérer des projets complexes, on est obligé de construire des couches d'abstraction.
Chaque couche d'abstraction s'appuie sur les couches inférieures pour fournir des services de plus haut niveau.
Une couche d'abstraction abstraie une partie de la complexité.
Cela permet au final de manipuler facilement des composants qui eux-mêmes sont complexes.
Dans ce diagramme, on a une application avec une interface graphique et des APIs qui permettent de manipuler un modèle de données qui s'appuie lui-même sur une base de données, sur des fonctions mathématiques, etc.
Si les couches d'abstraction n'existaient pas, l'utilisateur final devrait lui-même manipuler les fonctions mathématiques.
Les jeux vidéos seraient potentiellement moins funs et plus éducatifs !
Ici, rien n'est affiché.
On ne fait que définir une procédure.
Ici, on défini une procédure, puis on l'appelle 3 fois.
Par conséquent, le message est affiché 3 fois dans la sortie standard.
Evidemment, il peut y avoir plusieurs instructions dans une procédure.
Une procédure peut contenir ses propres variables locales.
Une procédure possède son propre contexte d'exécution.
La valeur de la variable x passée en argument de la fonction carre est remplacée par le nombre au niveau de l'appel de procédure.
Ainsi, pour carre(2), on a x == 2.
De même, pour carre(3), on a x == 3.
On a désormais des procédures réutilisables et utiles.
On peut évidemment passer autant d'arguments que nécessaire.
Cet exemple est en C#.
On doit utiliser un autre langage de programmation car le Python ne supporte pas le passage par référence.
Un argument sans valeur par défaut ne peut pas succéder à un argument avec une valeur par défaut.
La portée d'une variable est limitée a la procédure dans laquelle elle est définie.
Les arguments d'une procédure sont des variables de cette procédure.
Ainsi, dans le contexte de h, on appelle g(b, a), avec b == 5 et a == 3.
Dans le contexte de g, le premier argument a == 5, et le second argument b == 3.
La première fois que l'on appelle f, on affiche donc 5.
La deuxièmre fois que l'on appelle f, la variable a dans le contexte de f est a == 3.
Donc on affiche 3 la deuxième fois.
Même principe que précédemment.
La différence ici est que la variable globale a n'affecte pas le contexte de f.
On peut accéder en lecture seule à une variable globale dans le contexte d'une fonction.
On dit que la variable est globale car elle n'est locale à aucune procédure.
On ne peut pas accéder en écriture à une variable globale par défaut.
On doit informer explicitement que l'on souhaite réutiliser la variable a du contexte global.
Le mot clé return permet de retourner un résultat.
On peut affecter ce résultat à une autre variable.
En pratique, vous avez déjà utilisé de nombreuses fonctions : range, int, float, input, print, etc.
Plutôt que d'afficher le résultat dans la sortie standard, on préfère le renvoyer.
Cela offre plus de flexibilité et est plus évolutif.
On vient de se faire une petite bibliothèque composée des fonctions somme, racine_carre, et racine_cubique.
On va donc pouvoir répondre à notre problématique initiale de simplification de notre code.
Le code initial pour résoudre ce problème était beaucoup plus conséquent, comme vous pourriez le voir en revenant sur les premières diapositives.
L'emploi, ou non, de plusieurs returns n'affecte pas les performances d'exécution.
Il existe des débats concernant l'élégance de l'emploi de plusieurs returns.
Il s'agit essentiellement d'une histoire de préférence personnelle.
Souvent, une fonction écrit avec plusieurs returns comporte moins de variables et est plus simple à comprendre et à maintenir.
En effet, une fonction équivalente avec un unique return devrait employer au moins une variable supplémentaire pour sauvegarder le résultat à renvoyer.
Il est possible de retourner plusieurs résultats en les séparant par des virgules.
On les récupère de la même manière au niveau de l'appel de fonction.
Nous verrons d'autres exemples plus loin dans ce cours.
On peut dans certains cas se retrouver avec plus de commentaires que de code.
Il faut faire attention à bien garder les commentaires synchronisés avec l'implémentation.
Il s'agit de la docstring de la fonction native round.
On peut utiliser la même commande pour obtenir les docstring que l'on a défini.
La fonction print prend un nombre variable (en anglais : variadic) d'arguments.
La fonction max prend également un nombre variable d'arguments.
En pratique, de nombreuses fonctions en Python offre cette possibilité.
Contrairement au précédent exemple, celui-ci supporte le cas où la liste variable d'arguments est vide.
On emploie ici une étoile supplémentaire.
Cette syntaxe deviendra plus claire lorsque nous parlerons des dictionnaires lors d'un prochain cours.
La récursivité est un concept avec lequel les étudiants ont souvent des difficultés au départ.
Il est utile d'introduire cette notion avec une intuition géométrique puis un exemple plus textuel avant de passer à une définition plus formelle.
Attention : cette page contient un git animé inactif dans la version pdf.
Images de Wikipedia.
Liens :
- https://upload.wikimedia.org/wikipedia/commons/thumb/2/21/Mandel_zoom_00_mandelbrot_set.jpg/640px-Mandel_zoom_00_mandelbrot_set.jpg
- https://upload.wikimedia.org/wikipedia/commons/a/a4/Mandelbrot_sequence_new.gif
Attention : cette page contient un git animé inactif dans la version pdf.
Images de Wikipedia.
Lien : https://upload.wikimedia.org/wikipedia/commons/f/fd/Von_Koch_curve.gif
On défini une valeur constante pour le premier élément.
On défini la valeur d'un élément par rapport aux éléments précédents.
Cette définition est identique à la définition mathématiques.
Par contre, cette définition est complexifiée inutilement par la nécessité de passer les valeurs de a, b, c et b0 aux appels récursifs de f.
On va simplifier cette définition avant de la tester puis de l'instrumenter.
On voit bien ici que f(3) mène à l'évaluation de f(2), qui mène à l'évaluation de f(1), qui mène à l'évaluation de f(0).
f(0) contient la condition de fin de la récursivité. On le voit car f(0) n'appelle pas f.
Une fois que f(0) est affiché et évalué, on remonte la pile d'appels et on effectue les calculs.
On calcule d'abord f(1) = 2 * 0 + 1 = 1, et on l'affiche.
On calcule ensuite f(2) = 2 * 1 + 1 = 3, et on l'affiche.
On calcule enfin f(3) = 2 * 3 + 1 = 7, et on l'affiche.
A chaque appel récursif, le contexte d'appel doit être sauvegardé.
Cela augmente progressivement la quantité de mémoire nécessaire au calcul.
Par ailleur, la callstack (pile d'appels) est limitée par le système d'exploitation.
Lorsque l'on appelle f avec 1 000 000, on doit avoir une profondeur de pile d'appels de 1 million.
Or, le système d'exploitation utilisé ne permet pas d'avoir une telle prodondeur.
Par conséquent, l'exécution s'arrête lorsque l'on atteint les limites du système d'exploitation.
Ce type de problème s'appelle : stack overflow (surchage de pile d'appels).
On va voir ce que sont ces fonctions d'ordre supérieur.
Comme vous pouvez le voir, il est possible de définir des sous-fonctions.
Ces fonctions ne peuvent être appelées que depuis leur contexte directe.
Elles sont invisibles de l'extérieur.
Ces fonctions internes ne devraient jamais faire plus de 1 à 3 lignes.
En français, le terme "lambda" peut avoir une connotation péjorative signifiant : commun, quelconque voire inintéressant.
Le terme "fonction lambda" se retrouve dans beaucoup de langages de programmation.
Ce terme vient du calcul lambda.
Les fonction lambda sont intéressantes et pratiques.
Il n'est évidemment pas possible de définir une fonction lambda récursive.
En effet, une fonction lambda n'a pas de nom et ne peut donc pas savoir comment s'appeler elle-même.
C'est la raison pour laquelle nous utilisons ici le calcul du terme général d'une suite arithmético-géométrique.
Il s'agit de la version itérative de l'algorithme récursif vu dans les diapositives précédentes.
Image de Wikipedia.
Lien : https://upload.wikimedia.org/wikipedia/commons/3/33/Spaghettata.JPG
On peut espérer que les 2 dernier points vont évoluer dans le bon sens.
Les langages fonctionnels sont extrêmement intéressants mais certains cas d'usage ne sont pas supportés, comme la programmation temps réelle embarquée.