5. Fonctions⚓︎

Ce chapitre est la pierre angulaire de tout langage informatique !

Pour tous les exercices, vous pouvez valider vos réponses avec le petit gendarme : votre fonction sera alors testée sur des cas de base. Ces cas vous aident à comprendre pourquoi votre fonction n'a pas encore le fonctionnement attendu.

5.1 Principe⚓︎

Pourquoi les fonctions ?

Les lignes suivantes permettent de convertir une température de degré Fahrenheit vers degré Celsius.

temp_fahrenheit = 60
temp_celsius = temp_fahrenheit - 32 * (5/8)

Dans le terminal ci-dessous, tester ce programme pour convertir 60 degrés Fahrenheit en degrés Celsius. Afficher la valeur référencée par la variable temp_celsius. Pro tip : dans la console, utiliser la touche Tab pour compléter un mot dont vous aurez écrit le début. temp_f + Tab doit écrire temp_fahrenheit.
On souhaite maintenant convertir 90 et 120 degrés Fahrenheit en degrés Celsius. Ajouter les lignes correspondantes.

>>>

Solution

temp_fahrenheit = 60
temp_celsius = temp_fahrenheit - 32 * (5/8)
print(temps_celsius)
temp_fahrenheit = 90
temp_celsius = temp_fahrenheit - 32 * (5/8)
print(temps_celsius)
temp_fahrenheit = 120
temp_celsius = temp_fahrenheit - 32 * (5/8)
print(temps_celsius)

On remarque qu'il y a beaucoup de répétitions dans le code, même si nous avons utilisé des variables. Notez que l'on pourrait éventuellement utiliser une boucle :

for temp_fahrenheit in [60, 90, 120]:
    temp_celsius = temp_fahrenheit - 32 * (5/8)
    print(temps_celsius)

Il est toutefois difficile de comprendre ce que fait ce programme.

Le principe DRY va encore être ici à l'oeuvre : la structure fonction va permettre de simplifier un programme en évitant les répétitions inutiles et complexes à débogger. Cette structure va rendre également le code plus abstrait.

Cours

Une fonction permet de créer des blocs d'instructions que nous pouvons réutilisons quand nous le souhaitons. C'est une boite noire indépendante du reste d'un programme :

nous pouvons la tester et contrôler son fonctionnement de manière indépendante ;
elle découpe le problème en sous-problème plus simple à résoudre ;
nous pouvons la réutiliser dans d'autres programmes.

Exemple

Pour construire une voiture, on ne fait pas tout en même temps :

on a par exemple besoin de convertir de l'énergie thermique (ou électrique) en énergie mécanique. Pour cela, on "crée" une fonction nommée convertir_énergie_thermique_en_énergie_mécanique qu'on appelle aussi le moteur ;
la conversion de l'énergie thermique en énergie mécanique va fonctionner car le moteur a été testé de manière indépendante lors du développement du modèle de voiture ;
on le réutilise ensuite pour la production à la chaîne.

Nous nommerons nos fonctions avec des noms d'action : calculer_moyenne, trier_tableau ou afficher_résultats.

5.2 Définir une fonction⚓︎

Cours

Pour définir une fonction en Python, on utilise la syntaxe suivante :

def nom_de_la_fonction(parametre1, parametre2, ... ):
    ... instructions ...
    ... instructions ...
    ... instructions ...
    return résultat1, résultat2, ...

Une fois definie, la fonction appelée nom_de_la_fonction peut être utilisée n'importe où dans le programme.

En Python, l'indentation des instructions appartenant à la fonction est obligatoire.

Important

return est l'instruction permettant de renvoyer des résultats en dehors de la fonction.

Toute variable non renvoyée par return sera perdue dans la boîte noire !

Important

Dans ma grande bonté, je vous propose quelquefois des fonctions où seul le titre es présent (on appelle cela un prototype).

Pour éviter une erreur, le mot-clé pass apparaît dans la fonction : il indique à Python de ne rien faire. Quand vous commencez à écrire la fonction, supprimez pass.

Nous allons tout de suite étudier divers cas particuliers importants.

5.3 Exemple de fonctions⚓︎

5.3.1 Fonction sans paramètres⚓︎

