11 - Fonctions et variables

Description

Les fonctions sont des instructions particulières qui :

• reçoivent des données d'entrée et
• renvoient leur réponse en sortie.

Un exemple avec la fonction VALEUR_ABSOLUE qui n'attend qu'une entrée (un nombre) et qui renvoie la valeur absolue du nombre (le même nombre mais sans son signe).

D'autres exemples

A - Déclarer une fonction

Déclarer la fonction revient à stocker ses instructions.

Pour déclarer une fonction, on écrit dans l'ordre

1. le mot-clé def.
2. le nom de la fonction
3. entre parenthèses : les variables d'entrée séparées par des virgules
4. le caractère :
5. les instructions du bloc tabulé

Important : lors de la déclaration, on ne lance aucun appel, on ne fait que mettre en mémoire.

Le mot-clé return permet d'indiquer ce que la fonction devra renvoyer si on l'appelle.

Placer des commentaires en français dans le code Python

On peut placer du texte à destination des développeurs qui vont lire le programme en utilisant le caractère #. Voir la partie suivante pour un exemple.

Attention : sur votre ligne, tout ce qui se trouve derrière ce # sera purement ignoré par l'interpréteur.

B - Lancer un appel de fonction

Lancer un appel revient à fournir les entrées et attendre la réponse de la fonction.

Sur l'exemple, l'appel se fait LIGNE 4.

C - Lancer plusieurs appels

Les fonctions ont deux avantages :

1. Permettre l'envoi d'une sortie dont la valeur dépend des entrées reçues;
2. Permettre plusieurs appels successifs à une même fonction.

Différence entre paramètre et argument

Il faut savoir distinguer

• La déclaration qui indique les variables locales permettant de stocker les entrées qu'on fournira un jour.
  Plutôt que de dire les variables locales de stockage d'entrées qu'on fournira un jour", on dira les paramètres.

1 2 3

def valeur(d, u): # d et u sont les paramètres déclarés resultat = d*10 + u return resultat

Ces paramètres disparaissent donc une fois que la fonction a répondu.

• L'appel qui fournit les entrées envoyées à la fonction sur cet appel. Plutôt que de dire les "entrées envoyées à la fonction sur cet appel", on utilisera le mot argument.
>>> valeur(5, 3) # 5 et 3 sont les Arguments d'Appel 53

L'argument n°1 (5) va dans le paramètre n°1 (d), ect...

Cas d'une fonction avec 1 paramètre

Cas d'une fonction avec 2 paramètres

Lors de l'appel, on envoie l'argument 5 suivi de l'argument 3.

L'argument 5 est donc stocké dans d et l'argument 3 dans le paramètre u

Moyen mnémotechnique pour les interros

appel (commence par a) : argument (commence par a)

