def salutation():
    print("Bonjour à tous")

resultat = salutation()  # Appel de la fonction
print(resultat)  # Affiche None car aucune valeur n'est retournée

Une fonction Python peut retourner une valeur ou un objet. Lorsqu'elle retourne un conteneur comme une liste ou un tuple, cela peut sembler être plusieurs retours distincts.

def obtenir_liste():
    return ['a', 100, -5.5]

def obtenir_tuple():
    return 'b', [42, 'Python'], "Monty"
# La fonction obtenir_tuple retourne un tuple, ce qui simule plusieurs valeurs

Il est recommandé de documenter les fonctions avec des chaînes de documentation (docstirngs). La convention consiste en une chaîne multiligne, la première ligne en majuscule se terminant par un point, suivie d'une ligne vide et d'une description détaillée.

def calculer_total():
    """
    calculer_total() - Calcule la somme de valeurs.
    Cette fonction additionne les éléments fournis.
    """
    # Corps de la fonction

Les paramètres d'une fonction se divisent en paramètres formels (définition) et paramètres actuels (appel). Python offre quatre types de paramètres :

Paramètres positionnels ou par mot-clé

C'est le type par défaut. Les arguments peuvent être passés par position ou par mot-clé.

def afficher_info(prenom, nom="Dupont"):
    print(f"{prenom} {afficher_info}")

# Appels valides
afficher_info("Jean")  # Par position
afficher_info(nom="Martin", prenom="Pierre")  # Par mot-clé
afficher_info("Paul", nom="Durand")  # Mixte

Paramètres uniquement positionnels

Certains fonctions intégrées n'acceptent que des arguments positionnels.

# abs() n'accepte pas de mots-clés
print(abs(-5))  # Fonctionne
# abs(valeur=5)  # Erreur TypeError

Paramètres en nombre arbitraire positionnels

Avec un astérisque (*), les arguments supplémentaires sont collectés dans un tuple.

def collecter_args(premier, second, *supplements):
    print(premier, second, supplements)

collecter_args("x", "y", 1, 2, 3)  # Affiche x y (1, 2, 3)
# Pour passer un tuple existant, utiliser *
args_tuple = (1, 2, 3)
collecter_args("x", "y", *args_tuple)  # Décompacte le tuple

Paramètres en nombre arbitraire par mot-clé

Avec deux astérisques (**), les arguments supplémentaires sont collectés dans un dictionnaire.

def collecter_kwargs(premier, second, **supplements):
    print(premier, second, supplements)

collecter_kwargs("a", "b", x=1, y=2)  # Affiche a b {'x': 1, 'y': 2}
# Pour passer un dictionnaire existant, utiliser **
dict_args = {'x': 1, 'y': 2}
collecter_kwargs("a", "b", **dict_args)  # Décompacte le dictionnaire

Lors de la définision, l'ordre des paramètres doit respecter : paramètres positionnels ou par mot-clé (sans valeur par défaut d'abord), puis *args, enfin **kwargs. Chaque type ne peut apparaître qu'une fois.

def fonction_complete(p1, p2="défaut", *args_sup, **kwargs_sup):
    print(f"p1={p1}, p2={p2}, args={args_sup}, kwargs={kwargs_sup}")

fonction_complete(1)
fonction_complete(1, 2, 3, 4, clé="valeur")

Passage de paramètres : valeur ou référence ?

En Python, les arguments sont passés par référence d'objet. Les objets mutables comme les listes peuvent être modifiés dans la fonction, mais la réaffectation ne change pas la variable globale sans global.

donnees = [10, 20, 30]
def modifier_liste(lst):
    lst.append(40)  # Modifie l'objet mutable

modifier_liste(donnees)
print(donnees)  # Affiche [10, 20, 30, 40]

def reassigner(lst):
    lst = [100, 200]  # Crée une nouvelle liste locale

reassigner(donnees)
print(donnees)  # Toujours [10, 20, 30, 40]

Variables locales et globales

Les variables définies dans une fonction sont locales. Pour modifier une variable globale, utilisez l'nistruction global, mais cela est déconseillé pour maintenir la modularité.

compteur = 0
def incrementer():
    global compteur
    compteur += 1

incrementer()
print(compteur)  # Affiche 1

Expressions lambda

Les lambdas sont des fonctions anonymes courtes, définies avec le mot-clé lambda, utiles pour des opérations simples.

triple = lambda n: n * 3
print(triple(7))  # Affiche 21