Les fonctions sans paramètres sont des raccourcis pour éviter de retaper plusieurs fois les mêmes instructions. Leur utilité est très limitée : si vous les utilisez, ce sera pour des utilisations très spécifiques.

Exercice

5.3.2 Fonction avec paramètres⚓︎

Cours

Exemple

Exécuter le code.
Dans la console, taper compter(5) puis compter(10).

La valeur n est appelée paramètre de la fonction compter.
On dit qu'on passe le paramètre n à la fonction compter.
Lorsque vous avez tapé compter(5) da,ns la console, vous avez appeler la fonction compter avec l'argument 3.

Pour aller plus loin

Les annotations permettent de préciser à un utilisateur extérieur quel est le type des paramètres. Attention, cela n'impose pas le type du paramètres, c'est simplement une indication !

Pour indiquer que n est entier, on peut par exemple écrire :

def compter(n: int):
    ...

Pour plusieurs paramètres a flottant et n entier, on pourrait écrire :

def multiplier(a: float, n: int):
    ...

Nous le reverrons au chapitre 8 !

Exercices

5.3.3 Et si on n'a rien à renvoyer ?⚓︎

Cours

On a toujours quelque chose à renvoyer : en l'absence de valeurs à renvoyer, on écrira, return None.

Pour aller plus loin

En pratique, return None n'est pas obligatoire. Si une fonction ne contient pas le mot-clé return, Python rajoutera gentiment (et automatiquement) return None à la fin de votre fonction lors de l'interprétation du programme.

explicit is better than implicit : écrivez toujours return None.

Exercices

Exercice 12Exercice 13Exercice 14

Écrire une fonction f qui prend en paramètre un nombre flottant x et qui affiche le nombre flottant x**2 + 1.
Réaliser les opérations suivants : y = f(2) puis print(y) ? Expliquer le résultat.

5/5

Explications

print(f(2)) affiche :

>>> y = f(2)
5
>>> print(y)
None

L'appel y = f(2) se décompose en :

en évaluation du résultat de ma fonction f(2) : c'est un affichage de 2**2 + 1, suivi du renvoi de None comme résultat ;
y référence la valeur renvoyée qui est None.

print(y) affiche donc bien None !

Dessin à obtenir

Triangle à tracer

Compléter la fonction triangle qui prend en paramètre :
- une tortue graphique tortue ;
- la longueur côté du triangle ;
- l'abscisse initiale x de la tortue ;
- l'ordonnée initiale y de la tortue.
Cette fonction dessine un triangle équilatéral de couleur verte dont le sommet en bas à gauche a pour coordonnées \((x, y)\).
Exécuter votre programme et tester votre fonction dans la console.

Important

N'oubliez pas le return None !!!

5/5

Dessin à obtenir

hauteur

Écrire une fonction calculer_hauteur qui prend pour paramètre un côté côté et renvoie la hauteur d'un triangle équilatéral de côté c.
À l'aide des fonctions calculer_hauteur et triangle, créer la fonction nucléaire ayant pour paramètre une tortue graphique tortue et le côté côté. Le centre du symbole nucléaire est \((0,0)\).

Aide 1

Dessin

hauteur

La hauteur d'un triangle équilatéral peut se calculer facilement en découpant le triangle équilatéral en deux triangles rectangles. On applique alors le théorème de Pythagore. Faites un dessin !!

Aide 2

Les Maths ne sont pas votre truc. Voici la formule : \(h = \dfrac{\sqrt{3}}{2} c\).

Important

Avez-vous pensé au return None !!! J'y tiens. Vraiment. Pour de vrai.

5/5

5.4 Utilisation de `return`⚓︎

Cours

Dans une seule fonction, il est possible de renvoyer plusieurs valeurs avec return.

Il suffit d'utiliser la syntaxe : return valeur1, valeur2, valeur3 ....

Exemple

Il est également possible de mettre plusieurs return dans une seule fonction.

Dans ce cas, return est comme un siège éjectable : dès que le programme voit une instruction commençant par return, la fonction s'arrête !

Exemple

texte est très différent de phrase. En effet, texte et lettre sont les paramètres de la fonction, comme le \(x\) de \(f(x)\) en Maths.

"a" et phrase (ligne 12) sont les arguments de la fonction, comme \(2\) de \(f(2)\) en Maths. Ce sont eux qui vont être analysés par la fonction.

