⚙️ Création de fonctions
- Fonction
- Paramètres
- Retour
- Portée
- DRY
- Commentaires
- Modules
- Pile
- Trace
- Activités
- *Fct en param.*
- *Récursivité*
- Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique.
- Nous avons déjà utilisé des fonctions existantes, comme
print(),max()ouround(). Dans cette rencontre, nous allons créer les nôtres. - Une fonction peut prendre des paramètres (des valeurs d'entrée) et retourner une valeur de sortie.
- Les fonctions permettent de structurer le code, de réduire la répétition et de faciliter la maintenance du code.
Voici une fonction très simple :
def double(x):
return 2 * x
- Première ligne :
def double(x):defest un mot-clé qui indique que nous sommes en train de définir une fonction.doubleest le nom que nous avons décidé de donner à notre fonction.- 💡 Bien nommer une fonction : utilisez un verbe qui décrit ce qu'elle fait, écrit en
snake_case(minuscules et_), par exemplecalculer_moyenneouafficher_rapport.
- 💡 Bien nommer une fonction : utilisez un verbe qui décrit ce qu'elle fait, écrit en
- Les parenthèses
()indiquent que c'est une fonction, et peuvent contenir des paramètres (ici un seul :x). xest un paramètre que nous avons décidé de nommerxet qui prend la valeur transmise lors de l'appel de la fonction.- Le
:à la fin de la ligne indique que le corps (le code) de la fonction commence à la ligne suivante.
- Toutes les lignes suivantes (ici seulement une ligne :
return 2 * x)- Elles forment le corps de la fonction : elles sont indentées (décalées vers la droite) avec la touche
TAB.- ⚠️ En Python, c'est l'indentation qui indique quelles lignes font partie de la fonction. Voir l'explication détaillée plus bas.
returnest un mot-clé qui indique quelle valeur la fonction renvoie, ici le résultat de l'évaluation de l'expression2 * x.
- Elles forment le corps de la fonction : elles sont indentées (décalées vers la droite) avec la touche
👉 Définir une fonction, ce n'est pas l'exécuter.
Quand Python lit ces deux lignes, il ne calcule rien : il retient simplement que la fonction double existe et ce qu'elle doit faire.
C'est comme écrire une recette de cuisine : la recette est prête, mais le plat n'est pas encore préparé.
Le code de la fonction ne sera exécuté que lorsque nous l'appellerons, ce que nous verrons juste après.
Une fois qu'une fonction est ainsi définie, on peut l'appeler, en lui transmettant une valeur pour x :
def double(x):
return 2 * x
double(5) # Appel de la fonction en lui passant la valeur 5
Pour appeler une fonction, on écrit son nom suivi de parenthèses contenant les valeurs à transmettre aux paramètres.
Lorsqu'une fonction est appelée, le code à l'intérieur de la fonction est exécuté, et la valeur spécifiée par return est renvoyée à l'endroit où la fonction a été appelée.
Ici, la fonction double est appelée en lui passant la valeur 5, ce qui signifie que x reçoit la valeur 5 à l'intérieur de la fonction.
La fonction calcule 2 * 5 et retourne 10.
Cependant, ici, la valeur retournée par la fonction est perdue : la fonction fonctionne, mais le résultat disparaît si on ne le stocke pas.
Il est plus utile de stocker cette valeur dans une variable. Remplaçons la ligne 4 par :
resultat = double(5) # Appel de la fonction et stockage de la valeur retournée dans la variable 'resultat'
print(resultat) # Affiche 10
👉 Une fonction qui fait un return renvoie une valeur, elle ne l'affiche pas. Pour la voir, il faut l'afficher avec print().
Si vous confondez print() et return, lisez l'aide-mémoire return vs print.
Une fois une fonction définie, elle peut être appelée autant de fois que souhaité dans le code, en utilisant son nom suivi de parenthèses et des valeurs nécessaires :
resultat1 = double(5) # Appel de la fonction avec la valeur 5
resultat2 = double(10) # Appel de la fonction avec la valeur 10
resultat3 = double(2) # Appel de la fonction avec la valeur 2
print(resultat1) # Affiche 10
print(resultat2) # Affiche 20
print(resultat3) # Affiche 4
Pour passer des valeurs à une fonction, il est aussi possible d'utiliser des variables :
a = 5
resultat = double(a) # Appel de la fonction en lui passant la valeur contenue dans la variable 'a'
print(resultat) # Affiche 10
Ici, la variable a contient la valeur 5, et lorsque nous appelons double(a), la fonction reçoit la valeur de a (c'est-à-dire 5) et retourne 10.
👉 La variable s'appelle a et le paramètre s'appelle x : ce n'est pas un problème! C'est la valeur qui est transmise, pas le nom de la variable.
Erreur 1 : appeler la fonction avant de la définir
resultat = double(5)
def double(x):
return 2 * x
Dans la console, Python affiche ce message d'erreur :
Traceback (most recent call last):
File "...\r03_fonction.py", line 1, in <module>
resultat = double(5)
^^^^^^
NameError: name 'double' is not defined
🔎 Lisez d'abord la dernière ligne : elle donne le type d'erreur (NameError) et sa cause. La ligne line 1 indique où chercher.
Python lit le code de haut en bas : à la ligne 1, il ne connaît pas encore double.
👉 Écrivez toujours vos fonctions en haut du fichier, avant le code qui les appelle.
Erreur 2 : oublier les parenthèses
def double(x):
return 2 * x
print(double) # Affiche <function double at 0x000001D540C71440>
Sans parenthèses, la fonction n'est pas appelée : Python affiche la fonction elle-même (son adresse en mémoire), et non son résultat.
👉 Pour l'appeler, il faut les parenthèses et la valeur : print(double(5)).
En Python, l'indentation est le décalage vers la droite que l'on met au début d'une ligne.
Ce décalage n'est pas décoratif : il indique à Python quelles lignes forment un bloc de code.
L'indentation peut changer complètement le sens d'un programme!
Un bloc de code, c'est par exemple :
- 🔧 le corps d'une fonction (ce que nous voyons dans cette rencontre)
- 🔀 le contenu d'une structure conditionnelle (plus tard dans le cours)
- 🔁 le contenu d'une boucle (plus tard dans le cours)
Comment ça fonctionne :
- Une ligne qui se termine par
:annonce qu'un bloc va suivre (ex :def double(x):). - Les lignes du bloc sont décalées vers la droite par rapport à cette ligne.
- Le bloc se termine à la première ligne qui revient au niveau de la ligne qui contient le
:.
def double(x):
y = 2 * x # Indentée : fait partie de la fonction
return y # Indentée : fait partie de la fonction
z = 3 # Non indentée : le bloc est terminé, cette ligne est hors de la fonction
- Les lignes 2 et 3 sont indentées : elles forment le corps de la fonction
double. - La ligne 4 revient au niveau de la ligne
def: elle est en dehors de la fonction.
Règle d'or : toutes les lignes d'un même bloc doivent avoir exactement la même indentation.
- ✅
TAB: ajoute une indentation (décale la ligne vers la droite). - ✅
Maj + TAB: retire une indentation (décale la ligne vers la gauche). - ❌ Ne jamais utiliser la barre d'espace pour indenter!
Si vous sélectionnez plusieurs lignes, TAB et Maj + TAB les décalent toutes en même temps.
Pourquoi ✅ TAB et jamais la ❌ barre d'espace?
TABcrée toujours le même décalage : l'indentation est uniforme.- Avec la barre d'espace, il est très facile d'oublier un espace ou d'en ajouter un de trop, et l'erreur est presque invisible à l'œil.
- Un seul espace de trop suffit pour provoquer une
IndentationError.
👉 Voir aussi la section sur la tabulation de l'aide-mémoire ⌨️ Symboles au clavier.
Une indentation incorrecte empêche le programme de s'exécuter. Python affiche alors une erreur IndentationError.
Dans PyCharm, la ligne fautive est généralement soulignée en rouge avant même l'exécution, et l'erreur s'affiche dans la console si on lance le programme.
Cas 1 : on oublie d'indenter le corps de la fonction
def double(x):
return 2 * x # IndentationError: expected an indented block after function definition on line 1
Cas 2 : une ligne est plus indentée que les autres du même bloc
def double(x):
y = 2 * x
return y # IndentationError: unexpected indent
Pour corriger : donnez la même indentation à toutes les lignes du bloc, en utilisant TAB.
def double(x):
y = 2 * x
return y
passUne fonction doit contenir au moins une instruction indentée. Mais parfois, on veut déclarer une fonction qu'on écrira plus tard, par exemple pour construire un programme étape par étape.
On utilise alors pass : une instruction qui ne fait rien, mais qui sert d'espace réservé.
def calculer_moyenne(notes):
pass # À écrire plus tard
print("Le reste du programme fonctionne déjà!")
Sans pass, Python afficherait une erreur : IndentationError: expected an indented block after function definition on line 1.
👉 N'oubliez pas de remplacer le pass par le vrai code de la fonction une fois prêt!
Les explications de cette section étaient-elles claires ?
Les paramètres sont les valeurs d'entrée d'une fonction.
Les fonctions peuvent prendre un nombre variable de paramètres, y compris aucun paramètre du tout.
Voici 3 fonctions avec différents nombres de paramètres :
def nombre_pi():
return 3.14159
def carre(x):
return x * x
def puissance(base, exposant):
return base ** exposant
nombre_piest une fonction sans paramètre qui retourne la valeur de π.carreest une fonction avec un seul paramètrexqui retourne le carré dex.puissanceest une fonction avec deux paramètres,baseetexposant, qui retourne la base élevée à la puissance de l'exposant.
👉 Les paramètres sont séparés par des virgules.
👉 À l'intérieur de la fonction, un paramètre s'utilise comme une variable, qui n'existe que dans la fonction (voir l'onglet Portée).
Lorsqu'on appelle une fonction, il faut lui passer le même nombre de valeurs que de paramètres définis :
pi = nombre_pi() # Appel sans argument : les parenthèses restent obligatoires, même vides
carre_de_5 = carre(5) # Appel avec un argument : x reçoit 5
Lorsque la fonction a plusieurs paramètres, l'ordre des valeurs transmises doit correspondre à l'ordre des paramètres définis dans la fonction :
resultat1 = puissance(2, 3) # base reçoit 2 et exposant reçoit 3 (retourne 8)
resultat2 = puissance(3, 2) # base reçoit 3 et exposant reçoit 2 (retourne 9)
⚠️ Python ne signale aucune erreur si vous inversez l'ordre : le programme s'exécute, mais le résultat est faux.
C'est le pire type de bogue, car on ne le voit pas!
Ces deux mots sont souvent confondus :
- le paramètre est le nom écrit entre les parenthèses du
def(ex :xdansdef carre(x):); - l'argument est la valeur donnée lors de l'appel (ex :
5danscarre(5)).
Les messages d'erreur de Python utilisent le mot argument : c'est utile de le reconnaître!
Si on ne donne pas autant d'arguments qu'il y a de paramètres, Python affiche une erreur TypeError.
Il manque un argument :
def puissance(base, exposant):
return base ** exposant
resultat = puissance(2)
Traceback (most recent call last):
File "...\r03_parametres.py", line 4, in <module>
resultat = puissance(2)
TypeError: puissance() missing 1 required positional argument: 'exposant'
Il y a un argument de trop : avec resultat = puissance(2, 3, 4), la dernière ligne devient :
TypeError: puissance() takes 2 positional arguments but 3 were given
👉 La dernière ligne indique le nom de la fonction et ce qui ne va pas : comparez l'appel avec la ligne def.
Il est possible de définir une valeur par défaut pour un paramètre.
Si aucune valeur n'est fournie pour un paramètre lors de l'appel de la fonction, la valeur par défaut sera utilisée.
💡 Vous l'avez déjà utilisé à la rencontre 2 : round(17.8) arrondit à l'entier, alors que round(3.14159, 2) arrondit à 2 décimales. Le 2ᵉ paramètre de round() est facultatif!
def puissance(base, exposant=2):
return base ** exposant
resultat1 = puissance(5) # retourne 25, car exposant prend la valeur par défaut 2
resultat2 = puissance(5, 3) # retourne 125, car exposant prend la valeur 3 fournie lors de l'appel
Comme dans cet exemple, une fonction peut posséder à la fois des paramètres avec des valeurs par défaut et des paramètres sans valeurs par défaut.
Les paramètres obligatoires (ceux qui n'ont pas de valeur par défaut) doivent toujours être placés avant les paramètres facultatifs (ceux qui ont une valeur par défaut).
Sinon, Python affiche une erreur : SyntaxError: parameter without a default follows parameter with a default.
Cette règle permet à l'utilisateur de la fonction de fournir les valeurs pour les paramètres essentiels en priorité, tout en ayant la liberté de spécifier uniquement les options supplémentaires s'il le souhaite.
def prix_total(prix, quantite=1, taxe=1.15):
return prix * quantite * taxe
# Exemples d'appels
total1 = prix_total(10) # 10 * 1 * 1.15 = 11.5
total2 = prix_total(10, 3) # 10 * 3 * 1.15 = 34.5
total3 = prix_total(10, 3, 1.2) # 10 * 3 * 1.2 = 36.0
total4 = prix_total(10, taxe=1.2) # 10 * 1 * 1.2 = 12.0
La dernière ligne de cet exemple est particulièrement intéressante à analyser :
- on fournit un prix (
10) ; - on ne fournit aucune valeur pour la quantité, la valeur par défaut sera utilisée (
1) ; - malgré l'absence de valeur pour la quantité, on peut fournir une valeur pour la taxe, en utilisant le nom du paramètre (
taxe=1.2) : c'est un argument nommé.
Avec des arguments nommés, l'ordre n'a plus d'importance : puissance(exposant=3, base=2) retourne 8.
Un paramètre peut être de n'importe quel type y compris une liste.
À l'intérieur de la fonction, on accède aux éléments de la liste via leur index, comme on l'a vu à la rencontre précédente.
Voici une fonction qui reçoit une liste de 3 notes et retourne leur moyenne :
def calculer_moyenne(notes):
"""
Calcule la moyenne de 3 notes.
Paramètre :
notes (list) : Une liste contenant 3 notes numériques.
Retourne :
float : La moyenne des 3 notes.
"""
return (notes[0] + notes[1] + notes[2]) / 3
notes_alice = [14, 17, 12]
notes_bob = [9, 11, 15]
moyenne_alice = calculer_moyenne(notes_alice)
moyenne_bob = calculer_moyenne(notes_bob)
print(f"Moyenne d'Alice : {round(moyenne_alice, 2)}")
print(f"Moyenne de Bob : {round(moyenne_bob, 2)}")
👉 On passe la liste entière en un seul paramètre. À l'intérieur de la fonction, notes[0], notes[1] et notes[2] donnent accès à chacune des valeurs. Appeler la fonction avec des listes différentes produit des résultats différents sans réécrire la logique.
Les explications de cette section étaient-elles claires ?
returnLa valeur retournée est la sortie de la fonction.
Une fonction peut retourner plusieurs valeurs, séparées par des virgules :
def diviser(a, b):
quotient = a // b
reste = a % b
return quotient, reste
q, r = diviser(10, 3) # q reçoit 3 et r reçoit 1
Dans cet exemple, la fonction diviser retourne à la fois le quotient entier (//) et le reste (%) de la division.
Ces valeurs sont ensuite assignées à deux variables distinctes (q et r), séparées par une virgule lors de l'appel de la fonction.
👉 Il faut autant de variables à gauche du = que de valeurs retournées, et dans le même ordre : la 1ʳᵉ variable reçoit la 1ʳᵉ valeur, la 2ᵉ reçoit la 2ᵉ.
return, on revient à l'appelQuand Python rencontre un return, il quitte la fonction et revient à la ligne qui l'a appelée, en y apportant la valeur retournée.
👉 Vous le verrez dans vos traces : dans l'exemple de l'onglet Trace, après chaque appel de carre, l'exécution revient à la ligne 7 (total = carre(a) + carre(b)).
L'exécution de la fonction s'arrête dès qu'une instruction return est rencontrée : le code placé après n'est jamais exécuté.
def double(x):
return 2 * x
print("Ce message ne s'affichera jamais!") # Jamais exécuté
PyCharm grise d'ailleurs ce code et affiche l'avertissement This code is unreachable (« ce code est inaccessible »).
Pour cette raison, l'instruction return est généralement placée à la toute fin d'une fonction.
Cependant, une fonction peut comporter plusieurs instructions return à différents endroits du code, notamment dans des conditions différentes.
Nous verrons les conditions plus tard, mais voici tout de même un exemple simple :
def plus_grand(a, b):
if a > b:
return a
else:
return b
returnUne fonction peut ne pas avoir d'instruction return.
Dans ce cas, elle retourne automatiquement la valeur None.
Par exemple, la fonction ci-dessous affiche simplement une salutation à la console sur 2 lignes :
def salutation(nom, age):
print("Bonjour")
print(f"Je m'appelle {nom}, j'ai {age} ans")
C'est pareil comme si return None était ajouté à la fin de la fonction :
def salutation(nom, age):
print("Bonjour")
print(f"Je m'appelle {nom}, j'ai {age} ans")
return None
Par exemple, avec le code ci-dessous :
resultat = salutation("Gustave", 32) # Affiche la salutation, puis stocke `None` dans `resultat`
print(resultat) # Affiche la valeur de `resultat`, qui est `None`
print(salutation("Sciel", 32)) # Affiche la salutation, puis affiche la valeur de retour `None`
La console affiche :
Bonjour
Je m'appelle Gustave, j'ai 32 ans
None
Bonjour
Je m'appelle Sciel, j'ai 32 ans
None
Pour cette raison, n'affichez jamais le résultat d'une fonction qui ne retourne rien!
Cela affichera toujours None, ce qui n'a aucun sens.
# bonne utilisation :
salutation("Gustave", 32) # Affiche la salutation
# mauvaise utilisation :
print(salutation("Gustave", 32)) # Affiche la salutation, puis `None`
Une valeur retournée peut être réutilisée : dans un calcul, dans une variable, dans un autre appel de fonction…
✅ Avec return
def double(x):
return 2 * x
resultat = double(5) + 1
print(resultat) # Affiche 11
❌ Avec print
def afficher_double(x):
print(2 * x)
resultat = afficher_double(5) + 1
print(resultat)
La version avec print affiche 10, puis plante : la fonction retourne None, et on ne peut pas additionner None et 1.
10
Traceback (most recent call last):
File "...\r03_retour.py", line 4, in <module>
resultat = afficher_double(5) + 1
~~~~~~~~~~~~~~~~~~~^~~
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
🔎 Lisez la dernière ligne : NoneType est le type de None. Quand vous voyez NoneType dans une erreur, demandez-vous : « Ai-je oublié un return? »
On peut aussi définir une fonction qui construit et retourne une chaîne de caractères, sans jamais afficher quoi que ce soit à l'écran :
def salutation(nom, age):
return f"Bonjour\nJe m'appelle {nom}, j'ai {age} ans."
# Stocke la chaîne de caractères retournée par la fonction dans la variable 'message'
message = salutation("Gustave", 32)
print(message) # Affiche le message stocké dans la variable 'message'
👉 Dans une chaîne, \n crée un saut de ligne : le message s'affiche donc sur 2 lignes.
👉 Si jamais vous êtes confus.e entre print() et return, lisez l'aide-mémoire return vs print.
Les explications de cette section étaient-elles claires ?
La portée d'une variable, c'est la partie du code où elle existe et où on peut l'utiliser.
En Python, il existe deux types principaux de portée : locale et globale.
Une variable définie en dehors d'une fonction est globale.
Elle peut être utilisée dans tout le programme, y compris à l'intérieur des fonctions,
sauf si une variable du même nom est définie localement (cette situation est montrée plus bas).
⚠️ C'est possible, mais à éviter : voir la bonne pratique à la fin de cet onglet.
x = 10 # Variable globale
def ma_fonction():
print(f"Valeur de x dans la fonction : {x}") # x est accessible ici
ma_fonction()
print(f"Valeur de x en dehors de la fonction : {x}")
Une variable définie à l'intérieur d'une fonction est locale. Elle n'existe que dans cette fonction.
Les param ètres d'une fonction sont des variables locales : ils reçoivent leur valeur au moment de l'appel.
def ma_fonction(z): # z a une portée locale
y = 5 # y est une variable locale
print(f"Valeur de y dans la fonction : {y}")
print(f"Valeur de z dans la fonction : {z}")
ma_fonction(7)
ma_fonction(4)
print(y) # Erreur : y n'existe pas en dehors de la fonction
La ligne 9 provoque une erreur, car y n'existe pas à l'extérieur de la fonction :
Traceback (most recent call last):
File "...\r03_portee.py", line 9, in <module>
print(y)
^
NameError: name 'y' is not defined
print(z) donnerait la même erreur : le paramètre z n'existe pas non plus à l'extérieur de la fonction.
🔁 Les variables locales sont recréées à chaque appel.
Au 1ᵉʳ appel (ligne 6), y et z sont créées, puis disparaissent à la fin de la fonction.
Au 2ᵉ appel (ligne 7), elles sont créées à nouveau : la fonction ne se « souvient » pas de l'appel précédent.
Vous vous demandiez à quoi servent les colonnes contexte et portée de la feuille de trace? Les voici!
- Chaque fonction a son propre groupe de colonnes de variables : c'est sa portée. Les variables globales ont aussi le leur (globale).
- La colonne contexte indique où se trouve l'exécution :
globale, ou le nom de la fonction en cours d'exécution. - À la fin d'un appel, les variables locales de la fonction disparaissent : leurs colonnes se vident.
👉 Voyez-le dans l'exemple de l'onglet Trace : les fonctions affiche_resultat et carre ont chacune leurs colonnes, et le contexte change à chaque appel.
Dès qu'une fonction affecte une valeur à une variable (avec =), cette variable devient locale à la fonction, même si une variable globale porte déjà le même nom.
👉 En pratique : une fonction peut lire une variable globale, mais ne peut pas la modifier.
Cas 1 : la fonction crée une variable locale du même nom
x = 10 # Variable globale
def ma_fonction():
x = 5 # Nouvelle variable locale : la globale n'est pas touchée
print(f"Valeur locale de x : {x}") # Affiche 5
ma_fonction()
print(f"Valeur globale de x : {x}") # Affiche 10
Dans la fonction, la variable locale x cache la variable globale, sans la modifier : après l'appel, la globale vaut toujours 10.
Même nom, mais 2 variables différentes : dans votre trace, prévoyez 2 colonnes!
Cas 2 : la fonction tente de modifier la variable globale
compteur = 0 # Variable globale
def incrementer():
compteur = compteur + 1 # ❌ UnboundLocalError
incrementer()
Ce code plante avec l'erreur suivante :
Traceback (most recent call last):
File "...\r03_compteur.py", line 6, in <module>
incrementer()
~~~~~~~~~~~^^
File "...\r03_compteur.py", line 4, in incrementer
compteur = compteur + 1
^^^^^^^^
UnboundLocalError: cannot access local variable 'compteur' where it is not associated with a value
Remarquez les 2 niveaux : l'erreur survient à la ligne 4, dans incrementer, qui a été appelée à la ligne 6. Vous verrez pourquoi dans l'onglet Pile.
Pourquoi? À cause du = de la ligne 4, compteur est une variable locale dans toute la fonction.
Pour calculer compteur + 1, Python cherche donc la valeur de cette variable locale... qui n'en a encore aucune!
✅ La solution : la fonction reçoit la valeur en paramètre et retourne le résultat.
C'est le programme principal, à l'extérieur de la fonction, qui met à jour la variable globale.
compteur = 0
def incrementer(valeur):
return valeur + 1
compteur = incrementer(compteur) # La variable globale est modifiée ici, hors de la fonction
print(compteur) # Affiche 1
🚫 En cherchant sur le Web ou avec l'IA, vous trouverez peut-être le mot-clé global comme « solution ».
Ne l'utilisez pas dans ce cours : il crée exactement les problèmes décrits ci-dessous. Utilisez plutôt un paramètre et un return.
Ce n'est pas parce qu'une fonction peut lire une variable globale qu'elle doit le faire.
Si une fonction a besoin d'une information, on la lui transmet en paramètre.
👉 Une fonction devrait utiliser uniquement ses paramètres et ses variables locales.
❌ À éviter : la fonction utilise la variable globale masse
masse = 75
def calculer_poids(gravite):
return masse * gravite # masse vient de l'extérieur!
print(calculer_poids(9.81))
✅ À privilégier : la masse est transmise en paramètre
masse = 75
def calculer_poids(masse_kg, gravite):
return masse_kg * gravite # uniquement des paramètres
print(calculer_poids(masse, 9.81))
Pourquoi éviter les variables globales dans une fonction?
- 🔍 Dépendance cachée : en lisant l'appel
calculer_poids(9.81), rien n'indique que la fonction a aussi besoin demasse. Il faut lire tout son code pour le découvrir. - ♻️ Fonction moins réutilisable : copiée dans un autre programme ou importée depuis un module, elle plante (
NameError) simassen'y existe pas. - 🧪 Plus difficile à tester : pour calculer le poids d'une autre masse, il faut modifier la variable globale au lieu de simplement passer une autre valeur.
- 🐞 Plus difficile à déboguer : si la variable globale est modifiée ailleurs dans le programme, le résultat de la fonction change sans que son appel ait changé.
Règle simple : limitez au maximum les variables globales.
Une fonction bien écrite est comme une boîte noire : tout ce qui entre passe par ses paramètres, et tout ce qui sort passe par son return.
Les explications de cette section étaient-elles claires ?
En programmation, on suit souvent le principe DRY (Don't Repeat Yourself).
Si vous remarquez que vous copiez-collez du code en changeant seulement quelques valeurs, il est temps de créer une fonction!
Prenons un exemple en physique spatiale où l'on calcule et affiche le poids d'un spationaute dont la masse est de 75 kg sur différents astres (rappel : le poids est une force en newtons (N) calculée par la formule ).
masse_spationaute = 75
# Calcul et affichage pour la Terre
poids_terre = masse_spationaute * 9.81
print(f"Sur l'astre Terre, le poids est de {poids_terre:.2f} N.")
# Calcul et affichage pour Mars
poids_mars = masse_spationaute * 3.71
print(f"Sur l'astre Mars, le poids est de {poids_mars:.2f} N.")
# Calcul et affichage pour la Lune
poids_lune = masse_spationaute * 1.62
print(f"Sur l'astre Lune, le poids est de {poids_lune:.2f} N.")
Ici, les lignes de calcul et d'affichage sont répétées trois fois. C'est l'occasion idéale pour extraire le tout dans des fonctions.
Dans cet exemple, on va créer 2 fonctions : une pour faire le calcul du poids, et une pour faire l'affichage, qui appellera la première fonction pour faire le calcul.
Commençons par la fonction de calcul.
Fonction 1 : calcul du poids
Étape 1 : Identifier les éléments qui changent
Regardez attentivement les blocs de code répétés et identifiez ce qui varie d'un bloc à l'autre. Ces variables deviendront les paramètres de notre fonction.
Dans notre exemple, voici ce qui change :
- La valeur de la gravité (
9.81,3.71,1.62) - La masse pourrait aussi changer si on veut être plus flexible (
75).
Ce qui reste identique, c'est l'opération mathématique (la multiplication) et la phrase affichée dans le print().
Étape 2 : Extraire la fonction de calcul (avec retour)
Commençons par isoler le calcul mathématique. On veut créer une fonction qui reçoit les variables nécessaires, effectue le calcul, et nous redonne le résultat.
- Paramètres : la masse (
masse_kg) et la gravité (gravite). - Variable locale : le résultat du calcul (
poids). Elle n'existera que pour le temps de ce calcul. - Valeur de retour : le
poidscalculé (le résultat de la multiplication).
def calculer_poids(masse_kg, gravite):
poids = masse_kg * gravite
return poids
👉 Cette fonction est pure : son résultat dépend seulement de ses paramètres, et elle ne fait rien d'autre (aucun affichage, aucune modification à l'extérieur de la fonction).
C'est exactement la « boîte noire » décrite dans l'onglet Portée.
Résultat intermédiaire : intégration du calcul
Nous avons maintenant isolé la logique mathématique. Le programme principal appelle maintenant notre fonction calculer_poids au lieu de réécrire la formule à chaque fois.
def calculer_poids(masse_kg, gravite):
poids = masse_kg * gravite
return poids
masse_spationaute = 75
# On utilise maintenant la fonction pour obtenir les valeurs
p_terre = calculer_poids(masse_spationaute, 9.81)
print(f"Sur l'astre Terre, le poids est de {p_terre:.2f} N.")
p_mars = calculer_poids(masse_spationaute, 3.71)
print(f"Sur l'astre Mars, le poids est de {p_mars:.2f} N.")
p_lune = calculer_poids(masse_spationaute, 1.62)
print(f"Sur l'astre Lune, le poids est de {p_lune:.2f} N.")
👉 Observation : Le calcul est maintenant isolé dans une fonction (si la formule change ou contient une erreur, on ne la corrige qu'à un seul endroit). Cependant, on remarque que les instructions print() sont encore très répétitives. On va donc extraire une deuxième fonction pour gérer l'affichage, et qui appellera la fonction de calcul pour obtenir le poids.
Fonction 2 : affichage du poids
Étape 1 : Identifier ce que la fonction doit afficher
Regardez les lignes d'affichage et identifiez ce qui varie d'une ligne à l'autre.
Dans notre exemple, la phrase affichée contient :
- le nom de l'astre (
"Terre","Mars","Lune") - le poids calculé à partir de la masse et de la gravité
La structure de la phrase reste toujours la même.
Étape 2 : Extraire la fonction d'affichage (sans retour)
Nous allons créer une deuxième fonction qui gère le texte affiché, et qui appellera notre première fonction pour obtenir le poids.
- Paramètres : le nom de l'astre (
nom_astre), la masse (masse_kg) et la gravité (gravite). - Variable locale : le poids calculé par l'appel de fonction (
poids_calcule). - Valeur de retour : aucune (elle ne fera que des
print()).
def afficher_poids_astre(nom_astre, masse_kg, gravite):
# Appel à l'autre fonction pour faire le calcul
poids_calcule = calculer_poids(masse_kg, gravite)
# Affichage du résultat
print(f"Sur l'astre {nom_astre}, le poids est de {poids_calcule:.2f} N.")
👉 Une fonction peut en appeler une autre! Ici, afficher_poids_astre appelle calculer_poids. Pour voir comment Python s'y retrouve, consultez l'onglet Pile.
🕵️ Remarquez que masse_kg et gravite existent dans les deux fonctions : ce sont 4 variables différentes, chacune dans la portée de sa fonction. Dans votre trace, elles ont donc chacune leur colonne!
Résultat final : intégration de l'affichage
Une fois nos deux fonctions créées, notre programme principal devient beaucoup plus court et plus lisible!
# --- Définition des fonctions ---
def calculer_poids(masse_kg, gravite):
poids = masse_kg * gravite
return poids
def afficher_poids_astre(nom_astre, masse_kg, gravite):
poids_calcule = calculer_poids(masse_kg, gravite)
print(f"Sur l'astre {nom_astre}, le poids est de {poids_calcule:.2f} N.")
# --- Programme principal ---
masse_spationaute = 75
afficher_poids_astre("Terre", masse_spationaute, 9.81)
afficher_poids_astre("Mars", masse_spationaute, 3.71)
afficher_poids_astre("Lune", masse_spationaute, 1.62)
La console affiche :
Sur l'astre Terre, le poids est de 735.75 N.
Sur l'astre Mars, le poids est de 278.25 N.
Sur l'astre Lune, le poids est de 121.50 N.
👉 Si demain on veut changer la phrase affichée ou modifier le format d'affichage, on n'aura qu'à modifier un seul endroit dans le code au lieu de trois.
👉 Et pour ajouter un astre, il suffit maintenant d'une seule ligne :
afficher_poids_astre("Jupiter", masse_spationaute, 24.79) # Sur l'astre Jupiter, le poids est de 1859.25 N.
📋 Variante avec des listes parallèles
Les données utilisées pour appeler nos fonctions peuvent être organisées dans des listes parallèles : plusieurs listes où le même index correspond au même élément. Voici comment réécrire le programme principal en regroupant les noms des astres et leurs gravités dans des listes :
# --- Définition des fonctions (inchangées) ---
def calculer_poids(masse_kg, gravite):
poids = masse_kg * gravite
return poids
def afficher_poids_astre(nom_astre, masse_kg, gravite):
poids_calcule = calculer_poids(masse_kg, gravite)
print(f"Sur l'astre {nom_astre}, le poids est de {poids_calcule:.2f} N.")
# --- Programme principal avec des listes parallèles ---
masse_spationaute = 75
noms_astres = ["Terre", "Mars", "Lune"]
gravites = [9.81, 3.71, 1.62]
afficher_poids_astre(noms_astres[0], masse_spationaute, gravites[0])
afficher_poids_astre(noms_astres[1], masse_spationaute, gravites[1])
afficher_poids_astre(noms_astres[2], masse_spationaute, gravites[2])
👉 À l'index 0 on trouve tout ce qui concerne la Terre (noms_astres[0] et gravites[0]), à l'index 1 Mars, et ainsi de suite. Les données restent parfaitement synchronisées.
💡 Avec les boucles que vous verrez bientôt, il sera possible de parcourir ces listes automatiquement peu importe le nombre d'astres dans la liste!
- Qu'est-ce qui change d'une répétition à l'autre? Ce sont les paramètres.
- Qu'est-ce qui reste pareil? C'est le corps de la fonction.
- On remplace chaque répétition par un appel de la fonction, avec les bonnes valeurs.
Les explications de cette section étaient-elles claires ?
Il est possible d'ajouter des commentaires dans le code pour expliquer ce que fait une fonction ou pour donner des indications sur son utilisation.
Les commentaires sont ignorés par l'interpréteur Python et n'affectent pas l'exécution du code.
Ils sont utiles pour rendre le code plus lisible et compréhensible pour les autres développeurs (et pour vous-même dans le futur!).
En Python, les commentaires sont créés en utilisant le symbole # pour commenter une ligne entière ou une partie de ligne (tout ce qui est à droite du #).
# Ceci est un commentaire sur une seule ligne
total = 0 # Ceci est un commentaire en fin de ligne
⌨️ Dans PyCharm, Ctrl + / commente (ou décommente) les lignes sélectionnées. C'est très pratique pour désactiver temporairement du code pendant le débogage!
Le code dit déjà ce qu'il fait. Un commentaire utile explique pourquoi on le fait.
x = x + 1 # ❌ Ajoute 1 à x (répète le code, inutile)
tentatives = tentatives + 1 # ✅ Une tentative de plus après chaque erreur
Pour documenter une fonction, il est possible d'utiliser les triples guillemets """ (ou ''').
Ce type de documentation se nomme un docstring. Il se place sur la première ligne du corps de la fonction, indenté, juste après la ligne def.
Placé ailleurs, ce n'est plus un docstring : PyCharm ne l'affichera pas.
Créer une fonction sans mettre une documentation est une mauvaise pratique!
Par exemple :
# Ceci est un commentaire sur une seule ligne
def energie_cinetique(masse, vitesse): # Ceci est un commentaire en fin de ligne
"""
Calcule l'énergie cinétique d'un objet en mouvement.
Paramètres :
masse (float) : Masse de l'objet en kilogrammes (kg)
vitesse (float) : Vitesse de l'objet en mètres par seconde (m/s)
Retourne :
float : Énergie cinétique en joules (J)
Exemple d'utilisation :
energie_cinetique(10, 5) retourne 125.0
"""
nb_joules = 0.5 * masse * vitesse ** 2
return nb_joules
# Exemple avec différentes valeurs
objet1 = energie_cinetique(2, 3) # Masse de 2 kg, vitesse de 3 m/s
objet2 = energie_cinetique(5, 7) # Masse de 5 kg, vitesse de 7 m/s
# Affichage des résultats
print(f"Énergie cinétique de l'objet 1 : {objet1} joules") # 9.0 joules
print(f"Énergie cinétique de l'objet 2 : {objet2} joules") # 122.5 joules
Les lignes 3 à 15 constituent un docstring : un bloc utilisant des triples guillemets pour expliquer en détail la fonction energie_cinetique.
Lorsqu'une fonction possède une documentation sous forme de docstring, l'IDE vous permet de visualiser cette documentation rapidement.
Par exemple, si vous placez votre souris sur l'un des deux appels de fonction energie_cinetique, la documentation sera affichée.

