ISET-Sousse Préparation à la certification PYTHON 2

----------------------------------------------------------------------------------

CH1 : Les fonctions

I. Les fonctions
Les fonctions sont les éléments structurants de base de tout langage procédural. Elles offrent
différents avantages :
✓ Évitent la répétition : on peut « factoriser » une portion de code qui se répète lors de
l’exécution en séquence d’un script ;
✓ Mettent en relief les données et les résultats : entrées et sorties de la fonction ;
✓ Permettent la réutilisation : mécanisme de l’import ;
✓ Décomposent une tâche complexe en tâches plus simples : conception de
l’application.

1) Définition et syntaxe
Définition
Une fonction est un ensemble d’instructions regroupées sous un nom et s’exécutant à la
demande. On doit définir une fonction à chaque fois qu’un bloc d’instructions se trouve à
plusieurs reprises dans le code ; il s’agit d’une « factorisation de code ».
Syntaxe
Une fonction se compose :
- du mot clé def suivi de l’identificateur de la fonction, de parenthèses entourant les
paramètres de la fonction séparés par des virgules, et du caractère « deux points » qui termine
toujours une instruction composée ;
- d’une chaîne de documentation (ou docstring) indentée comme le corps de la fonction ;
- du bloc d’instructions indenté par rapport à la ligne de définition, et qui constitue le corps de
la fonction.
Le bloc d’instructions est obligatoire. S’il est vide, on emploie l’instruction pass.
Créons une fonction qui nous retournera un âge:

>>> def indique_mon_age():

... return 20;

...

>>> indique_mon_age()

20

Tout d'abord pour indiquer à l'interpréteur qu’on veut créer une fonction, on utilise le mot
clé def suivi d'un nom puis de parenthèses et ensuite d'un double point.
On remarque également qu'il y a un espace entre les 3 points et le mot clé "return", il s'agit
d'une indentation, c'est à dire un espace qui améliore non seulement la lecture de la fonction
mais qui indique que nous sommes toujours dans la fonction. Lorsque l'action demandée n'est

------------------------------------------------------------------------------------

Page 1 sur 8 Enseignante : Emna Bouzid – AU :2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------
plus dans la fonction, il ne faut plus indenter le texte. Pour indenter du texte, on peut appuyer
sur la touche TAB du clavier -ou dans d'autres cas créer 4 espaces manuellement.

2) Les paramètres
Créons une autre fonction:

>>> def augmente_moi(a):

... return augmente_moi + 2

...

>>> augmente_moi(1)

Cette fonction incrémente de 2 une valeur que l'on passe en paramètre.

Il est d'ailleurs possible d'utiliser plusieurs paramètres:

>>> def augmente_moi(a, b):

... return 30 + a + b

...

>>> augmente_moi(1, 2)

33

N.B Lorsqu’on doit donner des paramètres à une fonction, ces derniers doivent
impérativement être renseignés.

>>> def augmente_moi(a, b):

... return 30 + a + b

...

>>> augmente_moi(1)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: augmente_moi() takes exactly 2 arguments (1 given)

------------------------------------------------------------------------------------

Page 2 sur 8 Enseignante : Emna Bouzid – AU :2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------
2.1 L'opérateur splat
L'opérateur splat : * est très souvent utilisé en python.

def ma_function(*var)

def ma_function(**var)

ma_function(*var)

ma_function(**var)

2.2 Une liste en paramètre

On peut récupérer les valeurs renseignées via une liste:

>>> def augmente_moi(*param):

... return param[0] + param[1] + param[2]

...

>>> augmente_moi(1, 2, 3)

>>> augmente_moi(10, 20, 30)

60

Si on veut rendre obligatoire uniquement certains paramètres, on peut utiliser la syntaxe

suivante:

>>> def ma_fiche(prenom, nom, *reste):

... return prenom + " " + nom

...

>>> ma_fiche("Foulen","Ben Foulen")

' Foulen Ben Foulen'

2.3 Utiliser un splat dictionnaire pour les paramètres

Syntaxe
Collection de couples cle : valeur entourée d’accolades.

------------------------------------------------------------------------------------

Page 3 sur 8 Enseignante : Emna Bouzid – AU :2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------
Les dictionnaires sont modifiables mais non-ordonnés : leur emplacement est géré par un
algorithme spécifique (algorithme de hash). Une clé pourra être alphabétique, numérique…
en fait tout type hachable (donc liste et dictionnaire exclus). Les valeurs pourront être de tout
type sans exclusion.
On peut utiliser un dictionnaire en paramètres pour cela on doit ajouter une double étoile: **

>>> def ma_fiche(**parametres):

... return parametres["prenom"]

...

>>> ma_fiche(prenom="Foulen")

'Foulen'

2.4 Utilisation de splat liste au niveau des appels de fonctions

Reprenons l'exemple de la fonction augmente_moi :

>>> def augmente_moi(*param):

... return param[0] + param[1] + param[2]