Finalement, caractère est une simple variable de boucle qui n'existe que dans la fonction.

Danger mortel

N'oubliez pas le return ! Si vous n'utilisez que des print, vous ne faîtes que de l'affichage : les résultats de ces fonctions ne pourront en aucun cas être réutilisés dans un autre calcul !

Exercices sur return

5.5 Variables locales et globales⚓︎

Cours

On appelle portée d'une variable l'ensemble des endroits du programme où elle existe.

En théorie, il est possible d'accéder à des variables extérieures à une fonction.

Toutefois, pour simplifier notre travail, nous utiliserons des paramètres pour accéder à ces variables. Cela évite les effets de bord consistant à modifier des variables de manière inattendue.

Pour aller plus loin

Généralement, le langage de programmation cherche les variables en fonction de leur portée.

Ainsi, si une variable appelée dans une fonction n'y apparaît pas, Python va chercher si cette variable apparaît dans une fonction englobante.

Si cette variable n'y apparaît pas non plus, Python va chercher si cette variable apparaît dans le programme principal.

Si la variable est toujours absente, Python va rechercher si cette variable est une variable Python par défaut.

Exercices sur portée des variables

5.6 Documentation d'une fonction⚓︎

Cours

Pour écrire un code facilement compréhensible, nous avons jusqu'à maintenant utilisé le principe de de l'auto-documentation. On nomme toujours clairement nos variables et fonctions.

Exemple

Un code illisibleUn code auto-documenté

Difficile de savoir ce que fait ce programme...

def f(t):
    m = -1
    for i in t:
        if i > m:
            m = i
    return m

Beaucoup plus lisible !

def calculer_maximum(tableau):
    maximum_actuel = -1
    for nombre in tableau:
        if nombre > maximum_actuel:
            maximum_actuel = nombre
    return maximum_actuel

Toutefois, il convient également de documenter les fonctions complexes que vous faites.

Documenter permet d'expliquer aux personnes qui ne sont pas familières avec vos fonctions de les comprendre :

que fait-elle ?
de quels types sont les paramètres ?
un petit exemple.

Attention à ne pas trop documenter !

Exemple

Trop de documentationDocumentation correcteTrop peu de documentationIncompréhensible

def calculer_carré(x):
    """Calcule le carré d'un nombre

    Paramètres :
    x -- flottant ou entier

    Exemple :
    nombre = calculer_carré(2.0)
    """
    return x**2

def calculer_carré(x):
    """Calcule le carré d'un nombre flottant ou entier"""
    return x**2

def f(x):
    return x**2

f = lambda m : (lambda _ : pow(_, 1))(m) * (lambda u : u)(m)

Souvent... Vous allez être la personne nécessitant la documentation. Rien de plus frustrant que de revenir sur un de vos codes non documenté et de passer quelques heures à retrouver comment il fonctionne.

Thor vous apprend à documenter Frodon vous apprend à documenter

Exercice

Exercice 22

L'auto-documentation de cette fonction semble suffisante.

À partir de cette auto-documentation, ajouter une documentation adéquate.

5/5

5.7 Résumé⚓︎

Résumé

Dans ce chapitre, j'ai appris :

l'intérêt des fonctions en programmation informatique ;
à écrire une fonction simple ;
la différence entre paramètres et arguments ;
l'instruction return et ses subtilités ;
à documenter mes fonctions.

Une anecdote

En 1973, un robot est envoyé sur la Lune pour collecter des données. Celui-ci, une fois arrivé, affiche les données sur son écran avec l'équivalent de print.

Rien n'a été renvoyé sur Terre car l'équivalent de return n'a pas été utilisé !

En général, on souhaite faire quelque chose de nos données, pas les afficher.

5. Fonctions⚓︎

5.1 Principe⚓︎

5.2 Définir une fonction⚓︎

5.3 Exemple de fonctions⚓︎

5.3.1 Fonction sans paramètres⚓︎

5.3.2 Fonction avec paramètres⚓︎

5.3.3 Et si on n'a rien à renvoyer ?⚓︎

5.4 Utilisation de return⚓︎

5.5 Variables locales et globales⚓︎

5.6 Documentation d'une fonction⚓︎

5.7 Résumé⚓︎

5.4 Utilisation de `return`⚓︎