Chapitre 7 - Fonctions
INF1007 : Introduction à la
programmation
Chapitre 7 - Fonctions
Génie informatique et genie logiciel Benjamin De Leener 1 A2025
Chapitre 7 - Fonctions
Plan du cours
1. Définition, paramètres et arguments
2. Fonctions avancées
3. Portée des variables (globale, locale, non-locale) et
concept d’espace de noms
4. Fonctions natives, modules et librairies
Génie informatique et genie logiciel Benjamin De Leener 2 A2025
Chapitre 7 - Fonctions
Définition d’une fonction
Une fonction est une structure permettant de découper un
programme en plusieurs sous-programmes. Elle est
définie par:
• son nom 1 def nomDeLaFonction(paramètres):
• ses paramètres 2 ...
(optionnels) 3 bloc d'instructions
• sa valeur de retour 4 ...
(optionnelle) 5 return résultat
Génie informatique et genie logiciel Benjamin De Leener 3 A2025
Chapitre 7 - Fonctions
Définition d’une fonction
• Vous pouvez choisir n’importe quel nom pour la fonction, à l’exception
des noms réservés, et sans aucun caractère spécial ou accentué
(« _ » est permis).
• « def » définit une instruction composée, de la même manière que les
if, while, for. La ligne doit donc se terminer par un double point « : »
• Les paramètres de la fonction sont aussi appelés des « arguments »
et définissent l’information que la fonction a besoin pour fonctionner.
Ces paramètres peuvent avoir une valeur par défaut.
• Afin d’utiliser une fonction, on utilise un « appel de fonction », en
utilisant les parenthèses.
• Une fonction Python peut (mais ne doit pas nécessairement) renvoyer
un résultat à l’aide de l’instruction « return ».
Génie informatique et genie logiciel Benjamin De Leener 4 A2025
Chapitre 7 - Fonctions
Exemple
1 def addition(a, b):
2 c = a + b
3 return c
4
5 x = addition(123, 5)
print(x)
Génie informatique et genie logiciel Benjamin De Leener 5 A2025
Chapitre 7 - Fonctions
À quoi sert une fonction ?
• Éviter 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 programme
• Mettre en évidence les données, l’algorithme et les résultats : la
fonction est définit par ses entrées (les arguments) et ses sorties
(les valeurs de retour). Les instructions à l’intérieur de la fonction
définissent l’algorithme
• Permettre la réutilisation du code : grâce au mécanisme
d’importation, il est possible de réutiliser les fonctions implémentées
dans un autre programme
• Décompose une tâche complexe en tâches plus simples
Génie informatique et genie logiciel Benjamin De Leener 6 A2025
Chapitre 7 - Fonctions
Fonctions simples
La plus simple des fonctions ne demande aucun argument et ne
retourne aucune valeur. Elle permet de décomposer le code en
sous-parties. Une fonction peut en appeler une autre.
1 def table7(): 8 def table7triple():
2 n = 1 9 table7()
3 while n < 11: 10 table7()
4 print(n * 7) 11 table7()
5 n = n + 1 12
6 13 table7triple()
7 table7() # appel
Génie informatique et genie logiciel Benjamin De Leener 7 A2025
Chapitre 7 - Fonctions
Fonctions avec un paramètre
1 def table(base):
Les paramètres d’une fonction
sont définis entre les 2 n = 1
parenthèses. Grâce au typage 3 while n < 11:
dynamique du Python, il n’est
pas nécessaire de spécifier le 4 print(n * base)
type des arguments. Attention 5 n = n + 1
aux erreurs!
6
Nous pouvons également
« passer » des variables comme 7 table(9) # appel en base 9
arguments des fonctions. 8 table(17) # appel en base 17
Attention: le nom de la variable
9 for a in range(20):
utilisé est propre à la fonction.
10 table(a)
Génie informatique et genie logiciel Benjamin De Leener 8 A2025
Chapitre 7 - Fonctions
Fonctions avec plusieurs paramètres
Nous pouvons définir jusqu’à 255 paramètres à une fonction, identifiés
par leur nom, et en les séparant par des virgules. Lors de l’appel de
la fonction, ces arguments doivent être donnés dans le même ordre!
1 def tableMulti(base, debut, fin):
2 print('Fragment de la table de multiplication par', base, ':')
3 n = debut
4 while n <= fin:
5 print(n, 'x', base, '=', n * base)
6 n = n + 1
7 tableMulti(12, 5, 15)
Génie informatique et genie logiciel Benjamin De Leener 9 A2025
Chapitre 7 - Fonctions
Retour d’une fonction
Certains diront qu’une fonction n’est pas une vraie fonction si elle ne
retourne pas de valeur en sortie, on l’appellerait une procédure. Nous
pouvons notamment utiliser l’instruction return pour renvoyer une
ou des valeurs à la sortie de la fonction. Voici quelques exemples :
1 def cube(w): 1 def table(base):
2 return w**3 2 result = []
3 def volumeSphere(r): 3 n = 1
4 return 4 * 3.1416 * cube(r) / 3 4 while n < 11:
5 5 b = n * base
6 r = float(input('Valeur du rayon : ')) 6 result.append(b)
7 print('Volume =', volumeSphere(r)) 7 n = n + 1
8 return result
Génie informatique et genie logiciel Benjamin De Leener 10 A2025
Chapitre 7 - Fonctions
Exercices
1. Écrivez une fonction qui renvoie la factorielle d'un nombre donné.
1. Étant donné une phrase par l'utilisateur, écrivez une fonction qui
construit et affiche l'histogramme des lettres utilisées dans la
phrase.
Génie informatique et genie logiciel Benjamin De Leener 11 A2025
Chapitre 7 - Fonctions
Valeurs par défaut
1 def tableMulti(base, début=1, fin=10):
2 print('Fragment de la table de multiplication par', base, ':')
3 n = debut
4 while n <= fin:
5 print(n, 'x', base, '=', n * base)
6 n = n + 1
7 tableMulti(12, 5, 15)
8 tableMulti(12, 5)
9 tableMulti(12)
Si une valeur par défaut est fournie dans la définition de la fonction, nous
pouvons y faire appel sans y passer tous ses arguments. Les valeurs
par défaut seront alors utilisées. Attention à l’ordre des arguments!
Génie informatique et genie logiciel Benjamin De Leener 12 A2025
Chapitre 7 - Fonctions
Arguments facultatifs (optional)
Les arguments d’une fonction
peuvent être configurés de sorte 1 def ma_fonction(x=None):
à ne pas être obligatoires. Il faut 2 if x:
pour cela donner une valeur par
défaut, avec l’opérateur 3 print(x)
d’assignation dans la définition 4 else:
de la fonction, qui peut être
égale à None ou à toute autre 5 print('rien')
valeur. 6
Cet argument aura donc la valeur 7 ma_function('test')
donnée dans la définition de la
8 ma_function()
variable si aucune valeur n’est
passée à la fonction.
Génie informatique et genie logiciel Benjamin De Leener 13 A2025
Chapitre 7 - Fonctions
Nombre d’arguments arbitraires
1 def somme(*nombres):
Le nombre d’arguments passés à une
fonction peut être arbitraire en 2 resultat = 0
utilisant la notation étoilée 🡪 3 for nombre in nombres:
Les arguments sont alors passés à la 4 resultat += nombre
fonction dans un tuple.
5 return resultat
Il est également possible de passer un
6
dictionnaire en paramètre d’une
fonction, avec la notation « double 7 print(somme(23))
étoile ».
8 print(somme(23, 42, 13))
1 def fonction(**params):
2 return params
3 print(fonction(a=42, b=23))
Génie informatique et genie logiciel Benjamin De Leener 14 A2025
Chapitre 7 - Fonctions
Exercices
Écrivez une fonction dessiner_boite en Python qui
affiche une boîte rectangulaire formée de caractères.
La fonction doit avoir trois paramètres avec des
valeurs par défaut:
○ caractere="*"
○ largeur=5 : le nombre de caractères par ligne
○ hauteur=3 : le nombre de lignes de la boîte
La boîte doit être remplie uniquement avec le
caractère choisi (pas de bordures différentes).
Génie informatique et genie logiciel Benjamin De Leener 15 A2025
Chapitre 7 - Fonctions
Retour anticipé (early return)
Important!
1 def trier_liste(x): Dès que l’instruction return est
2 if len(x) == 0: rencontrée, le programme sort de la
fonction. Le reste du code de la
3 return []
fonction n’est alors pas exécuté.
4 …
5
6
7
Génie informatique et genie logiciel Benjamin De Leener 16 A2025
Chapitre 7 - Fonctions
Retour d’une fonction
Si plusieurs valeurs renvoyées par la fonction, celles-ci sont
assemblées dans un tuple. Il s’agit donc de les récupérer de la
bonne manière. Une fonction peut renvoyer n’importe quel type de
données. Par exemple :
1 def ordre(a, b):
2 if a <= b:
3 return a, b
4 else:
5 return b, a
6 ordonné = ordre(50, 2)
7 print(ordonné)
Génie informatique et genie logiciel Benjamin De Leener 17 A2025
Chapitre 7 - Fonctions
Exercices
Génie informatique et genie logiciel Benjamin De Leener 18 A2025
Chapitre 7 - Fonctions
Exercices
1. Écrire des fonctions pour effectuer le chiffrement César (shift_char,
shift_gauche, shift_droite, shift_phrase)
2. Écrire une fonction pour effectuer une attaque par force brute
Génie informatique et genie logiciel Benjamin De Leener 19 A2025
Chapitre 7 - Fonctions
Fonctions de rappel
Les arguments passés aux fonctions ne doivent pas nécessairement
être des types de données standards. On peut également leur
passer des fonctions. Par exemple:
1 def addition(x, y): 6 def operation(x, y, f):
2 return x + y 7 return f(x, y)
3 8
4 def multiplication(x, y): 9 operation(3, 4, addition)
5 return x * y 10 operation(3, 4, multiplication)
Génie informatique et genie logiciel Benjamin De Leener 20 A2025
Chapitre 7 - Fonctions
Fonctions récursives
Une fonction récursive est une fonction qui s’appelle elle-même. Ce
mécanisme permet de résoudre certains problèmes plus facilement.
Cependant, il est important de définir un critère d’arrêt pour ces
fonctions. Chaque fonction récursive dispose d’un cas de base. Par
exemple :
1 def factorielle(n): 1 def factorielle(n):
2 f = 1 2 if n <= 1:
3 i = 1 3 return 1
4 while i <= n: 4 else:
5 f = f * i 5 return n * factorielle(n - 1)
6 i = i + 1
7 return f
Génie informatique et genie logiciel Benjamin De Leener 21 A2025
Chapitre 7 - Fonctions
Exercice
1 def f(a, b):
2 # a et b sont des entiers naturels non nuls
3 if b==1 : return a
4 return a + f(a, b-1)
5 print(f(3, 5))
1. Quel est le résultat affiché par ce programme ?
2. Quel est le cas de base dans cette fonction récursive ?
3. Qu’est ce qui garantit dans les appels récursifs que le programme
finira par s’arrêter ?
4. Que retourne f(a, b) (a et b étant des entiers naturels non nuls) ?
Génie informatique et genie logiciel Benjamin De Leener 22 A2025
Chapitre 7 - Fonctions
Fonctions lambda
Une fonction lambda est une fonction anonyme et n’ayant pas de nom.
Il n’est pas nécessaire de la définir avec l’instruction « def ». Elle
s’exprime comme ceci:
lambda arguments: expression
Les fonctions lambda servent à simplifier la notation de certaines
fonctions simples, ou à intégrer certains comportements complexes
directement dans l’évaluation d’une expression.
1 def f(x): 1 (lambda x, y, z: x + y + z)(1, 2, 3)
2 return x*2 2 lambda first, last: first.title() + " "
+ last.title()
3 # est équivalent à
4 g = lambda x: x*2
5 multi = g(5)
Génie informatique et genie logiciel Benjamin De Leener 23 A2025
Chapitre 7 - Fonctions
Fonctions lambda – d’autres exemples
1 # Simplification de calcul de résultats
2 nb = 2
3 print(f"{nb} au carré est égale à {(lambda x: x ** 2)(nb)}")
4
5 # Tri d'une liste suivant des règles spécifiques
6 noms = ["B De Leener", "J Cohen", "M Guy", "K Lapierre"]
7 print(sorted(noms)) # Tri simple sur les chaînes de caractère
8 sorted_noms = sorted(noms, key=lambda x: x[2:])
9 print(sorted_noms) # Tri avec les noms de famille
10
11 sorted(range(-5, 6), key=lambda x: x ** 2)
Génie informatique et genie logiciel Benjamin De Leener 24 A2025
Chapitre 7 - Fonctions
Fonctions imbriquées
Les fonctions imbriquées, parfois appelées fonctions internes, sont des
fonctions définies à l’intérieur d’autres fonctions.
1 def fonction_externe(qui):
2 def fonction_interne():
3 print(f"Hello, {qui}!")
4 fonction_interne()
Ces fonctions permettent d’encapsuler et de cacher le fonctionnement
d’une fonction, de définir des fonctions facilitantes, d’implémenter un
mécanisme de fermeture lexicale et de créer des décorateurs.
Génie informatique et genie logiciel Benjamin De Leener 25 A2025
Chapitre 7 - Fonctions
Fermeture lexicale : exemple
La fermeture lexicale permet de préserver de l’état de certaines
variables au travers de plusieurs appels.
1 def generer_puissance(exposant):
2 def puissance(base):
3 return base ** exposant
4 return puissance
5 puissance_deux = generer_puissance(2)
6 puissance_trois = generer_puissance(3)
7 print(puissance_deux(4), puissance_deux(8))
8 print(puissance_trois(4), puissance_trois(8))
Génie informatique et genie logiciel Benjamin De Leener 26 A2025
Chapitre 7 - Fonctions
Décorateurs
Un décorateur est un mécanisme de haut-niveau en Python profitant du
des fonctions imbriquées et de la fermeture lexicale pour ajouter un
comportement à une fonction. Un décorateur est donc une fonction
qui prend une fonction en paramètre et retourne une autre fonction,
généralement interne, afin d’ajouter un comportement à la fonction
passée en paramètre.
1 def affiche_appel(fonction):
2 def _affiche_appel():
3 print("La fonction commence...")
4 fonction()
5 print("Elle est finie!")
6 return _affiche_appel
Génie informatique et genie logiciel Benjamin De Leener 27 A2025
Chapitre 7 - Fonctions
Décorateurs
Pour utiliser le décorateur, il suffit d’utiliser le nom du décorateur avec
le symbole @
1 @affiche_appel 1 # Ce code ne fonctionne pas
2 def bonjour(): 2 # car le décorateur ne transmet
3 print("Hello!") 3 # pas les arguments de la fonction
4 bonjour() 4 @affiche_appel
5 def addition(a, b):
6 return a + b
7 addition(1, 2)
Génie informatique et genie logiciel Benjamin De Leener 28 A2025
Chapitre 7 - Fonctions
Décorateurs
Les décorateurs sont très utiles pour implémenter des comportements
de vérification de données, d’affichage ou de sauvegarde
d’information ou encore pour mesurer la performance des fonctions.
Quelques exemples :
1 def debug(func):
2 def _debug(*args, **kwargs):
3 result = func(*args, **kwargs)
4 print(f"{func.__name__}(args: {args}, \
5 kwargs: {kwargs}) -> {result}")
6 return result
7 return _debug
Génie informatique et genie logiciel Benjamin De Leener 29 A2025
Chapitre 7 - Fonctions
Décorateurs - exemples
1 import time
2 def timeit(func):
3 def _time(*args, **kwargs):
4 t1 = time.time()
5 result = func(*args, **kwargs)
6 t2 = time.time()
7 print(f"Temps utilisé = {t2 - t1} secondes.")
8 return result
9 return _time
Génie informatique et genie logiciel Benjamin De Leener 30 A2025
Chapitre 7 - Fonctions
Exercices – suite
À partir de la fonction suivante, transformer le code en utilisant un
mécanisme de fonctions imbriquées ou de décorateurs afin
d’attraper les erreurs potentielles et d’afficher un message d’erreur
plutôt que de laisse le programme s’arrêter.
1 def division(a, b):
2 return a / b
Exemples d’erreurs :
• Division par zéro
• Mauvais types de données
Génie informatique et genie logiciel Benjamin De Leener 31 A2025
Chapitre 7 - Fonctions
Fonctions génératrices
Une fonction génératrice est une méthode permettant de fournir une
séquence d’éléments lorsque nécessaire (programmation par
nécessité). Un générateur ne stocke pas la séquence en mémoire, il
l’a construit à mesure que le programme avance.
Afin d’adopter le comportement d’un générateur, la fonction doit utiliser
l’instruction « yield » à la place de « return ».
1 def sequence_infinie(): 1 for i in sequence_infinie():
2 chiffre = 0 2 print(i, end=" ")
3 while True: 3 # ou
4 yield chiffre 4 gen = sequence_infinie()
5 chiffre += 1 5 print(next(gen))
6 print(next(gen))
Génie informatique et genie logiciel Benjamin De Leener 32 A2025
Chapitre 7 - Fonctions
Portée des variables – globales et locales
En introduisant le concept de fonction et de découpage du code en sous-
parties, nous introduisons également le concept de portée des variables :
« Quand et comment les variables sont-elles accessibles? »
Les variables sont définies et accessibles dans un espace défini du code.
Dans l’exemple ci-dessous, la variable « a » représente présente deux
valeurs distinctes, dépendamment de l’emplacement du programme.
1 a = 10 # variable globale En effet, la variable globale (le
premier « a ») demeure inchangé
2 def f():
car les variables locales sont
3 a = 20 # variable locale utilisées en priorité si elles existent.
4 print(a)
Notez que les variables créées
5 f() # --> 20 dans une fonction sont détruites à
6 print(a) # --> 10 sa sortie.
Génie informatique et genie logiciel Benjamin De Leener 33 A2025
Chapitre 7 - Fonctions
Portée des variables – globales et locales
Afin qu’une fonction puisse utiliser une variable dans plusieurs sous-parties
d’un programme, on peut définir cette variable comme étant globale.
1 a = 10
2 def f():
On peut également utiliser les
3 global a
fonctions locals() et globals()
4 a = 20 afin d’afficher la portée de chaque
5 print(a)
variable.
6 f() # --> 20
7 print(a) # --> 20
Génie informatique et genie logiciel Benjamin De Leener 34 A2025
Chapitre 7 - Fonctions
Espace de noms
De manière plus générale, les noms des variables et des fonctions sont
contenus dans des lexiques, selon une méthodologie d’espaces de
noms. Ces espaces définissent la portée de variables dans le
programme. Python définit 4 types d’espaces de noms :
1. Interne (Built-In) : contient tous les noms définis par le langage
2. Global : noms définis au niveau du programme principal.
3. Encapsulant (Enclosing) : noms définis dans une fonction qui en
encapsule une autre.
4. Local : noms définis à l’intérieur d’une fonction.
La recherche des noms de variables est réalisée selon la règle LEGB.
L’interpréteur regarde d’abord si la variable est définie dans l’espace
local (L). Si oui, il l’utilise, sinon, il regarde dans l’espace encapsulant
(E), s’il existe, puis l’espace global (G), puis interne (B).
Génie informatique et genie logiciel Benjamin De Leener 35 A2025
Chapitre 7 - Fonctions
Espace de noms - exemple
Quand le programme appelle la fonction
1 a = 'global'
f(), Python crée un espace de nom pour f().
2 def f(): Lorsque la fonction g() est appelée, Python
crée un autre espace de nom dédié à g().
3 a = 'encapsulant'
4 b = 'autre' L’espace de nom créé pour f() est l’espace
encapsulant.
5 def g():
L’espace de nom créé pour g() est l’espace
6 b = 'local' local.
7 print(a, b)
Ces espaces existent jusqu’à la fin de leur
8 g() fonction respective.
Les fonctions globales() et locales() permettent d’afficher les dictionnaires
contenant tous les noms de variables dans leurs espaces de noms respectifs.
Les déclarations « global » et « nonlocal » permettent de modifier une variable
globale sans initialiser une variable locale.
Génie informatique et genie logiciel Benjamin De Leener 36 A2025
Chapitre 7 - Fonctions
Introduction aux modules
La programmation modulaire cherche à fractionner un programme en
un sous-ensemble de tâches simples. Ces tâches peuvent être
répétables, et donc définies sous la forme d’une fonction, et
génériques, de sorte à pouvoir ajuster certains paramètres de ces
fonctions. Les modules cherchent à assembler les fonctions portant
sur une même thématique.
1 # fichier module.py 1 # fichier main.py
2 var = 'Bonjour' 2 import module
3 3 print(module.var)
4 def fonction(argument): 4 module.fonction('INF1007')
5 print(f'arg = {argument}')
Génie informatique et genie logiciel Benjamin De Leener 37 A2025
Chapitre 7 - Fonctions
Introduction aux modules
Rendre un programme modulaire a plusieurs avantages :
• Simplicité : en général, un module se concentre sur une petite
portion du problème, rendant sa compréhension plus aisée.
• Maintien du code : Les modules sont développés de sorte à définir
de façon claire leurs limites, diminuant donc le risque de
modification fréquente d’un module, et facilitant son maintien pour
une équipe.
• Réutilisation : les fonctionnalités qui sont définies dans un module
sont facilement utilisables par un autre programme.
• Portée : les modules définissent leur propre espace de noms.
Génie informatique et genie logiciel Benjamin De Leener 38 A2025
Chapitre 7 - Fonctions
L’instruction import
Il existe plusieurs façons d’importer le contenu d’un module :
• import <module_name>
• import <module_name>[, <module_name> ...]
• import <module_name> as <alt_name>
• from <module_name> import <name(s)>
• from <module_name> import *
• from <module_name> import <name> as <alt_name>
• from <module_name> import <name> as <alt_name>[, <name> as
<alt_name> …]
Génie informatique et genie logiciel Benjamin De Leener 39 A2025
Chapitre 7 - Fonctions
Exercices – suite
Un programme principal saisit une chaîne d'ADN valide et une
séquence d'ADN valide (valide signifie qu'elles ne sont pas vides et
sont formées exclusivement d'une combinaison arbitraire de "a", "t",
"g" ou "c").
a) Écrire une fonction valide qui renvoie vrai si la saisie est valide, faux
sinon.
b) Écrire une fonction proportion qui reçoit deux arguments, la chaîne
et la séquence et qui retourne la proportion de séquence dans la
chaîne (c'est-à-dire son nombre d'occurrences).
Le programme principal appelle la fonction saisie pour la chaîne et pour la
séquence et affiche le résultat.
Exemple d’affichage : 1 chaîne : attgcaatggtggtacatg
2 séquence : ca
3 Il y a 10.53 % de "ca".
Génie informatique et genie logiciel Benjamin De Leener 40 A2025
