Initiation aux fonctions

Initiation aux fonctions#

Motivation#

Revenons sur notre exemple de la feuille précédente : «Calculer l’énergie cinétique \(\frac12 m v^2\) d’un objet de masse \(14,5\) kg selon qu’il aille à \(1\), \(10\), \(100\), ou \(1000\) km/h».

Voilà comment nous avions procédé :

v = 100
m = 14.5

1. / 2 * m * v * v

72500.0

Avec cette façon de procéder, pour comprendre ce code, le lecteur doit reconnaître la formule pour en déduire l”intention: calculer l’énergie cinétique. De plus, chaque fois que nous devrons calculer une énergie cinétique, il faudra reécrire cette formule.

Pour éviter cela, il convient de distinguer l’intention (calculer une énergie cinétique) de comment la réaliser (utiliser la formule \(\frac12 mv^2\)). Pour cela nous pouvons définir une fonction, appelée energie_cinétique qui décrit comment calculer, à partir d’une masse m et d’une vitesse v l’énergie cinétique d’un objet de masse m et vitesse v :

def énergie_cinétique(m, v):
    return 1. / 2 * m * v * v

Cela étant fait, chaque fois que l’on souhaite calculer une énergie cinétique, nous pouvons appeler la fonction en précisant la valeur de la masse et de la vitesse, sans avoir à ce préocuper de comment on calcule une énergie cinétique :

énergie_cinétique(14.5, 100)

72500.0

énergie_cinétique(14.5, 10)

725.0

Fonctions#

Une fonction en informatique est un bloc de code qui effectue une tâche spécifique et peut être réutilisé plusieurs fois dans un programme. Les fonctions permettent de rendre le code plus modulaire, plus facile à lire et à maintenir.

Définition : Fonction

Informellement, une fonction (programming function (informal)) est un petit programme nommé avec :

  • En entrée: des paramètres

  • Un traitement

  • En sortie: une valeur renvoyée

Dans notre example :

def énergie_cinétique(m, v):
    return 1. / 2 * m * v * v

le nom de la fonction, introduit par le mot clé def est énergie_cinétique. L’entrée se compose de deux paramètres m et v (des nombres réels). Le traitement est le calcul de l’expression 1. / 2 * m * v * v. La valeur renvoyée, indiquée par le mot clé return est la valeur de cette expression.

Indication

Fonctions et modularité

Les fonctions aident à modulariser le code, c’est-à-dire à les structurer en petits éléments réutilisables et composables pour :

  • plus de facilité : résoudre un petit problème à la fois (méthode analytique).

  • plus de concision : éviter les répétitions.

  • plus de lisibilité : séparation de l”intention (le quoi) et du comment (encapsulation).

Indication

L’indentation en Python

Dans notre exemple de fonction, le traitement à effectuer consiste en une seule instruction :

    return 1. / 2 * m * v * v

Plus généralement le traitement pourrait consister en un bloc de plusieurs instructions. En Python, la syntaxe pour délimiter un tel bloc d’instructions utilise l” indentation (indentation) : chaque ligne du bloc d’instruction est précédée de quatre espaces. En outre, le bloc d’instruction est introduit par le charactère : à la fin de la ligne précédent le bloc. D’autres langages utilisent des accolades { et }, des parenthèses ( et ) ou des mots clés comme begin et end.

Cette particularité de Python favorise la lisibilité.

Exercice

  1. Définissez une fonction aire qui prend comme paramètre le rayon r d’un disque et calcule son aire :

pi = 3.1415
### BEGIN SOLUTION
def aire(r):
    return pi * r * r
### END SOLUTION

### BEGIN SOLUTION
aire(3)
### END SOLUTION

28.2735

La cellule suivante permet de tester votre fonction; si rien ne s’affiche, il y a de bonnes chances pour que votre fonction soit correcte :

assert aire(0) == 0
assert aire(1) == pi
assert round(aire(3), 4) == 28.2735

### BEGIN SOLUTION
def périmètre(r):
    return 2 * pi * r
### END SOLUTION

### BEGIN SOLUTION
périmètre(3)
### END SOLUTION

18.849

assert périmètre(0) == 0
assert périmètre(1/2) == pi
assert périmètre(3) == 18.849

Conclusion#

Dans cette feuille, vous avez défini vos premières fonctions, qui prennent en entrées des paramètres, réalisent un traitement, puis renvoie une valeur. Puis vous les avez appelées pour effectuer des calculs, sans avoir à vous préocuper de comment ces calculs étaient réalisés. C’est une premier outil pour faciliter la modularité des programmes.

Nous approfondirons ultérieurement les fonctions et nous explorerons d’autres outils pour favoriser la modularité.

Avant de passer à la suite, nous vous proposons quelques exercices d’entraînement et de révisions autocorrigés sur les fonctions. Exécutez la cellule suivante, suivez les consignes qui s’affichent et cliquez sur Valider pour vérifier votre réponse. Utilisez les différents bouttons pour parcourir les exercices et leurs variantes éventuelles.

Attention

L’outil utilisé, Jupylate, est en cours de développement; il a quelques défauts tels que l’absence d’indentation automatique ou de colorisation syntaxique dans la zone de réponse.

import glob
from jupylates import Exerciser
exercises = glob.glob('../Exercices/fonctions/*.md')
Exerciser(exercises, lrs_url="../.lrs.json", mode="train")

Retourner à l’index