Les docstrings ne servent qu'à la documentation et elles sont ignorées par Python lors de l'exécution du code.
Il en est de même pour les lignes 1, 19 et 23, qui sont des commentaires sur une seule ligne, ainsi que tout ce qui se trouve à droite du # aux lignes 2, 20, 21, 24 et 25.
Si vous tapez """ puis Entrée juste sous un def, PyCharm génère automatiquement un docstring dans un autre format (:param masse:, :return:).
👉 Dans ce cours, utilisez plutôt le format montré ci-dessus (Paramètres :, Retourne :).
Les docstrings sont évaluées dans le TP1 (1 point). Chaque docstring doit décrire clairement :
- le rôle de la fonction;
- ses paramètres (nom, type, signification et unité);
- sa valeur de retour (type et signification);
- les exceptions possibles.
Le tout dans un français sans faute!
👉 Les exceptions seront vues à la rencontre 4 : vous ajouterez alors une section Exceptions : à vos docstrings.
Les explications de cette section étaient-elles claires ?
À la rencontre 2, nous avons utilisé des modules existants comme math et random.
Bonne nouvelle : un module, ce n'est rien d'autre qu'un fichier .py. Donc n'importe quel fichier Python que vous écrivez peut devenir un module!
👉 Créer un module permet de regrouper des fonctions autour d'un même thème et de les réutiliser dans plusieurs programmes, sans jamais les copier-coller à la main.
C'est le prolongement naturel du principe DRY : au lieu de répéter du code dans un même fichier, on évite de le répéter d'un fichier à l'autre.
📖 La recette sur les modules montre pas à pas comment créer un module dans PyCharm. Cet onglet va plus loin : il explique ce qui se passe réellement lors d'un import.
physique.pyReprenons le calcul du poids vu dans l'onglet DRY. Plaçons la fonction dans son propre fichier, puis utilisons-la depuis un autre fichier.
📁 Les deux fichiers doivent être dans le même dossier.
Le module : il contient les fonctions réutilisables.
GRAVITE_TERRE = 9.81 # m/s²
def calculer_poids(masse, gravite):
"""Retourne le poids (N) d'un objet."""
return masse * gravite
Le programme principal : il importe le module et l'utilise.
import physique
poids = physique.calculer_poids(75, physique.GRAVITE_TERRE)
print(f"Poids : {poids} N")
- On écrit
import physique, sans l'extension.py: le nom du module est le nom du fichier sans.py. - Comme pour
math, on accède au contenu du module avec la syntaxenom_du_module.nom. - Les deux méthodes vues à la rencontre 2 fonctionnent aussi avec nos modules :
from physique import calculer_poidsest tout à fait valide. - Grâce au docstring, PyCharm affiche la documentation de
calculer_poidsquand vous placez la souris sur l'appel, même si la fonction est dans un autre fichier. C'est une raison de plus de bien commenter vos fonctions! GRAVITE_TERREest une constante : comme vu à la rencontre 1, on l'écrit en majuscules pour indiquer que sa valeur ne devrait jamais être modifiée.
📝 Dans cet onglet, les docstrings sont abrégés pour alléger les exemples. Dans vos programmes (et dans le TP1), écrivez-les au complet : rôle, paramètres, valeur de retour et exceptions.
Bien nommer son module : comme pour une variable, utilisez des lettres minuscules et des _ (ex. : outils_texte.py).
Pas d'espaces, pas de tirets -, pas d'accents et ne commencez pas par un chiffre : import 1-mon module n'est pas du Python valide!
import?Quand Python rencontre import physique, il fait essentiellement ceci :
- Il cherche le fichier
physique.py(d'abord dans le dossier du programme, ensuite parmi les modules installés avec Python). - Il exécute tout le fichier, de la première à la dernière ligne, exactement comme si vous l'aviez lancé.
- Il rend disponible tout ce que ce fichier a créé (fonctions, variables) sous le nom
physique.
👉 Vous pouvez donc imaginer un import comme un copier/coller automatique du contenu du module au début de votre programme :
Ce que vous écrivez
import physique
poids = physique.calculer_poids(75, physique.GRAVITE_TERRE)
print(f"Poids : {poids} N")
Ce que Python exécute (à peu près)
# ----- début du contenu de physique.py -----
GRAVITE_TERRE = 9.81 # m/s²
def calculer_poids(masse, gravite):
"""Retourne le poids (N) d'un objet."""
return masse * gravite
# ----- fin du contenu de physique.py -----
poids = calculer_poids(75, GRAVITE_TERRE)
print(f"Poids : {poids} N")
L'analogie est très utile pour comprendre ce qui s'exécute, mais elle n'est pas parfaite :
- Le code n'est écrit qu'à un seul endroit.
Si vous corrigez un bogue dansphysique.py, tous les programmes qui l'importent profitent de la correction.
Avec un vrai copier/coller, il faudrait corriger chaque copie! - Les noms restent « rangés » dans le module.
Avecimport physique, on doit écrirephysique.calculer_poids: cela évite les conflits si votre programme possède déjà une fonction du même nom.
Avecfrom physique import calculer_poids, le nom est copié directement dans votre programme : on se rapproche alors du vrai copier/coller. - Un module n'est exécuté qu'une seule fois.
Si le même module est importé deux fois, Python réutilise le résultat du premierimport.
📁 Après votre premier import, un dossier __pycache__ peut apparaître dans votre projet. C'est une version « précompilée » de vos modules que Python garde pour aller plus vite.
Vous pouvez l'ignorer : il sera recréé automatiquement au besoin.
Puisqu'un import exécute tout le fichier du module, toutes les instructions placées dans sa portée globale (à l'extérieur des fonctions) sont exécutées au moment de l'import.
Un def ne fait que définir une fonction (rien ne s'affiche), mais un print(), un input() ou un appel de fonction, lui, s'exécute vraiment!
Supposons que vous ayez testé votre fonction directement dans le module :
GRAVITE_TERRE = 9.81 # m/s²
def calculer_poids(masse, gravite):
"""Retourne le poids (N) d'un objet."""
return masse * gravite
# Tests de la fonction
print(calculer_poids(10, GRAVITE_TERRE))
import physique
poids = physique.calculer_poids(75, physique.GRAVITE_TERRE)
print(f"Poids : {poids} N")
En exécutant r03_poids.py, on obtient :
98.10000000000001
Poids : 735.75 N
😕 La première ligne ne vient pas de notre programme : c'est le test de la ligne 8 de physique.py, exécuté pendant l'import.
(Le ...0001 vient de la précision des flottants vue à la rencontre 2 : la fonction est correcte.)
Imaginez maintenant que le module contienne un input() : votre programme poserait une question inattendue avant même de commencer!
✅ Règle : la portée globale d'un module devrait contenir uniquement :
- des
import; - des constantes (comme
GRAVITE_TERRE); - des définitions de fonctions (
def).
Tout le reste (tests, print(), input(), appels de fonctions) va dans un bloc if __name__ == "__main__": (voir ci-dessous).
🔗 Lien avec l'onglet Portée : les variables globales d'un module sont accessibles par le programme qui l'importe (ex. : physique.GRAVITE_TERRE). C'est pratique pour des constantes, mais la bonne pratique tient toujours : une fonction du module ne devrait pas dépendre de variables globales. Elle reçoit ce dont elle a besoin en paramètre, sinon elle risque de ne plus fonctionner une fois importée ailleurs.
if __name__ == "__main__":Comment garder nos tests dans le module, sans qu'ils s'exécutent lors d'un import?
Python fournit une variable spéciale, __name__ (deux _ de chaque côté), qui existe automatiquement dans chaque fichier :
| Comment le fichier est utilisé | Valeur de __name__ dans ce fichier |
|---|---|
| Exécuté directement (bouton ▶ dans PyCharm) | "__main__" |
| Importé par un autre fichier | le nom du module, ex. : "physique" |
Il suffit donc de vérifier cette valeur pour savoir si le fichier est « le programme principal » ou s'il est importé :
🔜 Le if (une condition) et la comparaison == seront vus à la rencontre 4.
Pour l'instant, retenez cette ligne comme une formule : le code indenté en dessous s'exécute seulement si on lance ce fichier directement.
GRAVITE_TERRE = 9.81 # m/s²
def calculer_poids(masse, gravite):
"""Retourne le poids (N) d'un objet."""
return masse * gravite
if __name__ == "__main__":
# Ce bloc s'exécute seulement si on lance physique.py directement
print(calculer_poids(10, GRAVITE_TERRE)) # 98.10000000000001
print(calculer_poids(10, 1.62)) # Sur la Lune : 16.200000000000003
| Action | Résultat |
|---|---|
Exécuter physique.py | Les tests des lignes 9 et 10 s'affichent : on peut tester le module. |
Exécuter r03_poids.py (qui importe physique) | __name__ vaut "physique" : le bloc est ignoré, seul Poids : 735.75 N s'affiche. |
| Erreur | Cause probable |
|---|---|
ModuleNotFoundError: No module named 'physique' | Le module n'est pas dans le même dossier que le programme, ou son nom est mal écrit (attention aux majuscules et aux accents). |
ModuleNotFoundError: No module named 'physique.py'; 'physique' is not a package | On a écrit import physique.py : il ne faut pas mettre l'extension. |
NameError: name 'calculer_poids' is not defined | Avec import physique, on a oublié le préfixe : il faut écrire physique.calculer_poids(...). |
AttributeError: module 'random' has no attribute 'randint' | Vous avez nommé votre fichier random.py (ou math.py, etc.) : Python importe votre fichier au lieu du vrai module! Renommez-le. Python vous le suggère d'ailleurs à la fin du message : (consider renaming '...\random.py' since it has the same name as the standard library module named 'random' ...). |
- Un module est un simple fichier
.py; on l'importe avec son nom, sans.py. importexécute tout le fichier du module, un peu comme un copier/coller, puis rend son contenu disponible.- La portée globale d'un module ne contient que des
import, des constantes et desdef. - Les tests et le code à exécuter vont dans
if __name__ == "__main__":.
Les explications de cette section étaient-elles claires ?
Les fonctions peuvent appeler d'autres fonctions.
Cela est utile pour décomposer des tâches complexes en sous-tâches plus simples.
def ajouter(x, y):
return x + y
def multiplier(x, y):
return x * y
def calculer_expression(a, b, c):
somme = ajouter(a, b)
resultat = multiplier(somme, c)
return resultat
valeur = calculer_expression(2, 3, 4)
print(valeur) # Affiche 20
Dans cet exemple, la fonction calculer_expression() appelle les fonctions ajouter() et multiplier() pour effectuer une série de calculs.
Lorsque l'on démarre un programme Python, une pile d'appels est automatiquement créée.
Cette structure de données, généralement invisible sauf en cas d'erreur ou via des outils de débogage,
permet à Python de suivre l'ordre d'exécution des fonctions et de conserver l'état des variables locales.
🍽️ Imaginez une pile d'assiettes : on pose toujours une nouvelle assiette sur le dessus, et on retire toujours celle du dessus.
🔁 Fonctionnement de la pile
- Lorsqu'une instruction appelle une fonction, celle-ci est empilée au sommet de la pile d'appels.
- Python exécute une seule fonction à la fois, toujours celle qui se trouve en haut de la pile.
- Une fois l'exécution terminée (
returnou fin du corps), la fonction est retirée de la pile. - La fonction qui se retrouve au sommet reprend là où elle s'était arrêtée : à la ligne de l'appel, avec la valeur retournée.
📚 Principe LIFO
La pile d'appels suit le principe LIFO (Last In, First Out, « dernier entré, premier sorti ») :
- La dernière fonction appelée est la première à se terminer et à être retirée.
- Ce mécanisme permet à Python de gérer les appels imbriqués de fonctions, et de revenir à l'état précédent une fois qu'une fonction a terminé son exécution.
🧱 La pile, étape par étape
Voici l'état de la pile pendant l'exécution de l'exemple calculer_expression ci-dessus (le sommet est à droite) :
| Moment | Pile d'appels |
|---|---|
| Début du programme | <module> |
Ligne 12 : appel de calculer_expression | <module> → calculer_expression |
Ligne 8 : appel de ajouter | <module> → calculer_expression → ajouter |
ajouter retourne 5 | <module> → calculer_expression |
Ligne 9 : appel de multiplier | <module> → calculer_expression → multiplier |
multiplier retourne 20 | <module> → calculer_expression |
calculer_expression retourne 20 | <module> |
🕵️ <module>, c'est le nom que Python donne au programme principal (le code à l'extérieur de toute fonction).
C'est exactement ce que vous notez globale dans la colonne contexte de vos traces. Vous verrez <module> dans le débogueur et dans les messages d'erreur.
Un exemple avec un affichage
def fonction_a():
print("Fonction A")
fonction_b()
print("Retour dans A")
def fonction_b():
print("Fonction B")
fonction_a()
La console affiche :
Fonction A
Fonction B
Retour dans A
Lorsque fonction_a() est appelée, elle appelle fonction_b(), qui est ajoutée au sommet de la pile.
Une fois que fonction_b() a terminé son exécution, elle est retirée, et fonction_a() reprend à la ligne 4 : « Retour dans A » s'affiche.
👉 Remarquez que fonction_b est définie après fonction_a, et que ça fonctionne quand même : fonction_a() n'est appelée qu'à la ligne 9, quand les deux fonctions existent déjà. L'important, c'est que toutes les fonctions soient définies avant le premier appel.
Quand une erreur survient, Python affiche l'état de la pile d'appels à ce moment-là. Reprenons l'erreur de l'onglet Portée :
Traceback (most recent call last):
File "...\r03_compteur.py", line 6, in <module>
incrementer()
~~~~~~~~~~~^^
File "...\r03_compteur.py", line 4, in incrementer
compteur = compteur + 1
^^^^^^^^
UnboundLocalError: cannot access local variable 'compteur' where it is not associated with a value
- Chaque
File ..., line ..., in ...est un étage de la pile :<module>(le programme principal), puisincrementer. - most recent call last veut dire « l'appel le plus récent en dernier » : le sommet de la pile est en bas.
- C'est pourquoi on lit un traceback de bas en haut : la dernière ligne donne l'erreur, l'étage juste au-dessus dit dans quelle fonction elle s'est produite, et les étages plus haut disent qui a appelé cette fonction.
Le débogueur permet d'inspecter tous les détails de la pile d'appels.
Copiez le code ci-dessous dans un script, mettez un point d'arrêt sur la ligne 12 (valeur = ...) et exécutez le script en mode débogage.
def ajouter(x, y):
return x + y
def multiplier(x, y):
return x * y
def calculer_expression(a, b, c):
somme = ajouter(a, b)
resultat = multiplier(somme, c)
return resultat
valeur = calculer_expression(2, 3, 4)
print(valeur) # Affiche 20
| Bouton | Effet sur une ligne qui contient un appel de fonction |
|---|---|
| Exécute l'appel en entier, sans entrer dans la fonction | |
| Entre dans la fonction appelée | |
| Step Out | Termine la fonction en cours et revient à la ligne qui l'a appelée |
Pour entrer dans les fonctions appelées en mode débogage, il faut donc utiliser le bouton Step Into .
Lorsque vous entrez dans la fonction calculer_expression(), vous voyez :
- cette fonction s'ajouter au sommet de la pile d'appels (à gauche), au-dessus de
<module>, - les paramètres
a,betcapparaître dans la liste des variables (à droite) :

