fonctions python

Identification

Infoforall

7 - Fonctions et variables


Nous allons voir un aspect fondamental de la programmation : la possibilité d'insérer des "mini-programmes" dans les programmes de façon à créer de nouvelles actions. Vous avez déjà utilisé de nombreuses fois les fonctions. Lesquelles ? print() est une fonction (native), int() est une fonction (native)...

Il s'agit juste d'un premier contact. Les fonctions vont être vues sur plusieurs activités.

Nous allons voir aujourd'hui comment créer vos propres fonctions si l'action que vous voulez effectuer n'est pas gérée par l'une des fonctions natives. Nous allons ici surtout voir comment fonctions et variables interagissent.

Commençons par vous montrer ce qu'on peut faire assez facilement avec les fonctions (et qui peut s'avérer impossible ou presque sans leur intervention ):

animation d'introduction

Téléchargez le code à l'aide de l'image et lancez le. Nous obtenons une animation.

Le mini-projet lié à cette activité vous permettra de vous appropier ce petit programme et vous parviendrez même à le modifier.

Autre chose réalisable : un système réactif. Ici, on reprend l'idée du Simon pour obtenir un système qui réagit aux clics de souris :

Sans fonction, difficile de réaliser ceci...

Logiciel nécessaire pour l'activité : Python 3

Evaluation ✎ : question 07-13-14-18-19-20

Documents de cours : open document ou pdf

Résumé : Version HTML ou fond blanc ou ou PDF (couleur ou gris)

1 - Premieres déclarations de fonctions

01° Mettre le programme suivant en mémoire. Il contient deux fonctions nommées fois2() et plus2().

1 2 3 4 5 6 7
def fois2(x): resultat = x * 2 return resultat def plus2(x): resultat = x + 2 return resultat

Question :

Afficher l'onglet VARIABLES de Thonny et lancer le programme dans Thonny. Qu'est ce qui apparaît dans la mémoire ?

...CORRECTION...

Ce programme ne fait rien, SAUF qu'on crée deux nouvelles "variables" qui porte le nom des fonctions.

On obtient simplement cela :

résultat dans thonny

Par contre, on comprend vaguement que l'une doit faire une addition et l'autre une multiplication.

C'est l'indentation vers la droite qui permet à Python de comprendre quelles instructions appartiennent à la fonction, ou pas. Il faut donc placer une tabulation ou 4 espaces de suite pour savoir qu’elles sont les instructions rattachées au bloc. De plus, on remarquera qu’on met un double point [ : ] après la première ligne de la déclaration. Sans ce symbole, vous déclenchez une erreur..

Les lignes 2 et 3 appartiennent à la fonction déclarée ligne 1 puisqu'elles sont décalées de 4 espaces vers la droite.

1 2 3 4 5 6 7
def fois2(x): ....resultat = x * 2 ....return resultat def plus2(x): ....resultat = x + 2 ....return resultat

02° Vérifier que les fonctions sont bien en mémoire. Exécuter les commandes suivantes dans la console de Python et observer les réponses.

>>> plus2 >>> plus2(8) >>> fois2 >>> fois2(20)

Question

Pour lancer l'exécution d'une fonction doit-on juste taper son nom ou doit-on rajouter les parenthèses ?

...CORRECTION...

On obtient ceci

>>> plus2 <function plus2 at 0x7fd63eabb6a8> >>> plus2(8) 10 >>> fois2 <function fois2 at 0x7fd63eabb730> >>> fois2(20) 40 >>>

On voit donc qu'il faut rajouter les parenthèses.

Si on tape juste le nom, l'interpréteur Python nous dit qu'il trouve bien une fonction qui a ce nom et donne même une indication liée à son identifiant-mémoire.

03° Peut-on exécuter autant de fois qu'on le veut une fonction ? Tenter de le vérifier en faisant l'appel d'une des fonctions plusieurs fois de suite.

