Nous avons vu que les boucles permettaient de répéter une série d’instructions plusieurs fois de suite, mais lorsqu’on doit répéter une série d’instructions une fois puis ailleurs encore une autre fois, etc … on utilise les fonctions ou procédures. Elles ont l’avantage :
- De regrouper des blocs de code : cela évite la répétition de code
- De faciliter la maintenance et les tests du code : tout est regroupé
- De réinvestir le code : il est peut être dans un module séparé puis importé
- D’améliorer la conception et la compréhension du programme : Une fonction est associée à une sous-tâche particulière et elle est plus simple à appréhender que le programme lui-même.
7.1 Eviter de se répéter
Intéressons-nous au panneau d’affichage dans un aéroport :
L’employé chargé des affichages pourrait envisager le programme suivant :
1 2 3 4 5 6 |
print("Embarquement pour Bordeaux à 10h35") print("Embarquement pour Toulouse à 10h43") print("Embarquement pour Marseille à 10h57") print("Embarquement pour Lille à 11h03") print("Embarquement pour Strasbourg à 11h10") print("Embarquement pour Lyon à 11h17") |
Il semble cependant inutile de re-taper à longueur de journée les mêmes mots « Embarquement pour», « à ».
Une solution plus économique consiste à écrire une séquence d’instructions unique destinée à être ré-utilisée aussi souvent que nécessaire. C’est le premier objectif de la notion de fonction. Examinons le programme suivant :
1 2 3 4 5 6 7 8 9 |
def vol(destination, heure) : print("Embarquement pour ", destination, " à ", heure) vol("Bordeaux", "10h35") vol("Toulouse", "10h43") vol("Marseille", "10h57") vol("Lille", "11h03") vol("Strasbourg", "11h10") vol("Lyon", "11h17") |
Ce programme fournit exactement le même résultat que le précédent. Nous avons créé une fonction vol qui est utilisée plusieurs fois de suite, pour peu qu’on lui fournisse, lors de son appel, les paramètres dont elle a besoin pour fonctionner.
7.2 Syntaxe d’une fonction
Une fonction est un nom associé à un bloc d’instructions choisies pour réaliser un traitement particulier.
Fonctionnement :
- En Python, l’écriture d’une fonction commence toujours par le mot def
- Vous pouvez choisir le nom que vous voulez pour la fonction.
- Souvent une fonction a besoin de données pour être exécuter, on les passe alors en paramètres dans la parenthèse, séparées par des virgules, juste après le nom de la fonction. Ces données sont appelés les arguments de la fonction et le passage se fait par affectation.
- Comme les instructions if, for ou while, l’instruction def est une instruction composée : la ligne démarrant l’instruction def est terminée par deux points « : », lesquels introduisent un bloc d’instructions qui doit être indenté.
- La fonction s’utilise ensuite dans le reste du programme par un simple appel :
Nom_De_La_Fonction(Valeurs_des_paramètres)
Remarques :
- Des fonctions, nous en utilisons depuis le premier chapitre : l’instruction print(« Bonjour ») n’est autre que l’appel de la fonction print, avec en argument la valeur « Bonjour » de la variable à afficher.
- En effet, Python comprend un très grand nombre de fonctions prédéfinies : des fonctions déjà définies par les développeurs de Python.
- A celles-ci, nous allons maintenant en ajouter d’autres, que nous coderons nous-mêmes en fonction de nos besoins.
Exemple : Exécutez le programme suivant, que remarquez vous ?
Même question, après avoir rajouté les lignes :
1 2 3 |
fct() print(“INTRUSION”) fct() |
Exercice : Olympiade
Réaliser un programme 16_Olympiade_carre.py à partir du programme Olympiade_carre du début et simplifions-le à l’aide d’une fonction carré qui prendra en paramètre la couleur voulue afin de tracer en couleur un carré.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
from turtle import * up() width(5) goto(-200,0) down() color('blue') forward(90) left(90) forward(90) left(90) forward(90) left(90) forward(90) left(90) up() goto(-140,-60) down() color('yellow') forward(90) left(90) forward(90) left(90) forward(90) left(90) forward(90) left(90) up() goto(-80,0) down() color('black') forward(90) left(90) forward(90) left(90) forward(90) left(90) forward(90) left(90) up() goto(-20,-60) down() color('green') forward(90) left(90) forward(90) left(90) forward(90) left(90) forward(90) left(90) up() goto(40,0) down() color('red') forward(90) left(90) forward(90) left(90) forward(90) left(90) forward(90) left(90) up() done() |
7.3 Vraies fonctions et procédures
Les fonctions écrites jusqu’à présent se contentent de réaliser des actions (afficher un message, par exemple) sans retourner de valeurs. C’est ce l’on appelle des procédures. Une vraie fonction doit, en plus, lorsqu’elle se termine, renvoyer au moins une valeur : comme une fonction en mathématiques qui renvoie au final l’image d’un nombre : lorsque l’on appelle f avec la valeur 3, elle renvoie le nombre f(3).
1 2 3 4 5 6 7 |
def carre(nombre) : resultat = nombre**2 return resultat a = carre(12) print("Le carré de 12 est : ") print(a) |
L’instruction return, qui vient toujours en dernière ligne de la fonction, définit ce que doit renvoyer la fonction.
La valeur (ou l’objet) renvoyée pourra, par exemple, être stockée dans une variable et ré-exploitée par le programme.
Une fonction peut retourner plusieurs valeur simultanément, il suffit de placer les variables à retourner après l’instruction return.
Exercice : Tableau de Valeur
Réaliser un programme 17_tableau_valeur.py qui affiche le tableau de valeur de la fonction f(x)=2x^3+x-5 entre les borneinf et bornesup saisies par l’utilisateur. Vous nommerez mafonction la fonction d’argument x qui retourne l’image f(x) et vous nommerez tabuler la procédure qui affiche le tableau de valeur à partir des arguments : mafonction, borneinf, bornesup et nbpas.
Exercice : Indice de Masse Corporelle.
L’indice de masse corporelle (IMC, en anglais Body Mass Index, BMI) est une grandeur qui permet d’estimer la corpulence d’une personne. L’organisation mondiale de la santé a défini, en 1997, cet indice de masse corporelle comme le standard pour évaluer les risques liés au surpoids chez l’adulte. Il a également défini des intervalles standards (maigreur, indice normal, surpoids, obésité) en se basant sur la relation constatée statistiquement entre l’IMC et le taux de mortalité.
Selon la classification de l’OMS : IMC = masse⁄taille2
Par exemple, pour une personne de 65 kg pour 1,70 m : IMC = 65⁄1,702 ≈ 22,5.
Pour votre nouveau site web, « sport_et_tonus.com », coder un programme « 18_IMC.py » :
- commençant par définir une fonction IMC, qui calculera l’IMC en fonction du poids et de la taille,
- demandant à l’utilisateur son poids et sa taille,
- affichant au final l’IMC de l’utilisateur.
7.4 Variables locales et variables globales
Testez les lignes suivantes et expliquez l’erreur :
Les variables affectées dans le bloc de la fonction sont des variables locales , c’est le cas de base et de compteur :
- elles n’existent que dans le bloc de la fonction pendant son exécution
- elles sont détruitent à la sortie du bloc de la fonction
- elles prennent de nouvelles valeurs à chaque appel de la fonction
Testez les lignes suivantes :
Les variables affectées hors des fonctions sont des variables globales, c’est le cas des variables txt et val:
- elles existent pendant toute la durée de l’exécution du programme
- elles sont uniques dans tout le programme
- elles sont directement accessibles dans les fonctions mais non modifiables
Nous constatons que la variable « val » n’a pu être modifiée à l’intérieur de la fonction, puisque son affichage final en dehors de la fonction donne toujours 5.
Pire encore, nous remarquons que le nom de variable « val », est ici utilisé pour définir deux variables différentes : l’une globale, l’autre locale.
Ces deux variables sont bel et bien des variables distinctes, indépendantes, obéissant à une règle de priorité :
à l’intérieur d’une fonction (où elles pourraient entrer en compétition), ce sont les variables définies localement qui ont la priorité.
Ainsi lors de l’utilisation d’une variable dans une fonction, Python commence par rechercher s’il existe une telle variable dans l’espace des variables locales à la fonction. Ce n’est que s’il n’en trouve pas qu’il ira chercher si cette variable existe au niveau global.
Il arrivera bien souvent qu’une fonction ait besoin de modifier une variable globale. Pour cela, il suffit d’utiliser l’instruction global, suivi du nom de la variable, qui permet d’indiquer à l’intérieur d’une fonction, qu’une variable devra être traitée de façon globale.
Examinons l’exemple suivant :
1 2 3 4 5 6 7 8 9 10 |
def grandir() : global age age = age + 1 age = 15 grandir() print(age) >>> 16 |
7.5 Fonction récursive
Une fonction est dite récursive lorsqu’elle s’appelle elle-même.
Exemple: La fonction factorielle de n, noté n !
La fonction récursive est très proche de la définition mathématique.
Complétez le programme :
>
Le programme empile les appels récursifs jusqu’à atteindre la condition terminale puis dépile les valeurs.
Désormais nos programmes auront la structure suivante :
- Importation des librairies et fonctions prédéfinies nécessaires au programme,
- Définition de nos fonctions personnelles,
- Main, ou encore en français : corps principal du programme.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
## Importation des librairies et fonctions prédéfinies nécessaires au programme ## from random import randint #################### Définition de nos fonctions personnelles #################### def lancer() : """ fonction simulant un lancer de dé """ return randint(1,6) ###################################### Main ###################################### #### « corps principal du programme » #### n = int(input("Combien de fois voulez-vous lancer le dé ?")) for i in range(1,n+1) : essai = lancer() print("Lancer ", i , " : ") print(essai) |