PROGRAMMATION EN LANGAGE PYTHON LES FONCTIONS

Chapitre 6 : Les Fonctions

Sommaire :
1) Introduction........................................................................................................................2
2) Définition d’une fonction - def..........................................................................................2
3) Passage d'arguments..........................................................................................................3
4) Renvoi de plusieurs objets à la fois...................................................................................4
5) Arguments positionnels et arguments par mot-clé............................................................5
a) Les arguments positionnels............................................................................................5
b) Les arguments par mot-clé.............................................................................................5
c) Mélange des arguments..................................................................................................6
6) Variables locales, variables globales.................................................................................7
a) Les variables locales......................................................................................................7
b) Utilisation d’une variable globale - global.....................................................................8

ELBASRI OFPPT Page 1 sur 8

PROGRAMMATION EN LANGAGE PYTHON LES FONCTIONS

1) Introduction
En programmation, les fonctions sont très utiles pour réaliser plusieurs fois la même opération au
sein d'un programme. Elles rendent également le code plus lisible et plus clair en le fractionnant
en blocs logiques.
Nous avons déjà rencontré diverses fonctions prédéfinies : print(), input(), range().
Une fonction est un bloc de code qui ne s'exécute que lorsqu'elle est appelée. Elle peut être
considérée comme une sorte de « boîte noire » :
 À laquelle vous passez aucune, une ou plusieurs paramètre(s) entre parenthèses.
 Qui effectue une action.
 Et qui renvoie un objet Python ou rien du tout.

Par exemple, si vous appelez la fonctions print , len et max de la manière suivante :
>>> liste = [0, 10, 12]
>>> print(liste) # affiche le contenu de liste
[0, 10, 12]
>>> len(liste) # renvoie la longueur de liste
3
>>> max(liste) # renvoie le plus grand élément de liste
12

2) Définition d’une fonction - def

Pour définir une fonction, Python utilise le mot-clé def. Si on souhaite que la fonction renvoie
quelque chose, il faut utiliser le mot-clé return.
Syntaxe
La syntaxe Python pour la définition d’une fonction est la suivante :
def nom_fonction (liste de paramètres) :

ELBASRI OFPPT Page 2 sur 8

PROGRAMMATION EN LANGAGE PYTHON LES FONCTIONS

bloc d'instructions
 La syntaxe de def utilise les : (deux-points) comme les tests if et les boucles for et while.
 L'indentation du bloc d'instructions (appelé corps de la fonction) est obligatoire.
 Les paramètres doivent être séparés par des virgules (param1, param2, …. , paramN).
Notez qu'une fonction ne prend pas forcément un argument et ne renvoie pas forcément une
valeur, par exemple :
Exemple 1 : Fonction sans aucun argument
#Définition de la fonction hello
def hello():
print("Bonjour")

hello() # Appel de la fonction hello

Dans ce cas la fonction, hello () se contente d'afficher la chaîne de caractères "Bonjour" à
l'écran. Elle ne prend aucun argument et ne renvoie rien.
Exemple 2 : Fonction avec un seul argument
Dans cet exemple la fonction, carre ( x ) calcul et renvoie le carré du nombre x passé en
argument.
#Définition de la fonction carre
def carre ( x ):
return x ** 2

# Programme principal
a = 5
c = carre (a) # Appel de la fonction carre
print("Le carré de", a , " est :" , c )
Affichage après exécution :
Le carré de 5 est : 25

3) Passage d'arguments
Le nombre d'arguments que l'on peut passer à une fonction est variable. Nous avons vu ci-dessus
des fonctions auxquelles on passait 0 ou 1 argument.
Pour définir une fonction avec plusieurs paramètres, il suffit d’inclure ceux-ci entre les
parenthèses qui suivent le nom de la fonction, en les séparant à l’aide de virgules.
Lors de l’appel de la fonction, les arguments utilisés doivent être fournis dans le même ordre que
celui des paramètres correspondants (en les séparant eux aussi à l’aide de virgules). Le premier

ELBASRI OFPPT Page 3 sur 8

PROGRAMMATION EN LANGAGE PYTHON LES FONCTIONS

argument sera affecté au premier paramètre, le second argument sera affecté au second
paramètre, et ainsi de suite.
Exemple : Fonction compteur à 3 paramètres¶
La fonction suivante utilise trois paramètres :
 start qui contient la valeur de départ,
 stop la borne supérieure (non inclue).
 step le pas du compteur.
# Définition de la fonction compteur Affichage après exécution :
def compteur (start, stop, step):
1
i = start
3
while i < stop:
5
print(i)
7
i = i + step
9

# Appel de la fonction compteur

compteur (1, 10, 2)

4) Renvoi de plusieurs objets à la fois

Un énorme avantage en Python est que les fonctions sont capables de renvoyer plusieurs objets à
la fois, comme dans cette fraction de code :
# Définition de la fonction carre_cube
def carre_cube(x):
return x**2, x**3

# Appel de la fonction carre_cube

res = carre_cube (2)
print ( res)
Affichage après exécution :
(4, 8)
Récupération des valeurs renvoyées
Renvoyer deux éléments (ou plus) est très pratique en conjonction avec l'affectation multiple,
def carre_cube(x): z1, z2 = carre_cube2(3)
return x**2, x**3 print("z1 = ", z1)
print("z2 = ", z2)

ELBASRI OFPPT Page 4 sur 8

PROGRAMMATION EN LANGAGE PYTHON LES FONCTIONS

Affichage après exécution : z1 = 9

z2 = 27
Cela permet de récupérer plusieurs valeurs renvoyées par une fonction et de les affecter à la volée
à des variables différentes.

5) Arguments positionnels et arguments par mot-clé