>>> plus2(8) 10 >>> plus2(10) ??? >>> plus2(20) ???

Qu'est-ce qu'une fonction ? :

Une fonction est un moyen de stocker des instructions plutôt que du contenu (integer, float, strings...) Une fonction ne contient pas une valeur ou un texte mais des instructions.

Pour exécuter les instructions, il suffit en faire l'appel : mettre le nom de la fonction et placer les données sur lesquelles on veut qu'elle travaille entre parenthèses. Exemple :

>>> fois2(20) 40

Pour comprendre comment la fonction fonctionne lors d'un appel, il faut justaposer la première ligne de sa déclaration et la ligne de son appel.

1
def fois2(x):
>>> fois2(20) 40

On voit donc ici qu'on envoie l'argument 20 qui va être mémorisé lors de cet appel dans le paramètre x.

04° Que va contenir le paramètre x de la ligne 1 lorsqu'on lance l'appel suivant :

>>> fois2(12)
1 2 3 4 5 6 7
def fois2(x): resultat = x * 2 return resultat def plus2(x): resultat = x + 2 return resultat

La réponse de la fonction est-elle correcte ?

...CORRECTION...

Il faut comparer l'appel et la déclaration.

>>> fois2(12)
1
def fois2(x):

On voit que le paramètre x est affecté à 12.

Le code de la fonction permet de voir qu'on va renvoyer 24.

1 2 3
def fois2(x): resultat = x * 2 return resultat

05° Que va contenir le paramètre x de la ligne 5 lorsqu'on lance l'appel suivant :

>>> plus2(80)
1 2 3 4 5 6 7
def fois2(x): resultat = x * 2 return resultat def plus2(x): resultat = x + 2 return resultat

La réponse de la fonction est-elle correcte ?

...CORRECTION...

Il faut comparer l'appel et la déclaration.

>>> plus2(80)
5
def plus2(x):

On voit que le paramètre x est affecté à 80.

Le code de la fonction permet de voir qu'on va renvoyer 82.

5 6 7
def plus2(x): resultat = x + 2 return resultat

06° L'instruction suivante est-elle une simple évaluation ou une mémorisation d'un résultat ?

Que faudrait-il faire pour garder le résultat en mémoire ?

>>> fois2(15)

Comment faire comprendre à Python qu'on veut mémoriser le résultat ?

...CORRECTION...

On demande juste à l'interpréteur Python d'évaluer fois2(15)

En mode interactif, la console affiche le résultat, c'est son comportement par défaut.

Par contre, on ne mémorise pas le résultat.

Pour cela, il faudrait placer la réponse de la fonction dans une variable, comme ceci par exemple :

>>> m = fois2(15)
Déclaration de fonction

