Définition des fonctions
Les fonctions permettent de structurer le code en modules réutilisables. Elles isolent la logique en blocs gérables, évitant la duplication de code et assurant la cohérence. Une fonction est généralement conçue pour effectuer une tâche spécifique.
Syntaxe de déclaration
En Python, les fonctions sont définies avec le mot-clé def. La structure de base est la suivante :
def nom_fonction(paramètres):
corps_de_la_fonction
Règles de nommage : le nom doit commencer par une lettre ou un underscore, peut contenir des lettres, chiffres ou underscores, et ne doit pas être un mot réservé. Les noms sont sensibles à la casse.
Fonctions vs Procédures
Les fonctions et procédures sont des entités appelables. Une fonction peut retourner une valeur, tandis qu'une procédure n'en retourne pas. En Python, les procédures sont traitées comme des fonctions qui retournent implicitement None.
Par exemple :
def salut():
print("Bonjour")
resultat = salut()
print(resultat) # Affiche None
Le tableau suivant résume le comportement des retours :
| Nombre d'objets retournés | Objet réel retourné |
|---|---|
| 0 | None |
| 1 | objet |
| > 1 | tuple |
Types de fonctions
Les fonctions se classent en quatre catégories selon qu'elles prennent des paramètres ou retournent une valeur :
- Sans paramètre, sans retour
- Sans paramètre, avec retour
- Avec paramètre, sans retour
- Avec paramètre, avec retour
Remarque : évitez d'utiliser print() dans les fonctions sauf pour le débogage, car les fonctions sont orientées vers la fonctionnalité.
Exemple sans paramètre ni retour
def afficher_menu():
print("---------")
print("Menu du jour")
print("1. Salade")
print("2. Soupe")
print("---------")
afficher_menu()
Exemple sans paramètre mais avec retour
def obtenir_température():
# Simulation de données
return 22
temp = obtenir_température()
print(f"Température actuelle : {temp}°C")
Une fonction retourne une valeur via return. L'exécution s'arrête à la première instruction return.
Exemple avec paramètre et retour
def somme_n(n):
total = 0
compteur = 1
while compteur <= n:
total += compteur
compteur += 1
return total
resultat = somme_n(100)
print(f"Somme de 1 à 100 : {resultat}")
Dans cet exemple, n reçoit la valeur 100. La boucle calcule la somme, et le résultat est retourné via return.
Appel de fonctions
Pour appeler une fonction, utilisez son nom suivi de parenthèses avec les arguments nécessaires. Le nombre et l'ordre des arguments doivent correspondre à la définition. Si la fonction retourne une valeur, elle peut être stockée dans une variable.
L'opérateur d'appel est la paire de parenthèses. Sans parenthèses, on référence la fonction sans l'exécuter.
def dire_bonjour():
print("Salut")
dire_bonjour() # Appel de la fonction
print(dire_bonjour) # Référence à la fonction
Ordre d'exécution
Les fonctions sont exécutées dans l'ordre de leur appel. Si plusieurs fonctions ont le même nom, la dernière définition est prise en compte. Les fonctions imbriquées sont appelées à l'intérieur d'autres fonctions.
def premiere():
print("Première")
def deuxieme():
print("Deuxième")
premiere() # Affiche "Première"
deuxieme() # Affiche "Deuxième"
Création de fonctions avec def
La déclaration def crée une fonction. Elle comprend un nom, des paramètres optionenls, une chaîne de documentation et le corps. La fonction peut contenir plusieurs instructions return, mais s'arrête à la première exécutée. Sans return, elle retourne None.
def additionner(a, b):
"""Additionne deux nombres et retourne le résultat."""
somme = a + b
return somme
Référence antérieure
Une fonction ne peut pas être appelée avant d'être déclarée. Cependant, une fonction peut appeler une autre fonction déclarée plus tard dans le code, à condition que l'appel initial se produise après la déclaration de toutes les fonctions.
def fonction_a():
print("Dans A")
fonction_b()
def fonction_b():
print("Dans B")
fonction_a() # Fonctionne car fonction_b est déjà déclarée lors de l'appel
Attributs des fonctions
Les fonctions possèdent des attributs, comme la documentation accessible via __doc__. On peut ajouter des attributs personnalisés.
def ma_fonction():
"""Documentation de la fonction."""
pass
ma_fonction.version = 1.0
print(ma_fonction.__doc__)
print(ma_fonction.version)
Fonctions internes
Il est possible de définir des fonctions à l'intérieur d'autres fonctions, appelées fonctions imbriquées. Ces foncitons internes ne sont accessibles que dans leur portée.
def externe():
def interne():
print("Interne appelée")
print("Externe appelée")
interne()
externe() # Affiche "Externe appelée" puis "Interne appelée"
# interne() # Erreur : interne n'est pas définie ici
Paramètres des fonctions
Les paramètres sont définis lors de la déclaration de la fonction (paramètres formels) et reçoivent les valeurs lors de l'appel (arguments réels). Ils sont virtuels et n'existent que pendant l'exécution de la fonction.
Paramètres positionnels
Les arguments sont passés dans l'ordre défini. Le module sys permet de récupérer les arguments de la ligne de commande via sys.argv.
import sys
print(sys.argv) # Affiche les arguments passés au script
Paramètres par défaut
Les paramètres par défaut permettent d'omettre des arguments lors de l'appel. Les paramètres positionnels doivent précéder les paramètres par défaut.
def afficher_etoiles(nb=30):
print("*" * nb)
afficher_etoiles() # Utilise la valeur par défaut
afficher_etoiles(40) # Passe 40 comme argument
Paramètres nommés
Les paramètres nommés permettent de spécifier les arguments par leur nom, sans respecter l'ordre. Ils peuvent être utilisés avec des valeurs par défaut.
def afficher_infos(nom, age):
print(f"{nom} a {age} ans.")
afficher_infos(age=25, nom="Alice") # Les arguments sont nommés
Groupes de paramètres
Python supporte les arguments variables avec *args pour les tuples et **kwargs pour les dictionnaires. Ils doivent suivre les paramètres positionnels et par défaut.
def demo_arguments(p1, p2, *args, **kwargs):
print(f"p1 = {p1}")
print(f"p2 = {p2}")
print(f"args = {args}")
print(f"kwargs = {kwargs}")
demo_arguments(1, 2, 3, 4, cle="valeur")
Pour passer une séquence comme arguments individuels, utilisez * devant la séquence. Pour un dictionnaire, utilisez **.
def calculer_total(*nombres):
return sum(nombres)
liste = [1, 2, 3]
print(calculer_total(*liste)) # Décompose la liste en arguments