Si vous appuyez de nouveau sur , vous entrez dans la fonction
ajouter().
Vous pouvez voir que la fonction ajouter() est maintenant au sommet de la pile d'appels, et les paramètres x et y sont affichés dans la liste des variables :

Remarquez que les paramètres a, b et c de calculer_expression() ne sont plus visibles,
car vous êtes maintenant dans la fonction ajouter() et a, b et c sont hors de portée (voir l'onglet Portée).
Vous pouvez cliquer sur le nom de la fonction calculer_expression() dans la pile d'appels pour revenir à cette fonction et voir ses paramètres à nouveau, qui sont en attente du moment où calculer_expression() redeviendra la fonction sur le dessus de la pile :

Dans une trace, la colonne contexte correspond à la fonction au sommet de la pile (globale pour <module>).
Pour le reste de la méthode, relisez l'encadré « La portée dans vos traces » de l'onglet Portée et l'exemple de trace avec fonctions.
Le débogueur est alors le meilleur outil pour valider votre trace... sauf pour le volet papier de l'examen!
Les explications de cette section étaient-elles claires ?
🕵️♂️ Trace d'exécution avec des fonctions
Voici un exemple de trace d'exécution contenant des appels de fonctions.
Pour la méthode complète, consultez la recette Produire une trace et imprimez la feuille de trace.
Code
Si on a le code suivant :
def carre(n):
return n * n
def affiche_resultat():
a = 2
b = 3
total = carre(a) + carre(b)
print(f'La somme des carrés est : {total}')
z = 42
affiche_resultat()
Trace
On aura la trace suivante :
| Portées et variables | |||||||
|---|---|---|---|---|---|---|---|
| globale | affiche_resultat | carre | |||||
| #ligne | contexte | z | a | b | total | n | affichage |
| 10 | globale | 42 | |||||
| 11 | globale | 42 | |||||
| 5 | affiche_resultat | 42 | 2 | ||||
| 6 | affiche_resultat | 42 | 2 | 3 | |||
| 7 | affiche_resultat | 42 | 2 | 3 | |||
| 2 | carre | 42 | 2 | ||||
| 7 | affiche_resultat | 42 | 2 | 3 | |||
| 2 | carre | 42 | 3 | ||||
| 7 | affiche_resultat | 42 | 2 | 3 | 13 | ||
| 8 | affiche_resultat | 42 | 2 | 3 | 13 | La somme des carrés est : 13 | |
Explications
La colonne #ligne correspond exactement aux numéros de lignes que vous voyez défiler dans votre éditeur lorsque vous exécutez votre programme en mode débogage (pas à pas). Chaque ligne de la trace représente un moment précis de l'exécution, tout comme chaque fois que vous appuyez sur Pas suivant (Step Over / Step Into) dans le débogueur.
Produire une trace à la main, c'est donc faire le travail du débogueur dans votre tête.
On indique la portée des variables en les regroupant par portée (première ligne).
Ici, on a la portée globale (variables définies en dehors de toute fonction), la portée de affiche_resultat() et la portée de carre().
On remarque que la variable n n'existe que dans la portée de la fonction carre(), et que les variables a, b et total n'existent que dans la portée de la fonction affiche_resultat().
La variable z est dans la portée globale, c'est pourquoi elle est visible dans toute la trace.
La colonne contexte indique où se trouve l'exécution au moment de chaque ligne :
globalelorsque la ligne exécutée est à l'extérieur de toute fonction (le programme principal);- le nom de la fonction en cours d'exécution lorsque la ligne exécutée est à l'intérieur d'une fonction.
Dans l'exemple ci-dessus :
- À la ligne 11, l'appel
affiche_resultat()se fait depuis le programme principal : le contexte est encoreglobale. - Aux lignes 5 à 8, on exécute le code de
affiche_resultat: le contexte estaffiche_resultat. - À la ligne 7,
carre(a)est appelée : la ligne suivante (ligne 2) s'exécute dans le contextecarre. - Une fois le
returnexécuté, on revient à la ligne 7, de nouveau dans le contexteaffiche_resultat.
👉 Le contexte indique quelles variables sont accessibles : seules celles de la portée globale et de la portée du contexte courant ont une valeur sur cette ligne de la trace.
Voici maintenant un petit exemple qui démontre l'importance de spécifier la portée des variables, où on a une variable x dans la portée globale et une autre variable nommée x dans la portée de la fonction ma_fonction().
Code
def ma_fonction(y):
x = 3 + y
print(f'dans ma_fonction, x vaut {x}')
x = 5
print(f'dans main, x vaut {x}')
ma_fonction(100)
print(f'dans main, x vaut toujours {x}')
Trace
| Portées et variables | |||||
|---|---|---|---|---|---|
| globale | ma_fonction | ||||
| #ligne | contexte | x | y | x | affichage |
| 5 | globale | 5 | |||
| 6 | globale | 5 | dans main, x vaut 5 | ||
| 7 | globale | 5 | |||
| 2 | ma_fonction | 5 | 100 | 103 | |
| 3 | ma_fonction | 5 | 100 | 103 | dans ma_fonction, x vaut 103 |
| 8 | globale | 5 | dans main, x vaut toujours 5 | ||
- On voit que la variable
xdans la portée dema_fonction()n'a rien à voir avec la variablexdans la portée globale. - Cette dernière n'est pas modifiée par l'exécution de
ma_fonction(), malgré le fait qu'on ait une instructionx = 3 + ydansma_fonction()et que la variable globalexsoit aussi accessible dansma_fonction()(car elle est globale). - La raison est que l'instruction
x = 3 + ycrée une nouvelle variable localexdans la portée dema_fonction(), qui masque la variable globalex. - Si on voulait modifier la variable globale
xdansma_fonction(), il faudrait utiliser le mot-cléglobal(ce qui est déconseillé en général).
Pour favoriser une progression efficace, ce cours adopte une approche de classe inversée. Ce modèle déplace l'acquisition théorique hors de la classe pour transformer les heures de rencontre en véritables séances d'application pratique.
-
À la maison (Exploration et Appropriation) : Vous êtes le maître de votre rythme. Ces activités vous permettent de découvrir les nouveaux concepts et tester les exemples au moment où vous êtes le plus concentré. Si une notion vous semble obscure, n'hésitez pas à poser des questions à votre prof au fur et à mesure.
-
En classe (Application et Consolidation) : Le temps en présentiel est une ressource précieuse. Nous l'utilisons pour nous attaquer aux défis plus complexes et aux exercices de programmation qui demandent une mobilisation active de vos connaissances. C’est le moment idéal pour obtenir une rétroaction immédiate, collaborer avec vos pairs et bénéficier de l'accompagnement de votre enseignant au moment où vous en avez le plus besoin.
- 🏠 Activités à faire à la maison
- 🏫 Activités à faire en classe
🧠 Auto-validation des connaissances
Ce formulaire sert à vérifier votre compréhension des éléments les plus importants de la rencontre R03. Ne faites ce questionnaire que lorsque vous vous sentez en très bonne maîtrise de la matière. En classe, dès votre arrivée, vous aurez un questionnaire très similaire, évalué sommativement, à compléter sans accès à aucune documentation.
Ne pas remplir le formulaire diminue fortement vos chances de réussir l’évaluation sommative en début de rencontre.
Assurez-vous de bien comprendre toutes les notions derrière chaque question.
✏️ Exercices de compréhension
Pour le premier exercice de cette section, vous pouvez écrire vos réponses sur papier ou vous pouvez créer un fichier markdown.
Pour les autres exercices, vous pouvez imprimer ce tableau de trace d'exécution pour réaliser les traces.
📁 Créez un fichier r03_portee_variables.md pour votre réponse.
Il n’y a aucune trace à rédiger pour ce numéro.
Soit le code suivant :
def calcul_complexe(a, b, c):
x = a ** b
y = c * (b - a)
return x + y
x = 5
calcul_complexe(2, 3, 4)
print(x)
Combien vaut x dans calcul_complexe? (ligne 2)
Combien vaut x dans le script principal? (ligne 6)
S’agit‑il de la même variable 𝑥 ou de deux variables distinctes? Expliquez.
Portée des variables (locale vs globale), paramètres de fonction, variables distinctes de même nom, return
🖨 Pour réaliser cet exercice, imprimez le tableau de trace d'exécution.
En situation d'examen, vous devrez compléter une trace d'exécution sur papier sans utiliser d'ordinateur.
Sans exécuter le code, déterminez ce que le programme ci-dessous va afficher dans la console.
En suivant la recette de trace avec fonctions, complétez le tableau de trace d'exécution ligne par ligne.
def fonction_lineaire(a, x, b) :
print("appel de la fonction")
z = a * x + b
return z
x = 5
y = 10
z = 2
r = fonction_lineaire(x, z, y) # Attention à l'ordre des paramètres
x = x - 3
print(r, x)
Validez ensuite votre trace en exécutant le programme en mode débogage.
Avancez pas à pas et observez l'évolution de chaque variable à chaque ligne.
Appel de fonction, paramètres et ordre des arguments, return, réaffectation de variables, trace d'exécution, débogueur
🖨 Pour réaliser cet exercice, imprimez le tableau de trace d'exécution.
Sans exécuter le code, déterminez ce que le programme ci-dessous va afficher dans la console.
En suivant la recette de trace avec fonctions, complétez le tableau de trace d'exécution ligne par ligne.
def ajoute_cinq(x):
return x + 5
def carre(x):
return x * x
def calcul_final(a, b):
print("appel de calcul_final")
return carre(a) + ajoute_cinq(b)
x = 2
resultat = calcul_final(x, 3)
print(resultat)
Validez ensuite votre trace en exécutant le programme en mode débogage.
Avancez pas à pas et observez l'évolution de chaque variable à chaque ligne.
Appels de fonctions imbriqués, paramètres, return, ordre d'exécution, trace d'exécution, débogueur
🎯 Solutionnaires
Consultez le solutionnaire uniquement après avoir complété l'exercice par vous-même.
Comparer votre réponse avec une solution vous permet de valider votre raisonnement et de corriger vos erreurs.
Consulter la solution avant d'avoir tenté l'exercice prive votre cerveau de l'occasion de construire des connexions durables.
- Portée des variables — solutionnaire.pdf
- Trace avec fonction — solutionnaire.pdf
- Trace avec fonctions avec paramètres — solutionnaire.pdf
TABpour indenter,Maj + TABpour retirer une indentation.- N'utilisez jamais la barre d'espace pour indenter.
- Toutes les lignes d'un même bloc doivent avoir exactement la même indentation.
- Sinon :
IndentationError.
🔨 Exercices de création
Pour chacun des exercices de cette section, vous devez créer des fichiers .py avec les noms indiqués.
Pour les exercices de cette section, vous pouvez consulter librement la documentation du site web du cours.
📁 Créez un fichier r03_celsius_fahrenheit.py pour votre réponse.
Écrivez une fonction celsius_vers_fahrenheit(celsius) qui reçoit une température en °C et retourne sa valeur
en °F grâce à la formule
Tester votre fonction à l'aide des instructions ci-dessous :
print(celsius_vers_fahrenheit(0)) # 32.0
print(celsius_vers_fahrenheit(100)) # 212.0
Définition de fonction, paramètre, return, opérateurs arithmétiques
📁 Créez un fichier r03_aire_rectangle.py pour votre réponse.
Écrivez une fonction aire_rectangle(cote1, cote2) qui calcule et retourne l’aire d’un rectangle.
Puis, appelez la fonction pour afficher l’aire d’un rectangle de 5 m 3 m. Par exemple :
print(f"L'aire d'un rectangle de 5 x 3 est : {aire_rectangle(5,3)}") # L'aire d'un rectangle de 5 x 3 est : 15
Définition de fonction, paramètres, return, appel de fonction, f-strings
📁 Créez un fichier r03_reutilisation_fonctions.py pour votre réponse.
-
Écrivez une fonction
aire_rectangle(cote1, cote2)qui calcule et retourne l’aire d’un rectangle. -
Écrivez une deuxième fonction
volume_prisme(longueur, largeur, hauteur)qui calcule et retourne le volume d’un prisme rectangulaire.
👉 Cette deuxième fonction doit réutiliser (appeler) votre fonction aire_rectangle pour calculer la base du prisme avant de la
multiplier par la hauteur.
- Écrivez une troisième fonction
aire_totale_prisme(longueur, largeur, hauteur)qui calcule et retourne l’aire totale des 6 faces du prisme (la surface à peindre, par exemple).
👉 Un prisme rectangulaire possède 3 paires de faces identiques : deux faces , deux faces et deux faces .
Votre fonction doit appeler aire_rectangle trois fois (une par paire de faces) avec les bonnes dimensions, additionner les 3 aires obtenues, puis multiplier le total par 2.
⚠️ À vous de réfléchir à quelles dimensions transmettre à chaque appel : ce n’est pas une recopie de formule, c’est une décomposition à raisonner.
- Testez vos fonctions en affichant :
- l’aire d’un rectangle de
- le volume d’un prisme de
- l’aire totale d’un prisme de (réponse attendue : )
Objectif : pratiquer la décomposition d’un problème en plusieurs fonctions réutilisables, en réfléchissant aux arguments à transmettre à chaque appel.
Définition de fonctions, return, appel d'une fonction depuis une autre (réutilisation), appels multiples d'une même fonction, décomposition d'un problème
Dans cet exercice, vous allez séparer votre code en deux fichiers : un module, qui contient une fonction réutilisable, et un script, qui importe ce module pour utiliser la fonction.
📁 Créez les deux fichiers suivants, dans le même dossier :
| Fichier | Rôle |
|---|---|
sciences_nature.py | Le module : il contient la fonction de calcul. |
r03_energie_cinetique.py | Le script : il importe le module et affiche les résultats. |
Au besoin, référez-vous à la recette sur les modules.
Étape 1 : le module sciences_nature.py
Écrivez une fonction energie_cinetique(masse, vitesse) qui retourne l'énergie cinétique calculée selon la formule :
où est la masse (en kg), est la vitesse (en m/s) et est l'énergie (en joules, J).
La fonction ne doit rien afficher : elle utilise return pour renvoyer le résultat. C'est le script qui s'occupe de l'affichage.
Étape 2 : le script r03_energie_cinetique.py
- Importez le module
sciences_nature. - Appelez la fonction
energie_cinetiquepour chacun des cas suivants. - Affichez chaque résultat avec une phrase claire.
| Objet | Masse (kg) | Vitesse (m/s) | Énergie attendue (J) |
|---|---|---|---|
| Ballon | 0.5 | 10 | 25.0 |
| Cycliste | 80 | 8 | 2560.0 |
| Voiture | 1500 | 25 | 468750.0 |
Exemple d'affichage attendu :
Énergie cinétique du ballon : 25.0 J
Énergie cinétique du cycliste : 2560.0 J
Énergie cinétique de la voiture : 468750.0 J
Utilisez le tableau pour vérifier que votre fonction donne les bons résultats.
Modules (créer et importer), définition de fonction, paramètres, return, opérateurs arithmétiques (**, /)
Dans cet exercice, vous allez enrichir le module créé à l'exercice précédent en y ajoutant une deuxième fonction, puis l'utiliser dans un nouveau script.
📁 Vous travaillerez avec les deux fichiers suivants, dans le même dossier :
| Fichier | Rôle |
|---|---|
sciences_nature.py | Le module de l'exercice précédent, que vous allez compléter. |
r03_force_gravitationnelle.py | Le nouveau script : il importe le module et affiche les résultats. |
Étape 1 : compléter le module sciences_nature.py
- Au début du module, définissez une constante
Gpour la constante gravitationnelle : N·m²/kg². En Python, cette valeur s'écrit6.674e-11. - Sous la fonction
energie_cinetique(ne la supprimez pas!), ajoutez une fonctionforce_gravitationnelle(m1, m2, r)qui retourne la force d'attraction entre deux objets, selon la loi de la gravitation universelle de Newton :
où et sont les masses des deux objets (en kg), est la distance entre leurs centres (en m) et est la force (en newtons, N).
Le poids d'un objet est la force gravitationnelle qu'exerce une planète sur lui. Pour le calculer, on utilise la masse de la planète pour , la masse de l'objet pour , et le rayon de la planète pour .
Étape 2 : le script r03_force_gravitationnelle.py
- Importez le module
sciences_nature. - Appelez la fonction
force_gravitationnellepour chacun des cas suivants. - Affichez chaque résultat avec une phrase claire.
| Situation | (kg) | (kg) | (m) | Force attendue (N) |
|---|---|---|---|---|
| Poids d'une personne sur la Terre | 70 | ≈ 687.4 | ||
| Poids d'une personne sur la Lune | 70 | ≈ 113.8 | ||
| Attraction entre la Terre et la Lune | ≈ |
Les valeurs attendues sont arrondies : il est normal que votre programme affiche plus de décimales.
Dans une f-string, {force:.1f} affiche un nombre avec une décimale, et {force:.3e} l'affiche en notation scientifique avec trois décimales (par exemple 1.982e+20).
Modules (compléter et importer), constantes, définition de fonction à plusieurs paramètres, return, opérateurs arithmétiques (**), notation scientifique en Python (e)
📁 Créez un fichier r03_bonjour.py pour votre réponse.
- Écrivez une fonction
dire_bonjour(prenom)qui reçoit un prénom en paramètre et affiche un message de salutation personnalisé.
Par exemple, appelerdire_bonjour("Chatmouraï")doit afficher :
Bonjour, Chatmouraï!
- Déclarez une liste de prénoms, puis appelez
dire_bonjourpour chaque élément en accédant aux éléments par leur index :
prenoms = ["Chatmouraï", "Astro", "Peluche"]
✅ Sortie attendue
Bonjour, Chatmouraï!
Bonjour, Astro!
Bonjour, Peluche!
Définition de fonction, paramètre, f-strings, listes, accès par index
📁 Créez un fichier r03_umbrella_corporation.py pour votre réponse.
Le code ci-dessous affiche un rapport concernant des expérimentations réalisées par une entreprise pharmaceutique de confiance.
Beaucoup d'instructions servant à afficher des données sont très similaires et sont utilisées dans le même ordre.
En programmation, c'est un signe qu'on doit créer une fonction!
De plus, les données des échantillons peuvent être organisées dans des listes parallèles pour rendre le code encore plus lisible.
Améliorez ce code! Déclarez les listes parallèles, définissez une fonction et appelez-la.
print("Rapport - Résultats des expériences Umbrella Corporation")
print()
print("Échantillon : Virus-T")
print("Température : 37.0°C")
print("pH : 6.2")
print("Mutation Cellulaire : Stable")
print("Contagiosité : Élevée")
print("---------------")
print("Échantillon : Virus-G")
print("Température : 39.5°C")
print("pH : 5.8")
print("Mutation Cellulaire : Instable")
print("Capacité Régénérative : Extrême")
print("---------------")
print("Échantillon : Uroboros")
print("Température : 40.0°C")
print("pH : 7.0")
print("Mutation Cellulaire : Agressive")
print("Compatibilité Hôte : Faible")
print("---------------")
print()
print("Fin du rapport. Données classifiées - Niveau d'accès : Alpha")
🛠️INSTRUCTIONS
- Déclarez cinq listes parallèles contenant les données des trois échantillons :
noms = ["Virus-T", "Virus-G", "Uroboros"]temperatures = [37.0, 39.5, 40.0]pH_valeurs = [6.2, 5.8, 7.0]mutations = ["Stable", "Instable", "Agressive"]specifiques = ["Contagiosité : Élevée", "Capacité Régénérative : Extrême", "Compatibilité Hôte : Faible"]
- Définissez une fonction nommée
afficher_echantillon(...)qui reçoit un élément de chacune des cinq listes en paramètre et affiche le bloc d'informations d'un échantillon. - Appelez la fonction trois fois en lui passant les éléments correspondants par leur index (
noms[0],temperatures[0], etc.).
À l'index 0, on retrouve tout ce qui concerne le Virus-T (noms[0], temperatures[0], etc.). Cette structure rend les données plus faciles à maintenir : ajouter un quatrième échantillon ne demande qu'un ajout dans chaque liste. Avec les boucles for que vous verrez bientôt, un seul appel de fonction suffirait pour traiter tous les échantillons!
Lorsqu'on exécute votre version améliorée, on devrait observer le même résultat dans la console que la version originale.
Refactorisation, détection de répétitions, définition de fonction, paramètres, listes parallèles, accès par index
📁 Créez un fichier r03_calcul_densite.py pour votre réponse.
Le code ci-dessous calcule la densité en kg/m3 de 3 échantillons à partir de leur masse en g et de leur volume en cm3.
Le problème : les données sont stockées dans des variables individuelles et le calcul est répété trois fois.
Votre mission est de réécrire ce programme en mieux, en partant d'une page blanche.
#Variables contenants les données de 3 échantillons
echantillon1_masse_en_g = 135
echantillon1_volume_cm3 = 84
echantillon2_masse_en_g = 270
echantillon2_volume_cm3 = 151
echantillon3_masse_en_g = 92
echantillon3_volume_cm3 = 113
#Calcul des densités pour les 3 échantillons
echantillon1_masse_en_kg = echantillon1_masse_en_g / 1000
echantillon1_volume_m3 = echantillon1_volume_cm3 / 1_000_000
echantillon1_densite = echantillon1_masse_en_kg / echantillon1_volume_m3
echantillon2_masse_en_kg = echantillon2_masse_en_g / 1000
echantillon2_volume_m3 = echantillon2_volume_cm3 / 1_000_000
echantillon2_densite = echantillon2_masse_en_kg / echantillon2_volume_m3
echantillon3_masse_en_kg = echantillon3_masse_en_g / 1000
echantillon3_volume_m3 = echantillon3_volume_cm3 / 1_000_000
echantillon3_densite = echantillon3_masse_en_kg / echantillon3_volume_m3
#Affichage des résultats
print("Densité 1 :", round(echantillon1_densite, 2), "kg/m3")
print("Densité 2 :", round(echantillon2_densite, 2), "kg/m3")
print("Densité 3 :", round(echantillon3_densite, 2), "kg/m3")
🛠️INSTRUCTIONS
- Déclarez deux listes parallèles
masses_getvolumes_cm3contenant les données des 3 échantillons tirées du code ci-dessus. - Créez une fonction
calculer_densite(masse_g, volume_cm3)qui :- convertit la masse de grammes en kilogrammes,
- convertit le volume de cm³ en m³,
- calcule et retourne la densité en kg/m³.
- Appelez votre fonction trois fois en accédant aux éléments des listes par leur index et stockez les résultats dans des variables.
- Affichez les résultats de façon identique à la version originale.
Les masses et les volumes sont des données du même type collectées pour chaque échantillon. Les regrouper en listes parallèles réduit le nombre de variables de 6 à 2, et rend le code plus lisible : masses_g[1] et volumes_cm3[1] désignent clairement les données du deuxième échantillon. Avec les boucles for que vous verrez bientôt, un seul appel de fonction suffirait pour calculer les 3 densités!
✅ Sortie attendue
Densité 1 : 1607.14 kg/m3
Densité 2 : 1788.08 kg/m3
Densité 3 : 814.16 kg/m3
🎯 Pour aller plus loin
Ajoutez une ligne supplémentaire qui affiche la densité moyenne des 3 échantillons.
Pas besoin de recalculer quoi que ce soit : placez les 3 densités déjà obtenues dans une liste,
puis calculez la moyenne en divisant la somme des éléments de la liste par le nombre d'éléments de la liste.
✅ Sortie attendue (avec la ligne supplémentaire)
Densité 1 : 1607.14 kg/m3
Densité 2 : 1788.08 kg/m3
Densité 3 : 814.16 kg/m3
Densité moyenne : 1403.13 kg/m3
Refactorisation, listes parallèles, accès par index, définition de fonction, return, round(), sum() / len() (pour aller plus loin)
📁 Créez un fichier r03_nanosecondes.md pour votre réponse.
Dans la documentation du module time (doc), on trouve la fonction time.monotonic_ns().
Cette fonction permet d'obtenir le temps en nanosecondes depuis le lancement de l'application. À chaque appel de la fonction, le temps retourné est toujours de plus en plus grand. Testez le code ci-dessous :
import time
print(f"Temps moment A: {time.monotonic_ns()}")
print(f"Temps moment B: {time.monotonic_ns()}")
print(f"Temps moment C: {time.monotonic_ns()}")
Maintenant que vous comprenez ce que retourne cette fonction, observez son utilisation ci-dessous :
import time
def calcul_intensif():
'''
N'essayez VRAIMENT pas de comprendre le code de cette fonction!
Vous allez être en mesure de le comprendre à partir du cours sur les boucles.
La seule chose qui est importante de savoir, c'est que cette fonction prend un
certain temps pour s'exécuter (1 à 2 secondes en moyenne).
'''
total = 0
for i in range(1, 20000000): # 20 millions d'itérations
total += i ** 0.5
return total
tempA = time.monotonic_ns()
calcul_intensif()
tempB = time.monotonic_ns()
mystere = tempB - tempA # Expression intéressante
print(mystere)
Question
✏️ Selon vous, en observant les instructions 15 à 19, que représente le nombre contenu dans la variable mystere?
Instructions pour vous aider dans votre réflexion
- Exécutez le programme tel quel et notez la valeur affichée.
- À la ligne 11, modifiez le nombre 20 000 000 pour 40 000 000.
- Réexécutez le programme et notez le nouveau résultat.
- Expliquez la différence entre les 2 résultats obtenus.
Module time (monotonic_ns), appel de fonction, mesure du temps d'exécution, lecture de documentation, f-strings
✏️ Exercices sur papier
Faites ces exercices d'abord sur papier (ou dans un éditeur de texte simple) et sans aucune documentation, comme à l'examen.
Vous pouvez valider votre réponse dans PyCharm à la fin — un luxe que vous n'aurez pas le jour de l'examen, d'où l'importance de vous entraîner sans lui.
📁 Créez un fichier r03_force_centripete.py pour votre réponse.
Écrivez un programme qui calcule la force nécessaire () pour maintenir un objet en mouvement circulaire (comme une voiture dans un virage).
Formule :
(Note : est la masse en kg, la vitesse en m/s et le rayon du virage en mètres)
Contraintes techniques :
- Définissez une fonction nommée
calculer_force_centripeterecevant 3 paramètres : la masse, la vitesse et le rayon. - La fonction doit retourner la valeur calculée (elle ne doit pas faire de print elle-même).
- Appelez la fonction, récupérez la valeur retournée dans une variable, puis affichez le résultat final avec deux décimales.
Exemple attendu (pour , , ) :
Paramètres : 1200 kg, 25 m/s, 50 m
La force centripète résultante est de 15000.00 N
Définition de fonction, paramètres, return, opérateurs arithmétiques (**), round() / format à 2 décimales
🎯 Solutions des exercices
Un solutionnaire possible pour chaque exercice est disponible en format vidéo avec des explications. Vous pouvez vous en servir pour comparer votre solution avec une solution possible jugée optimale et vous débloquer après un long moment bloqué sur un exercice (ex. 20 minutes) et après avoir utilisé le débogueur pour essayer par vous-même de trouver le problème.
Il est tout à fait normal que certains problèmes demandent du temps, de la réflexion, et parfois même un peu de frustration. C’est précisément dans ces moments d’effort que l’apprentissage s’ancre réellement.
Consulter un solutionnaire avant d’avoir tenté l’exercice par soi-même, ou le parcourir trop rapidement, revient à court-circuiter le processus d’apprentissage. Ce n’est pas simplement contre-productif, c’est pédagogiquement désastreux.
En sautant l’étape de la réflexion personnelle, on prive son cerveau de l’occasion de construire des connexions durables. Et à force de répéter ce réflexe, on risque de passer à côté des compétences essentielles, ce qui peut mener à des échecs plus tard, même si tout semble facile sur le moment. Alors oui, prenez le temps. L’erreur fait partie du jeu. C’est en cherchant, en tâtonnant, en doutant, qu’on devient réellement compétent. Le solutionnaire doit être un outil de validation, pas un raccourci.
🔨 Solution des exercices de création :
- Conversion Celsius → Fahrenheit
- Aire d'un rectangle
- Réutilisation de fonctions
- Énergie cinétique
- Force gravitationnelle
- Bonjour
- Refactorisation du code - Umbrella Corporation
- Refactorisation du code - Calcul de densité
- Une question de nanosecondes — solutionnaire.pdf
✏️ Solution des exercices de compréhension :
Le passage de fonctions en paramètre est une notion plus avancée qui dépasse le cadre de ce cours.
Elle n'est pas obligatoire pour réussir le cours, mais il s'agit d'un concept intéressant à explorer si vous êtes curieux.se.
Vous pouvez choisir de ne pas lire cette section si vous n'êtes pas assez à l'aise ou si vous êtes déjà assez mêlé.e comme ça!
Vous pouvez utiliser ou non cette notion pour réduire la quantité de code de la section Comparaison des performances du TP1.
En Python, une fonction est une valeur comme une autre (comme un int ou une str). Cela signifie que vous pouvez :
- Stocker une fonction dans une variable.
- Passer une fonction en paramètre à une autre fonction.
Par exemple, pour le point 1 :
def vers_kelvin(celsius):
return celsius + 273.15
conversion = vers_kelvin # Pas de parenthèses : on stocke la fonction elle-même
print(conversion(21.0)) # conversion contient une fonction : on peut l'appeler! Affiche 294.15
👉 Vous vous souvenez de l'erreur « oublier les parenthèses » de l'onglet Fonction? print(double) affichait <function double at 0x…>, c'est-à-dire la fonction elle-même.
Ici, on omet volontairement les parenthèses, justement pour manipuler la fonction sans l'appeler.
Imaginez un instrument de laboratoire qui lit une température en Celsius, mais qui doit pouvoir afficher le résultat dans différentes unités selon l'expérience en cours.
On commence par définir des fonctions simples qui font une seule tâche : la conversion.
def vers_kelvin(celsius):
return celsius + 273.15
def vers_fahrenheit(celsius):
return (celsius * 9/5) + 32
C'est ici que la magie opère. On crée une fonction qui accepte une valeur ET une autre fonction comme paramètre.
# Le paramètre 'transformation' recevra une fonction (voir l'appel de cette fonction à l'étape #3)
def afficher_resultat_labo(celsius, transformation):
"""
Affiche la température lue par l'instrument, convertie avec la fonction reçue.
Paramètres :
celsius (float) : Température lue en degrés Celsius
transformation (fonction) : Fonction de conversion qui reçoit une température en Celsius et retourne la valeur convertie
Retourne :
Rien (affiche le résultat)
"""
# transformation contient une fonction : on peut donc l'appeler avec des parenthèses
resultat = transformation(celsius)
print(f"L'instrument affiche : {resultat}")
👉 Remarquez la façon de documenter un paramètre qui reçoit une fonction : son type est fonction, et on décrit ce qu'elle doit recevoir et retourner.
Lors de l'appel, on passe la fonction de conversion sans les parenthèses.
Si vous mettez des parenthèses, vous passez le résultat de la fonction au lieu de la fonction elle-même!
temp_piece = 21.0
# On passe 'vers_kelvin' comme une simple valeur
print("--- Mode Scientifique ---")
afficher_resultat_labo(temp_piece, vers_kelvin)
# On change le comportement simplement en passant une autre fonction
print("--- Mode Américain ---")
afficher_resultat_labo(temp_piece, vers_fahrenheit)
La console affiche :
--- Mode Scientifique ---
L'instrument affiche : 294.15
--- Mode Américain ---
L'instrument affiche : 69.8
❌ Avec des parenthèses : afficher_resultat_labo(temp_piece, vers_kelvin(temp_piece))
vers_kelvin(temp_piece) est appelée tout de suite et donne 294.15. C'est donc un nombre qui est passé dans transformation, et la ligne transformation(celsius) essaie d'appeler ce nombre :
TypeError: 'float' object is not callable
not callable veut dire « ne peut pas être appelé » : on ne peut pas mettre des parenthèses après un nombre!
Cela permet de créer une fonction « générique » (afficher_resultat_labo()) qui ne change jamais, même si vous ajoutez 50 nouveaux types de conversions plus tard. On sépare la logique d'affichage de la logique de calcul.
🧪 Mini-défi : ajoutez une fonction vers_rankine () et affichez la température de la pièce en Rankine.
Avez-vous dû modifier afficher_resultat_labo?
def vers_kelvin(celsius):
return celsius + 273.15
def vers_fahrenheit(celsius):
return (celsius * 9/5) + 32
def afficher_resultat_labo(celsius, transformation):
resultat = transformation(celsius)
print(f"L'instrument affiche : {resultat}")
temp_piece = 21.0
# On passe 'vers_kelvin' comme une simple valeur
print("--- Mode Scientifique ---")
afficher_resultat_labo(temp_piece, vers_kelvin)
# On change le comportement simplement en passant une autre fonction
print("--- Mode Américain ---")
afficher_resultat_labo(temp_piece, vers_fahrenheit)
Les explications de cette section étaient-elles claires ?
La récursivité est une notion plus avancée qui dépasse le cadre de ce cours.
Elle n'est pas obligatoire pour réussir le cours, mais il s'agit d'un concept intéressant à explorer si vous êtes curieux.se.
Vous pouvez choisir de ne pas lire cette section si vous n'êtes pas assez à l'aise ou si vous êtes déjà assez mêlé.e comme ça!
La récursivité est une technique de programmation où une fonction s'appelle elle-même pour résoudre un problème.
Cela peut être utile pour résoudre des problèmes qui peuvent être décomposés en sous-problèmes similaires.
Exemple : la factorielle
La factorielle d'un nombre (notée ) est le produit de tous les entiers de jusqu'à 1 : .
💡 L'idée clé : . Pour calculer la factorielle de 5, il suffit de connaître celle de 4… qui se calcule à partir de celle de 3, et ainsi de suite!
Voici une fonction récursive qui calcule la factorielle d'un nombre :
(note : le code contient un if et un or, qui seront vus à la rencontre 4, mais c'est pour illustrer la récursivité)
def factorielle(n):
if n == 0 or n == 1: # Cas de base
return 1
else:
return n * factorielle(n - 1) # Appel récursif
print(factorielle(5)) # Affiche 120
Dans cet exemple, la fonction factorielle s'appelle elle-même avec un argument plus petit (n - 1) jusqu'à atteindre le cas de base (0 ou 1), où elle retourne 1.
🧩 Les 2 ingrédients d'une fonction récursive
- Un cas de base, qui arrête les appels (ici :
nvaut 0 ou 1). - Un appel qui se rapproche du cas de base (ici :
n - 1).
Une récursion sans cas de base, c'est comme une boucle while dont la condition ne devient jamais fausse (voir la rencontre 4).
Voici l'état de la pile d'appels pendant le calcul de factorielle(5) (le sommet est à droite) :
| Moment | Pile d'appels |
|---|---|
Appel de factorielle(5) | <module> → factorielle(5) |
factorielle(5) appelle factorielle(4) | <module> → factorielle(5) → factorielle(4) |
| … | … |
Appel de factorielle(1) : cas de base | <module> → factorielle(5) → factorielle(4) → factorielle(3) → factorielle(2) → factorielle(1) |
factorielle(1) retourne 1 | <module> → factorielle(5) → factorielle(4) → factorielle(3) → factorielle(2) |
factorielle(2) retourne 2 * 1 = 2 | <module> → factorielle(5) → factorielle(4) → factorielle(3) |
factorielle(3) retourne 3 * 2 = 6 | <module> → factorielle(5) → factorielle(4) |
factorielle(4) retourne 4 * 6 = 24 | <module> → factorielle(5) |
factorielle(5) retourne 5 * 24 = 120 | <module> |
👉 La pile se remplit à l'aller (les appels), puis se vide au retour (les valeurs retournées remontent).
🕵️ Au plus profond, il y a 5 variables n différentes dans la pile, une par appel (5, 4, 3, 2 et 1) : chaque appel a ses propres variables locales (voir l'onglet Portée). Dans une trace, chacune aurait sa colonne!
🐞 Pour l'observer vous-même : mettez un point d'arrêt à la ligne 7, puis appuyez sur Step Into à répétition. Regardez la pile d'appels grandir, puis diminuer.
RecursionErrorSi on oublie le cas de base, la fonction s'appelle à l'infini :
def factorielle(n):
return n * factorielle(n - 1) # ❌ Aucun cas de base!
print(factorielle(5))
Python arrête le programme après environ 1000 appels :
Traceback (most recent call last):
File "...\r03_recursion.py", line 4, in <module>
print(factorielle(5))
~~~~~~~~~~~^^^
File "...\r03_recursion.py", line 2, in factorielle
return n * factorielle(n - 1)
~~~~~~~~~~~^^^^^^^
[Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
👉 Le traceback est la pile d'appels : elle est si haute que Python la résume (Previous line repeated 996 more times).
⚠️ Même avec le cas de base, factorielle(-1) donne la même erreur : en soustrayant 1 à partir de -1, on n'atteint jamais 0 ou 1! Il faudrait valider le paramètre avec un raise (voir la rencontre 4).
Tout ce qu'on fait par récursivité peut aussi se faire avec une boucle (rencontres 4 et 5). C'est l'approche utilisée dans ce cours.
Les explications de cette section étaient-elles claires ?