Jusqu'à maintenant, nous avons systématiquement passé le nombre d'arguments que la fonction
attendait. Que se passe-t-il si une fonction attend deux arguments et que nous ne lui en passons
qu'un seul ?
def somme(x, y):
return x + y

print(somme (2,5))
print(somme (2))
Affichage après exécution :
7
Traceback (most recent call last):
File "<somme.py>", line 4, in <module>
TypeError: somme() missing 1 required positional argument: 'y'
On constate que passer un seul argument à une fonction qui en attend deux, conduit à une erreur.
a) Les arguments positionnels
Lorsqu'on définit une fonction def fct(x, y): les arguments x et y sont appelés arguments
positionnels (en anglais positional arguments). Il est strictement obligatoire de les préciser lors
de l'appel de la fonction.
De plus, il est nécessaire de respecter le même ordre lors de l'appel que dans la définition de la
fonction. Dans l'exemple ci-dessus, 2 correspondra à x et 3 correspondra à y. Finalement, tout
dépendra de leur position, d'où leur qualification de positionnel.
b) Les arguments par mot-clé
Il est aussi possible de passer un ou plusieurs argument(s) de manière facultative et de leur
attribuer une valeur par défaut :
def fct(x = 1): print(x1, x2)
return x

x1 = fct()
x2 = fct(10)

ELBASRI OFPPT Page 5 sur 8

PROGRAMMATION EN LANGAGE PYTHON LES FONCTIONS

Affichage après exécution : 1 10

Un argument défini avec une syntaxe def fct(arg=val): est appelé argument par mot-clé (en
anglais keyword argument). Le passage d'un tel argument lors de l'appel de la fonction est
facultatif. Ce type d'argument ne doit pas être confondu avec les arguments positionnels présentés
ci-dessus, dont la syntaxe est def fct(arg):.
Il est bien sûr possible de passer plusieurs arguments par mot-clé :
>>> def fct(x=0, y=0, z=0):
... return x, y, z
...
>>> fct()
(0, 0, 0)
>>> fct(10)
(10, 0, 0)
>>> fct(10, 8)
(10, 8, 0)
>>> fct(10, 8, 3)
(10, 8, 3)
Python permet même de rentrer les arguments par mot-clé dans un ordre arbitraire :
>>> fct(z=10, x=3, y=80)
(3, 80, 10)
>>> fct(z=10, y=80)
(0, 80, 10)
c) Mélange des arguments
Que se passe-t-il lorsque nous avons un mélange d'arguments positionnels et par mot-clé ? Et
bien les arguments positionnels doivent toujours être placés avant les arguments par mot-clé :
>>> def fct(a, b, x=0, y=0, z=0):
... return a, b, x, y, z
...
>>> fct(1, 1)
(1, 1, 0, 0, 0)
>>> fct(1, 1, z=5)
(1, 1, 0, 0, 5)
>>> fct(1, 1, z=5, y=32)
(1, 1, 0, 32, 5)

ELBASRI OFPPT Page 6 sur 8

PROGRAMMATION EN LANGAGE PYTHON LES FONCTIONS

On peut toujours passer les arguments par mot-clé dans un ordre arbitraire à partir du moment où
on précise leur nom.
Par contre, si les deux arguments positionnels a et b ne sont pas passés à la fonction, Python
renvoie une erreur.
>>> fct(z=0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: fct() missing 2 required positional arguments: 'a' and 'b'
Conseil: Préciser le nom des arguments par mot-clé lors de l'appel d'une fonction est une pratique
que nous vous recommandons. Cela les distingue clairement des arguments positionnels.

6) Variables locales, variables globales

Lorsqu’une fonction est appelée, Python réserve pour elle (dans la mémoire de l’ordinateur) un
espace de noms. Cet espace de noms local à la fonction est à distinguer de l’espace de noms
global où se trouvaient les variables du programme principal.
Dans l’espace de noms local, nous aurons des variables qui ne sont accessibles qu’au sein de la
fonction. C’est par exemple le cas des variables start, stop, step et i dans l’exemple précédent.
a) Les variables locales
A chaque fois que nous définissons des variables à l’intérieur du corps d’une fonction, ces
variables ne sont accessibles qu’à la fonction elle-même. On dit que ces variables sont des
variables locales à la fonction.
Une variable locale peut avoir le même nom qu’une variable de l’espace de noms global mais elle
reste néanmoins indépendante.
Les contenus des variables locales sont stockés dans l’espace de noms local qui est inaccessible
depuis l’extérieur de la fonction.
Les variables définies à l’extérieur d’une fonction sont des variables globales. Leur contenu est «
visible » de l’intérieur d’une fonction, mais la fonction ne peut pas le modifier.

Exemple : Variable locale test()

def test(): print(a, b)
b = 5
print(a, b)

a = 2
b = 7
print(a, b)

ELBASRI OFPPT Page 7 sur 8

PROGRAMMATION EN LANGAGE PYTHON LES FONCTIONS

Affichage après exécution : 2 5

2 7 2 7

b) Utilisation d’une variable globale - global

Il peut se faire par exemple que vous ayez à définir une fonction qui soit capable de modifier une
variable globale. Pour atteindre ce résultat, il vous suffira d’utiliser l’instruction global. Cette
instruction permet d’indiquer - à l’intérieur de la définition d’une fonction - quelles sont les
variables à traiter globalement.
On va ici créer une fonction qui a accès à la variable globale b.
Exemple : Variable globale Affichage après exécution :
def test(): 2 7
global b 2 5
b = 5 2 5
print(a, b)

a = 2
b = 7
print(a, b)
test()
print(a, b)

ELBASRI OFPPT Page 8 sur 8