déclaration (commence par d) : paramètre (commence par p, un d à l'envers)

Précision

L'appel peut bien entendu se faire directement dans le programme. C'est même beaucoup plus courant.

2.2.1 Documenter pour utiliser

La documentation doit expliquer comment utiliser la fonction sans provoquer d'erreur.

Si on prend l'analogie de la voiture :

• Les commentaires expliquent comment fonctionne la voiture (cours de mécanique, d'électronique...)
• La documentation explique comment utiliser la voiture (cours de code et de conduite)

2.2.2 Trouver la documentation

En Python, pour trouver la documentation, il suffit d'utiliser une fonction native : la fonction help().

Imaginons qu'on veuille récupérer la documentation de la fonction native len() : il faut donner le nom de la fonction en tant qu'argument à la fonction type(). Attention, juste le nom, sans les parenthèses. On ne veut pas l'activer.

Première ligne : on voit que len() est une fonction native (build-in).

Deuxième ligne : à qui on doit fournir un seul argument (qui sera rangé dans un paramètre obj visiblement).

Troisième ligne : on voit que la fonction va renvoyer le nombre d'éléments contenus dans le conteneur envoyé.

2.2.3 Contenu d'une documentation

La documentation contient juste des informations sur

1. Le but de cette fonction
2. le type et le nombre d'arguments à lui envoyer (les ENTREES) et
3. le type et le contenu de la réponse (la SORTIE).

2.3.1 - Signature d'une fonction

Pour pouvoir utiliser une fonction, on a besoin :

1. de savoir comment elle se nomme.
2. de savoir combien d'arguments lui envoyer et leurs types.
3. de savoir ce qu'elle va répondre.

Toute ces informations se retrouvent dans la signature. Par exemple, la signature d'une fonction addition() qui permet d'additionner deux entiers :

addition(int, int) -> int

2.3.2 - Prototype d'une fonction

Prototyper une fonction consiste à rajouter les noms des paramètres à la signature.

addition(nombre1:int, nombre2:int) -> int

Attention : le prototype ne donne pas d'indications sur ce que réalise la fonction. On peut s'en douter en regardant les noms de la fonction et des paramètres si ils sont explicites, mais on ne fait que deviner. On peut donc se tromper.

2.3.3 - Spécification : la documentation minimale d'une fonction

Spécifier une fonction consiste à donner :

1. Le PROTOTYPE qui fixe la SYNTAXE et le TYPAGE
2. Une description nommée DOCSTRING qui fixe clairement la SEMANTIQUE

2.3.4 - Obtenir la documentation

La fonction help() renvoie les informations fournies dans la documentation.

2.4.1 Limitation de la documentation rapide

Parfois, la documentation rapide ne suffit pas. Par exemple, cette fonction vitesse() :

1. Problème 1 : on ne signale pas à l'utilisateur qu'il ne doit surtout pas fournir de durée nulle pour éviter une division par zéro.
2. Problème 2 : on ne signale pas si il y a des unités attendues pour durée et distance.

2.4.2 Solution : Docstring multiligne

On peut fournir une vraie documentation sur plusieurs lignes.

Il n'existe aucune codification imposée pour cette documentation. Voici les éléments qu'elle doit contenir, quelque soit la façon de l'exprimer :

• DESCRIPTION : une description de ce que fait la fonction
• PROTOTYPAGE : l'équivalent de la signature et du prototype mais sous forme d'un texte plus libre
• PRECONDITION : une explication claire des conditions supplémentaires sur les paramètres d'entrée si certaines valeurs posent problème.
• ...

3.2.1 Le cas du return absent

Une fonction Python renvoie au moins la valeur None lorsqu'elle se termine sans avoir rencontré return.

On parle parfois de procédure pour désigner une fonction qui ne répond rien. Les procédures n'existent donc pas vraiment en Python.

La ligne 4 ci-dessous est donc totalement facultative :

3.2.2 Attention au stockage de la réponse...

Il arrive souvent qu'on utilise mal de telles fonctions qui renvoient None si on a lu trop vite la documentation.

Le cas typique vient de la méthode append() qui permet de rajouter une case à la fin d'un tableau Python : elle modifie le tableau mais ne renvoie "rien".

Bonne utilisation

Mauvaise utilisation

Si quelqu'un l'utilise mal en pensant qu'elle répond en donnant la nouvelle version du tableau, il va écraser le tableau et y placer None !

Ici, t contient maintenant None.

Attention : si on utilise append(), il ne s'agit plus d'un tableau statique mais d'un tableau dynamique. Nous les utiliserons plus tard dans l'année.

3.2.3 None et les booléens

Lorsqu'on veut évaluer un contenu sous forme de booléen, None est considéré comme le cas nul ou vide.

Mais attention : None n'est identique à False.

4.1.1 Intérêt

Imaginons une fonction qui renvoie un résultat aléatoire compris entre un entier debut et un entier fin :

Si cette fonction doit simuler un dé, l'entier debut sera toujours 1. Et pourtant, il faut toujours lui fournir cette valeur puisqu'il y a deux arguments à envoyer.

Si on ne met qu'un seul paramètre attendu et qu'on impose que la valeur de départ est toujours 1, on obtient une fonction moins flexible.

Comment avoir le meilleur des deux mondes ?

4.1.2 Paramètres par défaut

On peut donner des valeurs d'arguments par défaut aux fonctions. Si l'utilisateur ne fournit pas de valeurs pour ces paramètres, il sera rempli automatiquement avec la valeur située un signe = dans la déclaration.

On peut alors faire des appels en envoyant la valeur de départ, ou pas.

Attention au positionnement : remarquez bien qu'il faut que les paramètres ayant une valeur par défaut soient positionnés derrière les paramètres sans valeur par défaut. C'est pour cela que debut=1 est déclarée derrière fin.

4.1.3 Documentation

On peut bien entendu continuer à indiquer rapidement le type des paramètres, même avec des valeurs par défaut.

4.2.1 Paramètres nommés

Cette fonctionnalité est présente de base dans Python : plutôt que de fournir les arguments dans l'ordre imposé par l'ordre des paramètres dans la déclaration, on peut les fournir comme on le veut, pourvu de tous les fournir.

4.2.2 Paramètres positionnels uniquement

Nommer les paramètres, c'est pratique mais dangereux. Un changement de nom et tous les programmes utilisant l'ancienne version ne fonctionneront plus.

On peut empêcher l'utilisation des paramètres nommés et donc imposer que seul l'ordre de transfert des arguments soit important.

Pour cela, il suffit de rajouter un symbole / dans la liste des paramètres.

• Les paramètres à gauche du / sont positionnels uniquement (nb).
• Les paramètres à droite du / sont nommables lors de l'appel (debut et (fin)).