Leçon 1 sur 5
Fonctions, modules et portée des variables
Je sais écrire des fonctions bien spécifiées (paramètres par défaut, valeurs de retour multiples, docstring), organiser un programme en modules et prévoir la portée des variables en Python.
- 1 h 10
- 4 exercices corrigés
- QCM de 5 questions
À la fin de la leçon, vous saurez :
- Écrire des fonctions avec paramètres positionnels, nommés et par défaut
- Documenter et tester une fonction (docstring, assert)
- Expliquer la règle de portée LGB et le passage des arguments par référence d'objet
- Créer et importer un module et y placer un bloc de tests qui ne s'exécute pas à l'importation
- Découper un problème scientifique en fonctions réutilisables
Avant de commencer : Programmation 1 (types, conditions, boucles, premières fonctions, listes).
1Je découvre
Fatoumata, étudiante en L2 de physique à Kankan, a écrit un programme de 300 lignes pour traiter ses mesures de TP : lecture des valeurs, calcul de moyennes, d'écarts-types, conversion d'unités. Tout est dans un seul fichier, sans fonctions. Quand l'enseignant lui demande d'ajouter le calcul d'incertitude, elle doit copier-coller le même bloc à cinq endroits, et une erreur s'introduit dans deux d'entre eux.
Son camarade de mathématiques a, lui, rangé ses calculs dans un fichier stats.py qu'il réutilise dans tous ses TP avec une simple ligne import stats. Une variable modifiée dans une fonction ne perturbe pas le reste de son programme.
Comment structurer un programme avec des fonctions et des modules, et comment Python décide-t-il quelle variable on utilise ?
2Je comprends
1. Rappels et bonnes pratiques sur les fonctions
Une fonction regroupe des instructions sous un nom, reçoit des paramètres et renvoie un résultat avec return.
def moyenne(valeurs):
"""Renvoie la moyenne d'une liste non vide de nombres."""
return sum(valeurs) / len(valeurs)Bonnes pratiques :
- une fonction, une tâche : elle calcule, ou elle affiche, mais évite de faire les deux ;
- un nom explicite (verbe ou nom de grandeur) ;
- une docstring (chaîne entre triples guillemets) qui dit ce que la fonction fait, ses paramètres et ce qu'elle renvoie ;
help(moyenne)l'affiche ; - une fonction qui n'exécute pas de
returnrenvoieNone.
2. Paramètres : positionnels, nommés, par défaut
def convertir(valeur, facteur=1000, arrondi=2):
"""Multiplie valeur par facteur et arrondit."""
return round(valeur * facteur, arrondi)
convertir(1.2345) # 1234.5
convertir(1.2345, 100) # 123.45
convertir(1.2345, arrondi=0) # 1234.0- Les arguments positionnels sont associés aux paramètres dans l'ordre.
- Les arguments nommés (
arrondi=0) peuvent être donnés dans n'importe quel ordre, après les positionnels. - Un paramètre par défaut est facultatif. Piège : ne jamais utiliser une liste comme valeur par défaut (
def f(l=[])), car elle est créée une seule fois et partagée entre les appels ; on écritdef f(l=None)puisif l is None: l = [].
Plusieurs valeurs de retour. Une fonction peut renvoyer un tuple, que l'on « dépaquette » :
def min_max(valeurs):
return min(valeurs), max(valeurs)
bas, haut = min_max([12.1, 9.8, 15.3]) # bas = 9.8, haut = 15.33. La portée des variables
La portée d'une variable est la partie du programme où son nom est visible. Pour trouver un nom, Python cherche dans l'ordre (règle simplifiée LGB) :
- Local : les variables créées dans la fonction (y compris les paramètres) ;
- Global : les variables définies au niveau du module ;
- Built-in : les noms prédéfinis (
len,print,sum…).
(Avec des fonctions imbriquées, il existe un niveau intermédiaire, d'où le nom complet LEGB.)
taux = 0.18 # variable globale
def prix_ttc(ht):
tva = ht * taux # tva est locale, taux est lue dans le global
return ht + tva
print(prix_ttc(1000)) # 1180.0
print(tva) # NameError : tva n'existe pas hors de la fonctionAffectation = variable locale. Si une fonction affecte un nom, ce nom est local dans toute la fonction :
compteur = 0
def incrementer():
compteur = compteur + 1 # UnboundLocalErrorOn pourrait écrire global compteur, mais c'est déconseillé : il vaut mieux passer la valeur en paramètre et renvoyer le résultat (compteur = incrementer(compteur)).
4. Passage des arguments et mutabilité
En Python, on passe aux fonctions des références vers des objets. Conséquence :
- un objet non modifiable (nombre, chaîne, tuple) ne peut pas être changé par la fonction ;
- un objet modifiable (liste, dictionnaire) peut être modifié en place par la fonction, et la modification est visible à l'extérieur.
def ajouter_zero(l):
l.append(0)
notes = [12, 15]
ajouter_zero(notes)
print(notes) # [12, 15, 0]Si l'on ne veut pas modifier l'original, on travaille sur une copie (l2 = list(l) ou l[:]). Une bonne fonction documente si elle modifie ses arguments.
5. Les modules
Un module est un fichier .py qui contient des fonctions, des constantes, des classes. On l'utilise avec import :
# fichier stats.py
"""Petites fonctions de statistique pour les TP."""
from math import sqrt
def moyenne(v):
return sum(v) / len(v)
def ecart_type(v):
m = moyenne(v)
return sqrt(sum((x - m) ** 2 for x in v) / len(v))
if __name__ == "__main__":
# tests exécutés seulement si on lance stats.py directement
assert moyenne([2, 4]) == 3
assert ecart_type([5, 5, 5]) == 0
print("tests OK")# fichier tp3.py, dans le même dossier
import stats
mesures = [9.79, 9.83, 9.81]
print(stats.moyenne(mesures))Formes d'importation : import math (on écrit math.sqrt), from math import sqrt (on écrit sqrt), import numpy as np (alias). On évite from module import *, qui mélange les noms et crée des conflits.
La variable spéciale __name__ vaut "__main__" quand le fichier est exécuté directement, et le nom du module quand il est importé : le bloc if __name__ == "__main__": permet donc de placer des tests ou un programme principal qui ne s'exécutent pas à l'importation.
Les bibliothèques standard (math, random, statistics, csv, os…) sont des modules fournis avec Python ; d'autres (numpy, matplotlib) s'installent avec pip (leçon 5).
6. Tester une fonction
Avant d'utiliser une fonction, on la vérifie sur des cas dont on connaît le résultat, avec assert :
assert convertir(2, 10) == 20
assert min_max([3, 1, 2]) == (1, 3)Pour les réels, on compare avec une tolérance, car les calculs flottants sont approchés : assert abs(moyenne([0.1, 0.2]) - 0.15) < 1e-12.
3Je retiens
Je retiens
Une fonction bien écrite a une seule tâche, un nom explicite, une docstring et des tests.
Paramètres positionnels, nommés et par défaut ; jamais de liste comme valeur par défaut.
Un nom affecté dans une fonction est local ; Python cherche les noms dans l'ordre local, global, prédéfini.
Préférer les paramètres et return à l'instruction global.
Une fonction peut modifier en place une liste ou un dictionnaire reçu : copier si nécessaire.
Un module est un fichier .py que l'on importe ; ses tests vont dans un bloc qui ne s'exécute que si l'on lance le fichier directement.
4Erreurs fréquentes
- Confondre print et return : une fonction qui affiche sans renvoyer donne None au programme appelant.
- Utiliser une variable locale hors de sa fonction : NameError.
- Modifier une variable globale dans une fonction sans le vouloir, ou croire qu'on l'a modifiée : passer en paramètre et renvoyer.
- Écrire def f(l=[]) : la liste est partagée entre les appels.
- Nommer son fichier math.py ou random.py : il masque le module standard du même nom.
5Je m’exerce
1Exercice 1
(Questions de cours) a) Que renvoie une fonction sans return ? b) Énoncez l'ordre de recherche des noms (LGB). c) À quoi sert if __name__ == "__main__": ?
Voir le corrigéCacher le corrigé
a) La valeur None. b) Python cherche d'abord dans la portée locale de la fonction, puis dans la portée globale du module, enfin parmi les noms prédéfinis (built-in). c) Ce bloc ne s'exécute que lorsque le fichier est lancé directement ; quand le fichier est importé comme module, il est ignoré. On y place des tests ou le programme principal.
2Exercice 2
Qu'affiche ce programme ? Justifiez chaque ligne.
x = 10
def f(x):
x = x + 1
return x
def g(l):
l.append(x)
a = f(x)
b = [1]
g(b)
print(x, a, b)Voir le corrigéCacher le corrigé
Affichage : 10 11 [1, 10]. f(x) reçoit 10 dans son paramètre local x, calcule 11 et le renvoie : a = 11, le x global reste 10. g(b) modifie en place la liste b en y ajoutant la valeur du x global (10), d'où [1, 10].
3Exercice 3
Écrivez une fonction incertitude(valeurs, k=2) qui renvoie le couple (moyenne, k × écart-type / racine de n), où n est le nombre de valeurs. Testez-la sur [10.0, 10.0, 10.0] et donnez le résultat attendu.
Voir le corrigéCacher le corrigé
from math import sqrt
def incertitude(valeurs, k=2):
"""Renvoie (moyenne, incertitude élargie k*s/racine(n))."""
n = len(valeurs)
m = sum(valeurs) / n
s = sqrt(sum((x - m) ** 2 for x in valeurs) / n)
return m, k * s / sqrt(n)
assert incertitude([10.0, 10.0, 10.0]) == (10.0, 0.0)Pour trois valeurs égales, la moyenne vaut 10.0 et l'écart-type 0, donc le résultat attendu est (10.0, 0.0). (On a pris ici l'écart-type avec division par n ; en TP, on utilise souvent n − 1 : il faut le préciser dans la docstring.)
4Exercice 4
(Type examen) Un groupement de producteurs de Kindia vend des mangues. a) Écrivez un module ventes.py contenant : recette(quantites, prix) qui renvoie la somme des produits quantité × prix pour deux listes de même longueur ; meilleur_jour(recettes) qui renvoie l'indice du jour de plus forte recette ; et un bloc de tests. b) Écrivez un programme rapport.py qui importe ce module et affiche la recette de chaque jour et le meilleur jour pour les données fictives : jour 0 : quantités [10, 5] et prix [2000, 3000] ; jour 1 : quantités [8, 9] et prix [2000, 3000]. c) Donnez l'affichage attendu.
Voir le corrigéCacher le corrigé
# ventes.py
def recette(quantites, prix):
"""Somme des quantite*prix ; listes de même longueur."""
total = 0
for q, p in zip(quantites, prix):
total += q * p
return total
def meilleur_jour(recettes):
"""Indice de la plus forte recette (le premier en cas d'égalité)."""
meilleur = 0
for i in range(1, len(recettes)):
if recettes[i] > recettes[meilleur]:
meilleur = i
return meilleur
if __name__ == "__main__":
assert recette([1, 2], [100, 10]) == 120
assert meilleur_jour([5, 9, 9]) == 1
print("tests OK")# rapport.py
import ventes
jours = [([10, 5], [2000, 3000]), ([8, 9], [2000, 3000])]
recettes = []
for i, (q, p) in enumerate(jours):
r = ventes.recette(q, p)
recettes.append(r)
print("Jour", i, ":", r, "GNF")
print("Meilleur jour :", ventes.meilleur_jour(recettes))Calculs : jour 0 : 10 × 2000 + 5 × 3000 = 20 000 + 15 000 = 35 000 ; jour 1 : 8 × 2000 + 9 × 3000 = 16 000 + 27 000 = 43 000. Affichage :
Jour 0 : 35000 GNF
Jour 1 : 43000 GNF
Meilleur jour : 1Le message « tests OK » ne s'affiche pas, car ventes.py est importé et non exécuté directement.
Cherchez d’abord seul, sur votre cahier, puis ouvrez le corrigé pour comparer.
6Je vérifie
Choisissez une réponse pour chaque question : la correction s’affiche aussitôt.
Karamö, votre enseignant
Il a lu cette leçon. Posez-lui votre question : il vous répond ici.
Connectez-vous pour poser vos questions à Karamö.
Avec un compte Kharandi gratuit, vous cochez les leçons terminées et vous suivez votre progression, cours par cours.