Fonctions#
Vidéo: Les fonction (1)#
Créer de nouvelles fonctions#
Jusqu’à maintenant nous avons utilisé des fonctions déjà définies dans Python ou dans des modules. Cependant, il est possible de définir ses propres fonctions. Au minimum, la définition d’une fonction spécifie le nom de la fonction, et le bloc d’instructions à exécuter lorsque la fonction est appelée.
Voici par exemple une fonction qui, lorsqu’on l’appelle, affiche la chaîne de caractères "en forme" :
# Définition de la fonction state
def state():
print("en forme")
# Appel de la fonction
state()
en forme
Pour définir la fonction, on a utilisé l’instruction def suivie du nom de la fonction, state, de deux parenthèses et de deux points : c’est l’en-tête de la fonction, aussi appelé sa signature. Cet en-tête est suivi par le bloc d’instructions, qui est indenté, et peut contenir n’importe quel nombre d’instructions. La définition de la fonction se termine lorsque l’indentation est terminée.
Pour appeler la fonction une fois qu’elle est définie, il suffit d’écrire son nom suivi de parenthèses, comme pour les fonctions pré-définies.
Il est possible de créer de nouvelles variables à l’intérieur d’une fonction :
# Définition de la fonction state
def state():
my_state = "Je suis " + "en forme"
print(my_state)
# Appel de la fonction
state()
Je suis en forme
Ici nous avons re-défini la fonction state, et à l’intérieur de cette fonction nous avons défini la variable my_state, qui est le résultat d’une concaténation de chaînes de caractères. Cette variable n’existe pas en dehors du champ de la fonction, elle est détruite à la fin de l’exécution du bloc d’instructions. Ainsi, le code suivant produit une erreur :
# Définition de la fonction state
def state():
my_state = "Je suis " + "en forme"
print(my_state)
# Appel de la fonction
state()
# Test de l'usage de la variable my_state
print(my_state)
Je suis en forme
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In[4], line 10
7 state()
9 # Test de l'usage de la variable my_state
---> 10 print(my_state)
NameError: name 'my_state' is not defined
La variable my_state a donc une portée limitée (en anglais : scope) : elle n’existe que dans la fonction state. À l’inverse, une variable qui est définie en dehors d’une fonction a une portée dite globale : elle est accessible depuis n’importe quelle partie du programme, même depuis l’intérieur d’une fonction.
Exercice#
Créer une fonction nommée cube. Dans le bloc d’instructions, calculer le cube du nombre 3 (sans utiliser de fonction pré-définie) et affecter le résultat à une variable nommée result, puis afficher cette variable à l’écran. Tester votre fonction en l’appelant.
Show code cell source
# Définition de la fonction cube
def cube():
result = 3 ** 3
print(result)
# Appel de la fonction
cube()
27
Paramètres et arguments#
La plupart des fonctions pré-définies que nous avons vues nécessitent des arguments. Par exemple :
str(2)
'2'
prend comme argument l’entier 2. Lorsque l’on définit une fonction, les arguments sont assignés à des variables appelées paramètres. Définissons de nouveau la fonction state avec un paramètre :
# Définition de la fonction state
def state(mot):
my_state = "Je suis " + mot
print(my_state)
# Appel de la fonction
state("en forme")
Je suis en forme
Lorsque l’on appelle la fonction state, l’argument entre parenthèses, "en forme", est assigné au paramètre mot. La partie de l’en-tête qui définit le nom de la fonction et son (ou ses) paramètre(s), ici state(mot), est appelée la signature de la fonction.
Exercice#
Reprendre la fonction cube. Définir un paramètre appelé x afin de pouvoir mettre au cube n’importe quel nombre. La signature de la fonction est donc cube(x). Tester la fonction avec le nombre 3.
Show code cell source
# Définition de la fonction cube
def cube(x):
result = x ** 3
print(result)
# Appel de la fonction
cube(3)
27
Retourner une valeur#
Nous avons vu que les fonctions pré-définies retournent généralement une valeur, que l’on peut affecter à une variable. Par exemple :
s2 = str(2)
Il est souvent préférable lorsque l’on définit une fonction de retourner la valeur plutôt que l’afficher avec print(). Pour cela, nous utilisons l’instruction return. Reprenons notre fonction state :
# Définition de la fonction state
def state(mot):
my_state = "Je suis " + mot
return my_state
# Appel de la fonction
s = state("en forme")
print(s)
Je suis en forme
Grâce à l’instruction return, nous avons pu affecter le résultat de la fonction à une nouvelle variable s.
Exercice#
Reprendre la fonction cube et remplacer l’instruction print() par return. Affecter le résultat de la fonction pour l’argument 3 à une nouvelle variable et l’afficher à l’écran (en dehors de la fonction).
Show code cell source
# Définition de la fonction cube
def cube(x):
result = x ** 3
return result
# Appel de la fonction
c3 = cube(3)
print(c3)
27
Vidéo: Les fonctions (2)#
Docstrings#
Nous avons vu précédemment qu’il est essentiel de commenter son code, pour les autres et soi-même. De la même façon, il est essentiel lorsque l’on crée une fonction de décrire son utilité. Pour cela nous utilisons les Docstrings :
# Définition de la fonction state
def state(mot):
""" Affiche mon état à l'écran """
my_state = "Je suis " + mot
return my_state
Le Docstring s’écrit juste après l’en-tête de la fonction, entre triple guillemets. Cela sert de documentation à votre fonction.
Exercice#
Reprendre la fonction cube et documenter cette fonction.
Show code cell source
# Définition de la fonction cube
def cube(x):
""" Retourne le cube d'une valeur """
result = x ** 3
return result
Paramètres multiples#
Nous avons vu une fonction avec un seul paramètre. Cependant, il est possible de définir autant de paramètres que l’on veut. Voici la fonction state avec 2 paramètres, dont la signature est state(mot, jour) :
# Définition de la fonction state
def state(mot, jour):
""" Affiche mon état à l'écran """
my_state = "Le " + jour + ", je suis " + mot
return my_state
# Appel de la fonction
s = state("en forme", "lundi")
print(s)
Le lundi, je suis en forme
On voit qu’il faut faire attention à l’ordre dans lequel on écrit les arguments lors de l’appel de la fonction : les arguments sont assignés dans le même ordre aux paramètres.
Il est possible de définir une valeur par défaut du (ou des) dernier(s) paramètre(s), avec le signe =. Lors de l’appel de la fonction, on n’est alors pas obligé de spécifier le deuxième argument, qui prend la valeur par défaut :
# Définition de la fonction state
def state(mot, jour = "lundi"):
""" Affiche mon état à l'écran """
my_state = "Le " + jour + ", je suis " + mot
return my_state
# Appel de la fonction
s = state("en forme")
print(s)
s = state("fatigué", "vendredi")
print(s)
Le lundi, je suis en forme
Le vendredi, je suis fatigué
Exercice#
Écrire une fonction de signature add(a, b = 1) qui retourne la somme de a et b. Par défaut, b est égal à 1. Tester et documenter la fonction.
Show code cell source
# Définition de la fonction add
def add(a, b = 1):
"""
Retourne la somme des valeurs a et b passée en paramètres.
a est obligatoire, b est optionnel et vaut 1 par défaut.
"""
result = a + b
return result
# Test de la fonction
x = add(5)
print(x)
x = add(4, 8)
print(x)
6
12
Retours multiples#
Il est possible de retourner plusieurs valeurs avec l’instruction return, en les séparant par des virgules. Les valeurs sont alors retournées sous la forme d’un tuple (voir le calepin sur le module Numpy) :
# Définition de la fonction state
def state(mot, jour = "lundi"):
""" Affiche à l'écran mon état et le nombre de caractères """
my_state = "Le " + jour + ", je suis " + mot
my_state_length = len(my_state)
return (my_state, my_state_length)
# Appel de la fonction
t = state("content", "mercredi")
print(t)
('Le mercredi, je suis content', 28)
Vérifions que l’objet retourné est bien un tuple avec 2 éléments :
print(type(t))
print(len(t))
<class 'tuple'>
2
Dans l’exemple, on a affecté le tuple à une nouvelle variable. Il est aussi possible d’affecter directement les 2 éléments du tuple dans deux nouvelles variables :
# Appel de la fonction
s, l = state("content", "mercredi")
print(s)
print("Cette phrase contient", l, "caractères")
Le mercredi, je suis content
Cette phrase contient 28 caractères
Exercice#
Créer une fonction de signature addmul(a, b) qui retourne la somme et le produit de a et b. Documenter et tester la fonction.
Show code cell source
# Définition de la fonction addmul
def addmul(a, b):
""" Retourne la somme et le produit de a et b """
somme = a + b
produit = a * b
return (somme, produit)
# Test de la fonction
addmul(2, 6)
(8, 12)
Forme Lambda#
Reprenons la fonction de signature state(mot) :
# Définition de la fonction state
def state(mot):
my_state = "Je suis " + mot
return my_state
# Appel de la fonction
state("en forme")
'Je suis en forme'
La forme lambda de cette fonction est :
# Forme lambda
lambda mot : "Je suis " + mot
<function __main__.<lambda>(mot)>
Cette expression est formée du mot-clef lambda, de la variable mot et de l’instruction "Je suis " + mot. Vous notez que la forme lamda ici n’a pas de nom, contrairement à une fonction définie avec le mot-clef def. C’est une fonction anonyme.
Ainsi, la syntaxe générale est:
lambda nom_variable : instruction
Pour donner une valeur d’entrée à la forme lambda, on écrit :
(lambda mot : "Je suis " + mot)("en forme")
'Je suis en forme'
On peut aussi donner un nom à la forme lambda :
# Forme lambda
state_lambda = lambda mot : "Je suis " + mot
# Appel
state_lambda("en forme")
'Je suis en forme'
Il est possible de faire des formes lambda plus compliquées. Par exemple :
(lambda mot, jour = "lundi" : ("Le " + jour + ", je suis " + mot, len("Le " + jour + ", je suis " + mot)))("content", "mercredi")
('Le mercredi, je suis content', 28)
Cependant, ce n’est pas lisible et une fonction classique est mieux adaptée dans ce cas.
Exercice#
Créez une forme lambda qui retourne le carré d’un argument, et testez-la.
Show code cell source
# Forme lambda
(lambda x : x ** 2)(5)
25