> Le guide complet de la fonction Python : def, arguments, *args/**kwargs, return, portée, lambda, docstrings et annotations de type, avec des exemples de code.

*Source : https://coder-studio.com/tutoriels/fonctions-python/*

---

[// Python](https://coder-studio.com/tutoriels/)

# Les fonctions en Python : tout ce qu'il faut savoir

Par **Kévin Papot** · publié le 12 octobre 2025

Une **fonction Python** est un bloc de code réutilisable, nommé, qui accomplit une tâche précise. Bien maîtrisées, les fonctions rendent votre code plus lisible, plus court et plus facile à tester. Ce guide couvre de façon exhaustive tout ce qu’il faut savoir : définition avec `def`, les différents types d’arguments, la valeur de retour, la portée des variables, les fonctions `lambda`, les docstrings et les annotations de type.

## Définir une fonction avec def

On déclare une fonction avec le mot-clé `def`, suivi du nom, de parenthèses et de deux-points. Le corps est indenté.

```
def saluer():
    print("Bonjour !")

saluer()   # appelle la fonction -> Bonjour !
```

Une fonction n’exécute rien tant qu’on ne l’**appelle** pas avec ses parenthèses. Le nom suit la convention `snake_case` (minuscules et underscores).

## Les paramètres et arguments

Une fonction peut recevoir des données via ses paramètres.

```
def saluer(nom):
    print(f"Bonjour {nom} !")

saluer("Alice")   # Bonjour Alice !
```

On parle de _paramètre_ dans la définition (`nom`) et d’_argument_ lors de l’appel (`"Alice"`). Une fonction peut prendre plusieurs paramètres, séparés par des virgules.

### Arguments positionnels

Les arguments positionnels sont transmis dans l’ordre des paramètres.

```
def diviser(a, b):
    return a / b

print(diviser(10, 2))   # 5.0 : a=10, b=2
```

L’ordre compte : `diviser(2, 10)` donnerait `0.2`.

### Arguments nommés (keyword arguments)

On peut préciser le nom du paramètre à l’appel, ce qui libère de l’ordre et clarifie l’intention.

```
def presenter(prenom, ville):
    print(f"{prenom} habite à {ville}")

presenter(ville="Lyon", prenom="Marie")
# Marie habite à Lyon
```

### Valeurs par défaut

Un paramètre peut avoir une valeur par défaut, utilisée si l’argument est omis.

```
def puissance(base, exposant=2):
    return base ** exposant

print(puissance(5))       # 25 (exposant vaut 2 par défaut)
print(puissance(5, 3))    # 125
```

Règle importante : **ne jamais** utiliser un objet mutable (liste, dictionnaire) comme valeur par défaut. Écrivez `def f(items=None)` puis `if items is None: items = []` à l’intérieur, sinon la valeur est partagée entre tous les appels.

### \*args : nombre variable d’arguments positionnels

`*args` capture un nombre indéfini d’arguments positionnels sous forme de tuple.

```
def somme(*nombres):
    total = 0
    for n in nombres:
        total += n
    return total

print(somme(1, 2, 3))        # 6
print(somme(4, 5, 6, 7, 8))  # 30
```

### \*\*kwargs : nombre variable d’arguments nommés

`**kwargs` capture les arguments nommés dans un dictionnaire.

```
def profil(**infos):
    for cle, valeur in infos.items():
        print(f"{cle} : {valeur}")

profil(nom="Durand", age=30, ville="Nantes")
# nom : Durand
# age : 30
# ville : Nantes
```

On combine souvent tout : `def f(a, b, *args, **kwargs)`. L’ordre à respecter dans la signature est : positionnels, `*args`, arguments nommés, puis `**kwargs`.

## La valeur de retour (return)

`return` renvoie un résultat et met fin à l’exécution de la fonction.

```
def carre(x):
    return x * x

resultat = carre(4)   # 16
```

Sans `return`, une fonction renvoie implicitement `None`. On peut renvoyer plusieurs valeurs d’un coup grâce aux tuples :

```
def minmax(nombres):
    return min(nombres), max(nombres)

petit, grand = minmax([3, 1, 7, 2])
print(petit, grand)   # 1 7
```

Tout code placé après un `return` exécuté est ignoré ; c’est pratique pour un retour anticipé (`if erreur: return None`).

## La portée des variables (scope)

Une variable créée dans une fonction est **locale** : elle n’existe pas à l’extérieur.

```
def compteur():
    x = 10      # variable locale
    return x

compteur()
# print(x) provoquerait une NameError
```

Pour modifier une variable globale depuis une fonction, on utilise le mot-clé `global`, mais c’est généralement déconseillé : préférez renvoyer une valeur.

```
total = 0

def ajouter(n):
    global total
    total += n

ajouter(5)
print(total)   # 5
```

Python applique la règle **LEGB** (Local, Enclosing, Global, Built-in) pour résoudre le nom d’une variable. Si vous découpez déjà votre programme en fonctions, jetez un œil à nos [listes en Python](https://coder-studio.com/tutoriels/listes-python/) souvent passées en argument.

## Les fonctions lambda

Une `lambda` est une fonction anonyme, tenant sur une seule ligne. Elle sert pour de petites opérations, notamment comme paramètre `key`.

```
double = lambda x: x * 2
print(double(6))   # 12

# Trier une liste de tuples par le second élément
paires = [(1, "b"), (2, "a"), (3, "c")]
paires.sort(key=lambda p: p[1])
# [(2, 'a'), (1, 'b'), (3, 'c')]
```

Une `lambda` ne contient qu’une seule expression, dont le résultat est automatiquement renvoyé. Pour une logique plus complexe, écrivez une vraie fonction `def`.

## Les docstrings

Une docstring documente la fonction. Placée juste après la ligne `def`, entre triples guillemets, elle est accessible via `help()` ou l’attribut `__doc__`.

```
def moyenne(nombres):
    """Renvoie la moyenne d'une liste de nombres.

    Args:
        nombres (list): la liste de valeurs numériques.

    Returns:
        float: la moyenne arithmétique.
    """
    return sum(nombres) / len(nombres)

print(moyenne.__doc__)
```

Documenter ses fonctions est une excellente habitude, surtout dans un projet partagé.

## Les annotations de type

Les annotations précisent les types attendus des paramètres et du retour. Elles n’imposent rien à l’exécution mais aident la lecture et les outils comme `mypy`.

```
def additionner(a: int, b: int) -> int:
    return a + b

def saluer(nom: str, majuscule: bool = False) -> str:
    message = f"Bonjour {nom}"
    return message.upper() if majuscule else message
```

Le `-> int` indique le type de retour. Ces indices de type rendent votre code auto-documenté et facilitent la détection d’erreurs avant même de lancer le programme.

## Bonnes pratiques

-   Une fonction = **une** responsabilité claire.
-   Un nom explicite (un verbe : `calculer_total`, `est_valide`).
-   Éviter les fonctions trop longues : découpez.
-   Renvoyer plutôt que de modifier des variables globales.
-   Documenter avec une docstring dès que la logique n’est pas triviale.

## Conclusion

Vous connaissez maintenant l’essentiel des fonctions Python : `def`, arguments positionnels et nommés, valeurs par défaut, `*args`/`**kwargs`, `return`, portée, `lambda`, docstrings et annotations de type. Ces briques sont le socle de tout programme structuré. L’étape suivante logique consiste à regrouper des fonctions et des données au sein d’objets.

### À lire ensuite

-   [Les classes en Python : la POO expliquée](https://coder-studio.com/tutoriels/classes-python-poo/)
-   [Les listes en Python](https://coder-studio.com/tutoriels/listes-python/)
-   [Apprendre Python en 2026](https://coder-studio.com/tutoriels/apprendre-python/)