Voici comment déclarer une fonction :

  1. On commence la déclaration par le mot-clé def suivi du nom de la fonction.
  2. 1
    def fois2
  3. entre des parenthèses, on fournit le nom des variables qui vont servir à mémoriser les informations reçues (ici, c'est x). Ces variables particulières se nomment les paramètres de la fonction. Même si on ne désire rien transmettre à notre fonction pour qu'elle travaille, on doit au moins placer des parenthèses vides : ()
  4. 1
    def fois2(x)
  5. On finit la ligne par un double point : signifiant qu'on a fini la déclaration.
  6. 1
    def fois2(x):
  7. Les instructions à réaliser sont indentées (4 espaces ou touche TAB)
  8. 1 2
    def fois2(x): resultat = x * 2
  9. On finit par return suivi de la réponse qu'on veut renvoyer, ici resultat
  10. 1 2 3
    def fois2(x): resultat = x * 2 return resultat

✎ 07° Expliquer la réponse qu'on va obtenir lors de l'appel de la fonction facile() ci-dessous. On vous donne la déclaration de la fonction et son utilisation dans la console interactive.

1 2
def facile(x): return x*10 + 5
>>> facile(3) ???

08° Expliquer la réponse qu'on va obtenir lors de l'appel de la fonction difficile() ci-dessous. Pourquoi difficile ? Car cette fois, on envoie deux arguments lors de l'appel. On vous donne la déclaration de la fonction et son utilisation dans la console interactive.

1 2
def difficile(x, y): return x*10 + y
>>> difficile(5, 6) ???

...CORRECTION...

Il faut comparer l'appel et la déclaration.

>>> difficile(5, 6)
5
def difficile(x, y):

On voit que le paramètre x est affecté à 5 et que le paramètre y est affecté à 6.

Le code de la fonction permet de voir qu'on va renvoyer 5*10+6, soit 56.

Nous avons donc un script qui ne fait RIEN sauf déclarer des fonctions. Fonctions qu'on peut ensuite activées à l'aide de la console. On peut bien entendu également utiliser les fonctions dans le programme lui-même. Dans ce cas, on respecte toujours cette structure :

  1. tout en haut du programme : importations des modules
  2. ensuite, la déclaration des CONSTANTES
  3. puis la déclaration des fonctions
  4. enfion, les instructions en elles-même qu'on pourrait nommer programme principal.

09° Pour valider cette première partie :

  1. Appuyer sur le bouton VISUALISER ci-dessous, pour observer l'ordre d'exécution de ce programme
  2. expliquez les valeurs finales stockés dans les variables a et b après exécution du code ci-dessous.
  3. Vérifiez ensuite en lançant le code réellement.
  4. Modifier vos réponses au besoin !
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
# 1 - - Déclaration des fonctions - - - - def fois2(x): resultat = x * 2 return resultat def plus2(x): resultat = x + 2 return resultat # 2 - - Programme principal - - - - - nombre = 3 nombre2 = 5 a = plus2(nombre) b = fois2(a) b = b + 1

CLIQUEZ ICI POUR VOIR L'ORDRE DES INSTRUCTIONS EXECUTEES :

Pour visualiser les valeurs des deux variables, deux possibiltés :

  • Soit vous utilisez votre éditeur de code (par exemple VIEW-VARIABLES dans Thonny)
  • Soit vous demandez les résultats via la console interactive :
  • >>> a >>> b

...CORRECTION...

On obtient ceci

  • Mise en mémoire de la fonction fois2
  • Mise en mémoire de la fonction plus2
  • Affectation de 3 dans nombre
  • Affectation de 5 dans nombre2
  • plus2(nombre) renvoie 5.
  • Affectation de 5 dans a
  • fois2(a) renvoie 10 car a est évaluée à 5.
  • Affectation du 10 dans b
  • Evaluation de b + 1 à la valeur 11
  • Affectation du 11 dans b
Bilan intermédiaire

On retrouve ainsi toutes les choses vues jusqu'à présent.

  • Le code s'exécute séquentiellement une ligne à la fois, de la ligne du haut vers celle du bas (Python 2)
  • Lors de l'affectation d'une variable, Python évalue d'abord ce qu'il y a à droite du signe = puis le place dans la variable dont le nom est à gauche (Python 1 et 3)
  • On déclare la fonction fois2 (cela ne l'active pas mais la place en mémoire)
  • On déclare la fonction plus2 (cela ne l'active pas mais la place en mémoire)
  • a = plus2(3) lance un appel à plus2(x). C'est comme si on avait écrit x = 3, et on stocke le résultat (de 5) dans a.
  • b = fois2(a) lance un appel à fois2(x) en transmettant a (donc 5) et on stocke le résultat (qui donne 10) dans la variable b.

On trouve deux écoles dans la notation des fonctions dans un texte. Certains diront qu'il faut noter fois2() avec les parenthèses lorsqu'on parle de la fonction, et d'autres diront qu'on peut noter également fois2 sans les parenthèses lorsqu'on en parle dans un texte explicatif.

Le tout est de savoir que les deux possibilités existent dans les textes en français. Il n'y a pas de normes établies à ce sujet.

2 - Documentation

Commentaires : pour comprendre comment une fonction réalise le travail demandé

Nous avons déjà vu comment insérer des commentaires dans un programme.

En Python, on rajoute des commentaires dans le code en utilisant #. Les commentaires servent à comprendre le fonctionnement interne d'une fonction.

Les commentaire sont destinés à être lu par un autre développeur qui veut comprendre le fonctionnement de votre fonction.

Documentation : pour savoir comment utiliser la fonction

Nous allons maintenant voir qu'on doit documenter les fonctions : la documentation sert à savoir comment utiliser le code.

La documentation est destinée au développeur qui veut utiliser le code.

Il s'agit d'informer de la façon dont il faut utiliser votre fonction. Une sorte de mode d'emploi de votre fonction. Ces informations doivent être suffisantes pour utiliser la fonction sans provoquer d'erreurs.

10° Taper les instructions suivantes dans la console pour récupérer la documentation que les concepteurs de Python ont intégré à l'interpréteur. Comme vous allez le constater, pour récupérer la documentation de la fonction len() (qui renvoie la longueur d'une chaîne de caractères), on doit lancer l'appel à une autre fonction nommée help() !

>>> help(len) Help on built-in function len in module builtins: len(obj, /) Return the number of items in a container.

Questions

Qu'envoie-t-on à cette fonction help() : un appel à une fonction ou simplement la référence d'une fonction ?

...CORRECTION...

On place des parenthèses derrière le help : on lance donc bien un appel réel.

On voit qu'on a placé len dans ces parenthèses. Cela veut dire qu'on demande à la fonction help() de fournir la documentation de la fonction native len.

D'ailleurs, remarquez bien qu'on fournit juste la référence de len et pas un appel len().

Documentation des fonctions

Pour réaliser une documentation :

1 - On place la documentation sous la première ligne de la fonction (la ligne de déclaration).

2 - On place la documentation dans entre 3 guillemets simples d'ouverture ''' et 3 guillemets de fermeture ''' en fermeture.

Les documentations des fonctions peuvent être écrites comme on le veut. Il suffit que le lecteur puisse comprendre vos informations.

Voici un premier exemple de la structure que peut prendre une documentation :

  • :param x: derrière lequel on explique le contenu attendu pour le paramètre nommé ici x pour l'exemple
  • :type x: pour préciser le type attendu de cette variable (int ? float ? str ? bool ?)
  • :return: pour expliquer ce que va renvoyer la fonction
  • :rtype: pour préciser le type de la réponse renvoyée

11° Lire la documentation. Modifier la fonction calculer_moyenne() pour qu'elle renvoie la réponse attendue précisée dans les commentaires.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
def calculer_moyenne(note1, note2): '''Renvoie la moyenne des deux notes :param note1: une note dans [0;20] :type note1: int :param note2: une note dans [0;20] :type note2: int :return: la moyenne de note1 et note2 :rtype: float ''' moyenne = 0 return moyenne moy = calculer_moyenne(10, 20)

Exemple d'utilisation dans la console interactive (après avoir mis la fonction en mémoire !)

>>> calculer_moyenne(10, 20) 15.0 >>> calculer_moyenne(10, 14) 12.0

...CORRECTION...

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
def calculer_moyenne(note1, note2): '''Renvoie la moyenne des deux notes :param note1: une note dans [0;20] :type note1: int :param note2: une note dans [0;20] :type note2: int :return: la moyenne de note1 et note2 :rtype: float ''' moyenne = (note1 + note2) / 2 return moyenne moy = calculer_moyenne(10, 20)

Dans la correction précédente, j'ai donné ce qu'un débutant tape souvent : on calcule la moyenne puis on la renvoie. Mais, en réalité, il est inutile ici de stocker le résultat avant de le renvoyer. On peut le renvoyer directement.

Voici une autre façon d'écrire cette fonction (juste la réponse) associée à une documentation plus compacte par exemple 

1 2 3 4 5 6 7 8 9 10 11
def calculer_moyenne(note1, note2): '''Renvoie la moyenne des deux notes :: param note1(int) :: une note dans [0;20] :: param note2(int) :: une note dans [0;20] :: return (float) :: la moyenne de note1 et note2 ''' return (note1 + note2) / 2 moy = calculer_moyenne(10, 20)

11-bis° Utiliser ce nouveau programme dans Thonny pour vérifier que la fonction fonctionne de la même façon.

Vous pouvez donc faire ceci :

>>> moy 15.0 >>> moy2 = calculer_moyenne(10, 15) 12.5 >>> help(calculer_moyenne) Help on function calculer_moyenne in module __main__: calculer_moyenne(note1, note2) Renvoie la moyenne des deux notes :: param note1(int) :: une note dans [0;20] :: param note2(int) :: une note dans [0;20] :: return (float) :: la moyenne de note1 et note2

Nous avons donc vu comment créer la documentation et comment la lire.

Comprenez bien qu'une documentation de fonction n'est pas un commentaire mais bien un mode d'emploi pour quelqu'un qui veut juste utiliser la fonction.

Le concepteur d'une fonction doit donc savoir :

  • Créer une nouvelle fonction
  • Documenter sa fonction

L'utilisateur d'une fonction doit donc savoir :

  • Trouver la documentation de la fonction voulue avec help() ou en allant lire directement le programme de façon à
    • Savoir ce que réalise la fonction
    • Savoir ce qu'elle doit recevoir comme paramètres
    • Savoir ce que la fonction va répondre
  • Savoir lancer un appel concrêt à cette fonction

3 - Python interactif

Le programme précédent permet donc de créer la fonction calculer_moyenne() et de l'activer directement depuis le programme lui-même.

Mais la fonction calculer_moyenne() est maintenant en mémoire tant qu'on ne réappuie pas sur la flèche pour relancer un nouveau programme. Autant continuer à l'utiliser non ?

Vérifions que vous vous parvenez encore à prévoir le comportement des fonctions.

12° Vérifiez que la fonction est en mémoire. Tapez alors ceci dans la console :

>>> calculer_moyenne(12, 14) 13.0 >>> calculer_moyenne(0, 14) 7.0 >>> resultat = calculer_moyenne(0, 14) >>> resultat 7.0

Question : comparer la déclaration de la fonction et l'appel calculer_moyenne(12, 14)

1
def calculer_moyenne(note1, note2):

Que contient le paramètre note2 de notre fonction lors de l'exécution de cet appel ?

...CORRECTION...

Il suffit de comparer les places respectives des différents éléments lors de la déclaration et de l'appel.

1
def calculer_moyenne(note1, note2):
>>> calculer_moyenne(12, 14)

On voit donc que

  • 12 va être stocké dans le paramètre note1 et
  • 14 va être stocké dans le paramètre note2.

✎ 13° Compléter la fonction addition() pour qu'elle fonctionne correctement. Enregistrer et lancer dans Thonny pour placer cette fonction en mémoire. En faire appel ensuite dans la console pour vérifier son fonctionnement.

1 2 3 4 5 6 7 8 9
def addition(note1, note2): '''Renvoie la somme des deux notes :: param note1(int) :: une note dans [0;20] :: param note2(int) :: une note dans [0;20] :: return (int) :: la somme de note1 et note2 ''' return 0
>>> addition(12,14) 26 >>> resultat = addition(10,14) >>> resultat 24

✎ 14° Compléter la fonction multiplication() pour qu'elle fonctionne correctement. Enregistrer et lancer dans Thonny pour placer cette fonction en mémoire. En faire ensuite appel dans le shell pour vérifier son fonctionnement.

1 2 3 4 5 6 7 8 9
def multiplication(x, y): '''Renvoie la multiplication de a par b :: param x(int) :: un entier :: param y(int) :: un entier :: return (int) :: x*y ''' return 0
>>> multiplication(5,10) 50 >>> resultat = multiplication(6,6) >>> resultat 36

4 - Au return, prêt, sortez !

Que se passe-t-il lorsque la fonction rencontre un return ?

A quel moment sort-on vraiment de la fonction ?

15° Observer la fonction division(). On a demandé à quelqu'un de compléter la fonction suivante pour qu'elle réalise bien une division entière. Il a tapé ceci en oubliant de supprimer la ligne qu'on lui avait donné, celle avec le return 0.

1 2 3 4 5 6 7 8 9 10 11
def division(x, y): '''Renvoie le quotient de la division euclidienne de x par y :: param x(int) :: un entier :: param y(int) :: un entier NON NUL :: return (int) :: la division entière de x par y ''' return 0 mon_petit_calcul = x // y return mon_petit_calcul

Tester la fonction dans la console.

Question

Pourquoi cette fonction renvoie-t-elle TOUJOURS 0 ?

...CORRECTION...

On aurait pu croire que la fonction suit son cours et finit par répondre à la fin. Mais non !

Dès qu'on rencontre un return, la fonction renvoie ce qu'on a placé derrière et on sort immédiatement.

Dès qu'on arrive sur la ligne 9, on renvoie 0. Et on sort de la fonction.

Il ne sert strictement à rien de placer des choses sur des lignes qui suivent le return : ces lignes ne seront jamais analysées.

Ici, les lignes 10 et 11 ne servent strictement à rien. C'est comme si vous aviez tapé ceci :

1 2 3 4 5 6 7 8 9
def division(x, y): '''Renvoie la division entière de x par y :: param x(int) :: un entier :: param y(int) :: un entier NON NUL :: return (int) :: la division entière de x par y ''' return 0

Il faut donc comprendre que toutes les choses créées uniquement dans la fonction (comme la variable mon_petit_calcul) disparaît une fois sorti de la fonction.

C'est comme si vous aviez tapé del mon_petit_calcul (del comme delete).

5 - Et sans return ?

Lorsqu'on rencontre le return, on sort immédiatement. Ok.

Mais...

Et si on ne rencontrait jamais de return ? Que se passe-t-il ?

Nous allons voir que la fonction répond quelque chose quand même et cette réponse est ... vide. Mais une réponse "vide" contient une information : l'information que la fonction est bien terminée puisqu'elle a répondu.

16° Observer le code suivant qui possède une fonction sans return...

1 2 3
def division(x, y): '''Calcule la division entière de x par y, mais n'en fait rien...''' mon_petit_calcul = x // y

Tester la fonction dans la console.

>>> division(7,2) >>>

Questions

  • Cette fonction renvoie-t-elle quelque chose ?

...CORRECTION...

Et non. Cette fonction ne renvoie rien. On a repris la main : nous sommes donc sortis de la fonction. Mais il n'y a eu AUCUN retour.

17° Observer un peu mieux l'onglet de Thonny après avoir tapé ceci dans la console :

Questions

  • Que contient la variable reponse ?
  • Quel est le type de cette variable ?
>>> reponse = division(5, 3) >>> reponse >>> type(reponse) ???
résultat d'une fonction sans retour

...CORRECTION...

En réalité, la variable contient quelque chose !

Elle contient None.

Quel est le type de None ?

>>> reponse = division(5, 3) >>> reponse >>> type(reponse) <class 'NoneType'>

Voilà comment on pourrait interpréter le code de la fameuse fonction qui ne possède pas de return.

1 2 3 4
def division(x, y): '''Calcule la division entière de x par y, mais n'en fait rien...''' mon_petit_calcul = x // y return None
Pas de fonction vraiment sans retour en Python...

On retiendra donc qu'une fonction Python renvoie au moins la valeur None lorsque son code se termine sans avoir rencontré un autre return.

En Python, on parle parfois de procédure pour désigner une fonction sans return. Elle renvoie au moins None, il ne s'agit donc pas vraiment d'une vraie procédure, mais l'idée est là.

Pour finir, voici trois dernières questions qui vous permettront de voir si vous avez bien compris les notions sur les fonctions vues dans cette activité.

✎ 18° Réaliser la fonction telle qu'elle est spécifiée dans sa documentation :

1 2 3 4 5 6 7 8 9 10 11 12
def longueur(chaine): '''Fonction qui renvoie la taille de la chaine de caractères reçue :: param chaine(str) :: la chaîne de caractères :: return (int) :: le nombre de caractères de la chaîne reçue :: exemple .. >>> longueur('Bonjour') 7 ''' pass

Remarque : l'instruction pass porte bien son nom. Elle veut dire de ne rien faire, de passer son chemin. Ici, il faudra donc la remplacer par votre propre réponse. Une fonction sans instruction provoque une erreur. pass ainsi de remplir la fonction avec au moins une instruction, qui ne fait rien, mais une instruction quand même.

✎ 19° Réaliser la fonction telle qu'elle est spécifiée dans sa documentation :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
def contient(chaine1, chaine2): '''Fonction booléenne qui renvoie True si chaine1 est bien dans chaine2, False sinon :: param chaine1(str) :: la petite chaîne de caractères :: param chaine2(str) :: la grande chaîne de caractères :: return (bool) :: True si chaine1 est dans chaine2 :: exemple .. >>> contient('Bonjour', 'Bon, alors bonjour') False >>> contient('bonjour', 'Bon, alors bonjour') True ''' pass

✎ 20° Placer la fonction en mémoire. Réaliser les appels proposés. Ecrire alors la documentation de cette fonction une fois que vous avez compris ce qu'elle fait.

Note : cette fonction utilise dans ses instructions la fonction randint() du module qui se nomme random, hasard ou aléatoire en anglais.

1 2 3 4 5 6 7 8 9 10
import random def de(nbr_faces): '''La petite phrase qui va bien :: à faire : décrire le paramètre :: :: à faire : décrire la réponse :: ''' return random.randint(1, nbr_faces)
>>> de(6) 5 >>> de(6) 6 >>> de(6) 3 >>> de(6) 4

6 - FAQ

J'ai entendu parler de routine, de procédure. C'est quoi ?

Le mot fonction est utilisé de façon assez générique dans Python. Par contre en informatique, il existe des entités qui peuvent être gérées de façon différente selon les langages.

Le vrai mot générique pour parler d'une suite d'instructions mémorisées et à laquelle on peut faire appel de nombreuses fois est le mot routine.

On distinguera deux types de routine :

  • Si la routine ne renvoie rien (pas de return), on parle de procédure.
  • Si la routine renvoie bien quelque chose vers le programme d'appel, on parle de fonction.

Du coup, les vraies procédures n'existent pas en Python : même si votre fonction ne renvoie rien, elle renvoie None. Cela permet de savoir que la fonction n'a rien renvoyé mais ce n'est pas vraiment ...rien... En effet, si la variable reponse existe et contient None, nous avons appris quelque chose : notre fonction est terminée.

On peut détruire une variable ?

Oui, on peut libérer la place mémoire attribuée à une variable. Pour cela, il faut utiliser le mot-clé del.

Exemple :

>>> a = 5 >>> a 5 >>> del a >>> a NameError: name 'a' is not defined

C'est tout en terme de connaissances sur les fonctions pour aujourd'hui. Si on récapitule, nous avons vu :

  • Comment déclarer une fonction
  • Comment documenter un peu les fonctions
  • Comment une fonction parvient à renvoyer quelque chose avec le mot-clé return
  • Qu'on sort IMMEDIATEMENT de la fonction dès qu'on rencontre return
  • Qu'une fonction-python renvoie au moins None.

Activité publiée le 28 08 2019
Dernière modification : 17 10 2021
Auteur : ows. h.