Fonctions Python

Une fonction est un bloc de code nommé et réutilisable qui effectue une tâche spécifique. Les fonctions vous permettent d'écrire la logique une seule fois et de l'appeler depuis n'importe où dans votre programme — ce qui rend votre code plus court, plus lisible et plus simple à tester. Ce chapitre couvre tout ce dont vous avez besoin pour travailler avec confiance avec les fonctions Python : définition, paramètres, valeurs de retour, arguments par défaut, *args et **kwargs, portée, docstrings, annotations de type, récursion et utilisation des fonctions comme objets de première classe.

Définir une fonction

Utilisez le mot-clé def, un nom, des parenthèses et deux-points. Le corps est indenté d'un niveau.

def greet(name):
    print("Hello, " + name)

La fonction n'est pas exécutée tant que vous ne l'appelez pas. Rien ne se passe au moment de la définition, sauf que Python stocke l'objet fonction sous le nom donné.

Appeler une fonction

Passez des arguments à l'intérieur des parenthèses en faisant correspondre les noms de paramètres de la définition.

Valeurs de retour

Une fonction peut renvoyer un résultat à l'appelant avec l'instruction return. Sans return, Python renvoie None.

def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 8

Une fois que return s'exécute, la fonction s'arrête immédiatement — tout code après lui dans le même corps de fonction est inaccessible.

Retourner plusieurs valeurs

Python vous permet de retourner plusieurs valeurs sous forme de tuple, que vous pouvez décompresser côté appelant.

import math

def circle_stats(radius):
    area = math.pi * radius ** 2
    circumference = 2 * math.pi * radius
    return area, circumference

area, circ = circle_stats(5)
print(round(area, 2))   # 78.54
print(round(circ, 2))   # 31.42

Paramètres et arguments

Python prend en charge plusieurs façons de passer des arguments.

Arguments positionnels

Les arguments sont associés aux paramètres dans l'ordre.

def describe(name, age):
    print(name, "is", age, "years old")

describe("Bob", 25)   # Bob is 25 years old

Arguments nommés

Vous pouvez passer des arguments par nom, dans n'importe quel ordre.

describe(age=25, name="Bob")   # Bob is 25 years old

Valeurs de paramètres par défaut

Fournissez une valeur de repli utilisée lorsque l'appelant omet cet argument.

def greet(name="World"):
    print("Hello, " + name)

greet()         # Hello, World
greet("Alice")  # Hello, Alice

Attention : n'utilisez jamais un objet mutable (liste, dict) comme valeur par défaut — il est créé une seule fois au moment de la définition et partagé entre tous les appels. Utilisez None comme valeur par défaut et créez l'objet à l'intérieur du corps à la place.

# Correct pattern for a mutable default
def append_item(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

Arguments positionnels arbitraires (*args)

Préfixez un nom de paramètre avec * pour collecter n'importe quel nombre d'arguments positionnels dans un tuple.

def total(*numbers):
    return sum(numbers)

print(total(1, 2, 3))    # 6
print(total(10, 20))     # 30

Arguments nommés arbitraires (**kwargs)

Préfixez avec ** pour collecter n'importe quel nombre d'arguments nommés dans un dictionnaire.

def describe_person(**info):
    for key, value in info.items():
        print(key + ": " + str(value))

describe_person(name="Alice", age=30, city="Paris")
# name: Alice
# age: 30
# city: Paris

Combiner les types de paramètres

Lorsque vous mélangez des types de paramètres, l'ordre doit être : positionnels, *args, mots-clés uniquement, **kwargs.

def log(level, *messages, separator=" | ", **meta):
    print(level.upper(), separator.join(messages), meta)

log("info", "started", "ready", separator=" — ", version="1.0")
# INFO started — ready {'version': '1.0'}

Portée des variables

Les règles de portée de Python suivent la règle LEGB : Local → Englobant → Global → Intégré.

Une variable définie à l'intérieur d'une fonction est locale — elle ne peut pas être accédée à l'extérieur.

def my_func():
    x = 10          # local to my_func
    print(x)

my_func()
# print(x)  # NameError: name 'x' is not defined

Pour lire ou modifier une variable globale à l'intérieur d'une fonction, déclarez-la avec global.

x = 10

def change_x():
    global x
    x = 20

change_x()
print(x)   # 20

Utilisez global avec parcimonie — les fonctions qui dépendent d'un état global sont plus difficiles à tester et à réutiliser. Consultez Python Variables et Global Variables pour une vue approfondie de la portée.

Docstrings

Une docstring est un littéral de chaîne placé immédiatement après la ligne def. Elle documente ce que la fonction fait, ce qu'elle accepte et ce qu'elle retourne. Python la stocke dans l'attribut __doc__ de la fonction et des outils comme help() l'affichent.

def add(a, b):
    """Return the sum of a and b.

    Args:
        a: First number.
        b: Second number.

    Returns:
        The sum as a number.
    """
    return a + b

print(add.__doc__)
# Return the sum of a and b.
# ...

Annotations de type

Les annotations de type (PEP 484) vous permettent d'annoter les types des paramètres et de retour. Python ne les applique pas à l'exécution, mais les éditeurs, les linters et mypy les utilisent pour détecter les bogues tôt.

def multiply(a: float, b: float) -> float:
    return a * b

print(multiply(3, 4))      # 12
print(multiply(2.5, 2.0))  # 5.0

Récursion

Une fonction peut s'appeler elle-même. C'est ce qu'on appelle la récursion et c'est utile pour les problèmes avec une structure naturellement récursive (arbres, factorielles, etc.). Chaque fonction récursive a besoin d'un cas de base qui arrête la récursion.

def factorial(n):
    if n == 0 or n == 1:   # base case
        return 1
    return n * factorial(n - 1)

print(factorial(5))   # 120
print(factorial(0))   # 1

Python limite la profondeur de récursion (1000 par défaut) pour éviter les débordements de pile. Pour une récursion profonde, préférez une approche itérative ou utilisez sys.setrecursionlimit.

Fonctions comme objets de première classe

En Python, les fonctions sont des objets. Vous pouvez les stocker dans des variables, les passer comme arguments et les retourner depuis d'autres fonctions.

def apply(func, value):
    return func(value)

def double(n):
    return n * 2

print(apply(double, 7))   # 14

C'est la base des fonctions lambda, des fonctions d'ordre supérieur et des décorateurs.

Fonctions intégrées vs. fonctions définies par l'utilisateur

Python est livré avec de nombreuses fonctions intégrées — print(), len(), range(), sum(), sorted() — qui sont toujours disponibles sans importation. Les fonctions définies par l'utilisateur sont celles que vous écrivez avec def. Les deux suivent une syntaxe d'appel identique.

Bonnes pratiques

• Nommez les fonctions comme des verbes : calculate_tax() est plus clair que tax().
• Faites une seule chose : une fonction qui valide, enregistre et envoie un e-mail est en réalité trois fonctions en attente d'être créées.
• Écrivez une docstring : même une seule phrase décrivant le but est précieuse.
• Évitez les effets de bord dans la mesure du possible : les fonctions qui retournent des valeurs et ne modifient aucun état global sont plus faciles à tester.
• Gardez les signatures courtes : plus de trois ou quatre paramètres est un signal pour regrouper les données liées dans une classe ou un dict.
• Utilisez les annotations de type : elles servent de documentation légère et permettent l'analyse statique.

Pratique