...

Nous avons vu qu'il était possible de faire ceci:

>>> augmente_moi(1, 2, 3)

L'utilisation de l'étoile permet de passer par une liste:

>>> data = [1, 2, 3]

>>> augmente_moi(*data)

2.5 Utilisation de dictionnaire au niveau des appels de fonctions

Prenons l'exemple de cette fonction:

------------------------------------------------------------------------------------

Page 4 sur 8 Enseignante : Emna Bouzid – AU :2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------

>>> def test(firstname="", lastname=""):

... return "{} {}" .format(firstname, lastname)

Créons notre dictionnaire:

>>> data = {'firstname':'Foulen', 'lastname':'Ben Foulen'}

Et envoyons notre variable avec une étoile *

>>> test(*data)

' firstname lastname '

Puis avec deux étoiles **

>>> test(**data)

' Foulen Ben Foulen'

3) Renvoyer plusieurs valeurs

Python permet à une fonction de retourner plusieurs valeurs. Le code ci-dessous définit une
fonction qui prend deux nombres et les renvoie dans l’ordre croissant.

1. def Sort(number1, number2):

2. if number1 < number2:
3. return number1, number2
4. else:
5. return number2, number1
6.
7. n1, n2 = Sort(3, 2)
8. print("n1 est ", n1)
9. print("n2 est ", n2)

Voici le résultat du code ci-dessus :

• n1 est 2
• n2 est 3

------------------------------------------------------------------------------------

Page 5 sur 8 Enseignante : Emna Bouzid – AU :2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------
La fonction Sort renvoie deux valeurs. Quand elle est appelée, on peut récupérer les valeurs
retournées en utilisant une affectation simultanée (n1, n2 = Sort(3, 2)).

4) Portée des variables (variable globale et variable locale)

Une variable déclarée à la racine d'un module est visible dans tout ce module. On parle alors
de variable globale.

>>> x = "hello"

>>> def test():

... print x

...

>>> test()

hello

Et une variable déclarée dans une fonction ne sera visible que dans cette fonction. On parle
alors de variable locale.

>>> x = False

>>> def test():

... x = "hello"

...

>>> test()

>>> x

False

II. Fonctions anonymes ou lambda

1) Définition et syntaxe
Définition
Pour des fonctions très courtes, on peut utiliser des fonctions anonymes, connues aussi comme
expressions lamda.

Syntaxe :
nom_fonction = lambda param_1, ..., param_n : expression

▪ lambda au lieu de def ;

▪ pas de parenthèses;
------------------------------------------------------------------------------------

Page 6 sur 8 Enseignante : Emna Bouzid – AU :2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------
▪ pas de mot clé return .

nom_fonction est le nom de la fonction, param_1 à param_n sont les paramètres de cette
fonction (ils peuvent également recevoir des valeurs par défaut), expression est
l’expression retournée par la fonction.
L’exemple suivant utilise cette écriture pour définir la fonction min retournant le plus
petit entre deux nombres positifs.
<<<
min = lambda x, y: (abs(x + y) - abs(x - y)) / 2

print(min(1, 2)) # affiche 1

print(min(5, 4)) # affiche 4

>>>
1.0
4.0

Cette écriture correspond à l’écriture non condensée suivante :

<<<
def min(x, y):
return (abs(x + y) - abs(x - y)) / 2
print(min(1, 2)) # affiche 1
print(min(5, 4)) # affiche 4

>>>
1.0
4.0

La fonction lambda considère le contexte de fonction qui la contient comme son contexte.
Il est possible de créer des fonctions lambda mais celle-ci utiliseront le contexte dans
l’état où il est au moment de son exécution et non au moment de sa création.
<<<
fs = []
for a in range(0, 10):
f = lambda x: x + a
fs.append(f)
for f in fs:
print(f(1)) # le programme affiche 10 fois 10 de suite
# car la variable a vaut dix à la fin de la boucle

>>>

------------------------------------------------------------------------------------

Page 7 sur 8 Enseignante : Emna Bouzid – AU :2020/2021

 ISET-Sousse Préparation à la certification PYTHON 2
----------------------------------------------------------------------------------
10
10
10
10
10
10
10
10
10
10

Pour que le programme affiche les entiers de 1 à 10, il faut préciser à la

fonction lambda une variable y égale à a au moment de la création de la fonction et qui
sera intégrée au contexte de la fonction lambda :
<<<
fs = []
for a in range(0, 10):
f = lambda x, y=a: x + y # ligne changée
fs.append(f)
for f in fs:
print(f(1))

1
2
3
4
5
6
7
8
9
10

2) Les limites des lambdas

Les lambdas en Python se caractérisent par les limites suivantes:

• On ne peut les écrire que sur une ligne.

• On ne peut pas avoir plus d’une instruction dans la fonction.

------------------------------------------------------------------------------------

Page 8 sur 8 Enseignante : Emna Bouzid – AU :2020/2021