⚙️ Création de fonctions
🏗️ en construction 🏗
- Fonction simple
- Paramètres
- Retour
- Portée
- Pile d'appels
- Commentaires
- Exercices
- *Récursivité*
Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique.
Elle est définie à l'aide du mot-clé def, suivi du nom de la fonction, de parenthèses et d'un :.
Le code à l'intérieur de la fonction est indenté avec une tabulation (touche TAB).
En Python, cette indentation est essentielle pour délimiter le bloc de code de la fonction.
def saluer():
print("Bonjour!")
Dans cet exemple, nous avons défini une fonction nommée saluer qui affiche "Bonjour!" lorsqu'elle est appelée.
Une fois définie, la fonction peut être appelée à tout moment dans le code en utilisant son nom suivi de parenthèses.
saluer() # Appel de la fonction
Appeler une fonction se fait en écrivant son nom suivi de parenthèses.
Lorsqu'une fonction est appelée, le code à l'intérieur de la fonction est exécuté.
Les fonctions peuvent accepter des paramètres, qui sont des valeurs d'entrée que la fonction peut utiliser pour
effectuer son travail.
Lorsqu'une fonction est appelée, les arguments fournis sont associés aux paramètres définis dans la fonction.
def saluer(nom):
print(f"Bonjour, {nom}!")
saluer("Alice") # Affiche "Bonjour, Alice!"
Dans cet exemple, la fonction saluer prend un paramètre nom et affiche un message de salutation en utilisant
ce paramètre.
Il est possible de définir une valeur par défaut pour un paramètre.
Si aucun argument n'est fourni lors de l'appel de la fonction, la valeur par défaut sera utilisée.
def saluer(nom="inconnu"):
print(f"Bonjour, {nom}!")
saluer() # Affiche "Bonjour, inconnu!"
saluer("Alice") # Affiche "Bonjour, Alice!"
Dans cet exemple, si saluer est appelée sans argument, nom prendra la valeur par défaut "inconnu".
Une fonction peut retourner une valeur à l'aide du mot-clé return.
Lorsqu'une fonction est appelée, elle exécute son code et renvoie la valeur spécifiée par return à l'endroit où elle a été appelée.
Si aucune valeur n'est spécifiée, la fonction renvoie la valeur None par défaut.
def carre(x):
return x * x
resultat = carre(5)
print(resultat) # Affiche 25
Dans cet exemple, la fonction carre prend un paramètre x, calcule son carré et le retourne.
La valeur retournée est ensuite stockée dans la variable resultat.
Une fonction peut aussi retourner plusieurs valeurs en les séparant par des virgules.
Lorsqu'une fonction retourne plusieurs valeurs, elles sont renvoyées sous forme de tuple (une structure de données que nous verrons plus tard).
def diviser(a, b):
quotient = a / b
reste = a % b
return quotient, reste
q, r = diviser(10, 3)
print(f"Quotient: {q}, Reste: {r}") # Affiche "Quotient: 3.3333333333333335, Reste: 1"
Dans cet exemple, la fonction diviser retourne à la fois le quotient et le reste de la division.
Ces valeurs sont ensuite assignées à deux variables distinctes, séparées par une virgule lors de l'appel de la fonction.
La portée d'une variable détermine où cette variable peut être accédée dans le code.
En Python, il existe deux types principaux de portée : locale et globale.
- Portée locale : Une variable définie à l'intérieur d'une fonction est locale à cette fonction et ne peut pas être accédée en dehors de celle-ci.
- Portée globale : Une variable définie en dehors de toute fonction est globale et peut être accédée depuis n'importe quelle fonction dans le même module.
x = 10 # Variable globale
def ma_fonction():
y = 5 # Variable locale
print(f"Valeur locale y: {y}")
print(f"Valeur globale x: {x}")
ma_fonction()
print(f"Valeur globale x: {x}")
# print(y) # Cela provoquerait une erreur car y n'est pas défini ici
Dans cet exemple, x est une variable globale accessible à l'intérieur de ma_fonction, tandis que y est une variable locale accessible uniquement à l'intérieur de cette fonction.
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.
Lorsqu'une fonction est appelée, elle est ajoutée à la pile d'appels.
La pile d'appels est une structure de données qui suit le principe LIFO (Last In, First Out), ce qui signifie que la dernière fonction appelée est la première à être terminée.
Cela permet 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.
def fonction_a():
print("Fonction A")
fonction_b()
def fonction_b():
print("Fonction B")
fonction_a()
Dans cet exemple, lorsque fonction_a est appelée, elle appelle fonction_b, qui est ajoutée à la pile d'appels.
Une fois que fonction_b a terminé son exécution, le contrôle revient à fonction_a.
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
Pour entrer dans les fonctions appelées en mode débogage, il faut 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),
- 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.
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 :
Lorsque vous faite une trace d'un code avec des appels de fonctions, il est nécessaire de noter la pile d'appels et les variables locales à chaque étape.
Le débogueur est alors le meilleur outil pour valider votre trace... sauf en examen!
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, ou bien : - des triples guillemets
"""(ou''') pour commenter un bloc de lignes continu.
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.
Formule :
E_c = 0.5 * m * v^2
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)
125.0
"""
nb_joute = 0.5 * masse * pow(vitesse,2)
return nb_joute
# 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("Énergie cinétique de l'objet 1 :", objet1, "Joules")
print("Énergie cinétique de l'objet 2 :", objet2, "Joules")
Les lignes 3 à 19 montrent un exemple de commentaire de bloc utilisant des triples guillemets pour expliquer en détail la fonction energie_cinetique.
Elles sont ignorées par Python lors de l'exécution du code.
Il en est de même pour les lignes 1, 23 et 27 qui sont des commentaires sur une seule ligne, ainsi que tout ce qui se trouve à droite du # à la ligne 2.
✏️ Exercices de compréhension
Sans exécuter le code, qu'affichera le programme ci-dessous?
Faites la trace de l'exécution.
En situation d'examen, ce type de question serait à faire sans l'ordinateur.
def fonction_lineaire(a, x, b) :
print("appel de la fonction")
resultat = a * x + b
return resultat
x = 5
y = 10
z = 2
r1 = fonction_lineaire(x, z, y)
x -= 3
r2 = fonction_lineaire(x, y, z) # Attention à l'ordre des paramètres
print(r1, r2)
Validez votre trace en exécutant le code dans un script en mode débogage.
Soit le code suivant :
def calcul_complexe(a, b, c):
x = a ** b
y = c * (b - a)
return a ** b + c * (b - a)
x = 5
calcul_complexe(3, 5, 7)
print(x)
Combien vaut x dans calcul_complexe?
Dans le script principal?
C'est le même x?
Faites la trace de l'exécution de ce code :
def triple(x):
print("appel de triple")
return 3 * x
def double_et_triple(x):
print("appel de double_et_triple")
return 2 * x + triple(x)
val = 4
res = double_et_triple(val)
print(res)
Validez votre trace en l'exécutant en mode débogage.
Faites la trace de l'exécution de ce code :
def ajoute_cinq(x):
print("appel de ajoute_cinq")
return x + 5
def carre(x):
print("appel de carre")
return x * x
def calcul_final(a, b):
print("appel de calcul_final")
return carre(a) + ajoute_cinq(b)
x = 2
y = 3
resultat = calcul_final(x, y)
print(resultat)
Validez votre trace en l'exécutant en mode débogage.
🔨 Exercices de création
Pour les exercices de cette section, vous devez créer des fichiers .py dans un nouveau projet PyCharm.
Écris une fonction dire_bonjour() qui affiche simplement le message "Bonjour!" à l’écran.
Ensuite, modifie la fonction pour qu’elle prenne un paramètre prenom et affiche :
Bonjour, Alice!
lorsqu’on appelle dire_bonjour("Alice").
É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
Exemples d’appels attendus :
print(celsius_vers_fahrenheit(0)) # 32.0
print(celsius_vers_fahrenheit(100)) # 212.0
Écrivez une fonction aire_rectangle(longueur, largeur) qui calcule et retourne l’aire d’un rectangle.
Puis, appellez la fonction pour afficher l’aire d’un rectangle de 5 m par 3 m.
-
Écrivez une fonction
aire_rectangle(longueur, largeur)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.
- Testez vos fonctions en affichant :
- l’aire d’un rectangle de 5 × 3
- le volume d’un prisme de 5 × 3 × 4
Objectif : pratiquer la décomposition d’un problème en plusieurs fonctions réutilisables.
Écrivez une fonction permettant de calculer l'énergie cinétique en utilisant la formule :
où est la masse et la vitesse.
Votre fonction doit se trouver dans un module nommé sciences_nature (donc dans un fichier nommé sciences_nature.py).
Dans un script Python (un autre fichier .py) :
- importez le module,
- appelez votre fonction avec différentes valeurs,
- affichez les résultats.
Dans le même module créé à l'exercice précédent, ajoutez une fonction permettant de calculer la force gravitationnelle en utilisant la loi de la gravitation universelle de Newton doit la formule est :
où :
- (constante gravitationnelle),
- et sont les masses en kg,
- est la distance en mètres.
Dans un script Python (ça peut être le même qu'à l'exercice précédent) :
- importez le module,
- appelez votre fonction avec différentes valeurs,
- affichez les résultats.
La récursivité est un concept plus avancé qui dépasse le cadre de ce cours et n'est pas obligatoire pour réussir le cours, mais qui peut être intéressant à explorer si vous êtes curieu.x.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.
Voici un exemple simple de fonction récursive qui calcule la factorielle d'un nombre :
(note : le code contient un if que l'on n'a pas encore vu, 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 réduit jusqu'à atteindre le cas de base (0 ou 1), où elle retourne 1.
La pile d'appels se remplit à chaque appel récursif, puis se vide lorsque les appels sont résolus.
Si vous êtes curieu.x.se vous pouvez exécuter ce code en mode débogage et observer la pile d'appels pour voir comment elle évolue avec chaque appel récursif.