Définition d'un argument en Python
En Python, un argument est une valeur que vous transmettez à une fonction ou une méthode lors de son appel. Les arguments permettent de fournir des données d'entrée à une fonction pour qu'elle puisse effectuer son traitement. Ils représentent les informations concrètes que vous passez à une fonction, par opposition aux paramètres, qui sont les variables définies dans la signature de la fonction avec le mot-clé def.
Si vous souhaitez maîtriser pleinement les fonctions et les arguments en Python, notre formation complète sur Python vous guidera pas à pas dans l'apprentissage de ces concepts fondamentaux.
La distinction entre argument et paramètre est subtile mais importante : un paramètre est la variable dans la définition de la fonction, tandis qu'un argument est la valeur réelle passée lors de l'appel.
# Ici, 'nom' est un paramètre
def saluer(nom):
print(f"Bonjour, {nom} !")
# Ici, "Alice" est un argument
saluer("Alice")
# Affiche : Bonjour, Alice !Cette distinction est essentielle pour comprendre le fonctionnement des fonctions en Python et pour communiquer efficacement avec d'autres développeurs.
Les différents types d'arguments en Python
Python offre une grande flexibilité dans la manière dont vous pouvez passer des arguments à une fonction. Comprendre chaque type d'argument vous permettra d'écrire un code plus lisible, plus maintenable et plus puissant.
Arguments positionnels
Les arguments positionnels sont les plus simples et les plus courants. Ils sont transmis dans l'ordre exact dans lequel les paramètres sont définis dans la signature de la fonction. L'ordre compte : le premier argument correspond au premier paramètre, le deuxième au deuxième, et ainsi de suite.
def presenter(prenom, nom, age):
print(f"{prenom} {nom} a {age} ans.")
# Les arguments sont passés dans l'ordre : prenom, nom, age
presenter("Marie", "Dupont", 30)
# Affiche : Marie Dupont a 30 ans.
# Attention à l'ordre ! Inverser les arguments change le résultat
presenter("Dupont", "Marie", 30)
# Affiche : Dupont Marie a 30 ans.Comme vous pouvez le constater, inverser l'ordre des arguments positionnels produit un résultat incorrect. C'est pourquoi il est crucial de respecter l'ordre des paramètres lors de l'appel d'une fonction.
Arguments nommés (keyword arguments)
Les arguments nommés (ou keyword arguments) sont passés en précisant explicitement le nom du paramètre auquel ils correspondent. Cette approche présente deux avantages majeurs : vous n'avez plus besoin de respecter l'ordre des paramètres, et votre code devient beaucoup plus lisible.
def presenter(prenom, nom, age):
print(f"{prenom} {nom} a {age} ans.")
# Avec des arguments nommés, l'ordre n'a pas d'importance
presenter(age=30, nom="Dupont", prenom="Marie")
# Affiche : Marie Dupont a 30 ans.
# Vous pouvez aussi mixer positionnels et nommés
presenter("Marie", age=30, nom="Dupont")
# Affiche : Marie Dupont a 30 ans.Lorsque vous mélangez arguments positionnels et nommés, les arguments positionnels doivent toujours être placés avant les arguments nommés. Sinon, Python lèvera une SyntaxError.
Arguments par défaut
Les arguments par défaut sont définis directement dans la signature de la fonction. Ils permettent de rendre certains paramètres optionnels : si vous ne fournissez pas de valeur pour ces paramètres, la valeur par défaut sera utilisée.
def creer_profil(nom, role="utilisateur", actif=True):
return {
"nom": nom,
"role": role,
"actif": actif
}
# Appel avec uniquement l'argument obligatoire
profil1 = creer_profil("Alice")
print(profil1)
# {'nom': 'Alice', 'role': 'utilisateur', 'actif': True}
# Appel en modifiant un argument par défaut
profil2 = creer_profil("Bob", role="admin")
print(profil2)
# {'nom': 'Bob', 'role': 'admin', 'actif': True}
# Appel en modifiant tous les arguments
profil3 = creer_profil("Charlie", role="moderateur", actif=False)
print(profil3)
# {'nom': 'Charlie', 'role': 'moderateur', 'actif': False}Attention aux valeurs par défaut mutables ! N'utilisez jamais une list, un dict ou un sets comme valeur par défaut. Utilisez plutôt None et créez l'objet mutable dans le corps de la fonction.
# ❌ MAUVAISE PRATIQUE : liste mutable en valeur par défaut
def ajouter_element(element, liste=[]):
liste.append(element)
return liste
print(ajouter_element(1)) # [1]
print(ajouter_element(2)) # [1, 2] ← La même liste est réutilisée !
# ✅ BONNE PRATIQUE : utiliser None comme valeur par défaut
def ajouter_element(element, liste=None):
if liste is None:
liste = []
liste.append(element)
return liste
print(ajouter_element(1)) # [1]
print(ajouter_element(2)) # [2] ← Comportement attendu
Arguments variables avec *args
La syntaxe *args vous permet de passer un nombre variable d'arguments positionnels à une fonction. Ces arguments sont regroupés dans un tuple accessible à l'intérieur de la fonction. C'est particulièrement utile lorsque vous ne savez pas à l'avance combien d'arguments seront passés.
def calculer_somme(*args):
print(f"Type de args : {type(args)}")
print(f"Valeurs reçues : {args}")
return sum(args)
# Appel avec un nombre variable d'arguments
resultat1 = calculer_somme(1, 2, 3)
print(f"Somme : {resultat1}")
# Type de args :
# Valeurs reçues : (1, 2, 3)
# Somme : 6
resultat2 = calculer_somme(10, 20, 30, 40, 50)
print(f"Somme : {resultat2}")
# Somme : 150Vous pouvez également combiner *args avec des paramètres classiques :
def afficher_scores(joueur, *scores):
moyenne = sum(scores) / len(scores) if scores else 0
print(f"{joueur} - Scores : {scores} - Moyenne : {moyenne:.1f}")
afficher_scores("Alice", 85, 92, 78, 95)
# Alice - Scores : (85, 92, 78, 95) - Moyenne : 87.5
Arguments variables avec **kwargs
La syntaxe **kwargs fonctionne de manière similaire à *args, mais pour les arguments nommés. Les arguments sont regroupés dans un dict (dictionnaire) accessible à l'intérieur de la fonction.
def creer_utilisateur(**kwargs):
print(f"Type de kwargs : {type(kwargs)}")
for cle, valeur in kwargs.items():
print(f" {cle} = {valeur}")
return kwargs
creer_utilisateur(nom="Alice", age=30, ville="Paris", email="alice@example.com")
# Type de kwargs :
# nom = Alice
# age = 30
# ville = Paris
# email = alice@example.comLa combinaison de *args et **kwargs est très puissante et couramment utilisée dans les bibliothèques Python :
def fonction_flexible(*args, **kwargs):
print(f"Arguments positionnels : {args}")
print(f"Arguments nommés : {kwargs}")
fonction_flexible(1, 2, 3, nom="Alice", age=30)
# Arguments positionnels : (1, 2, 3)
# Arguments nommés : {'nom': 'Alice', 'age': 30}
L'ordre des paramètres en Python
Python impose un ordre strict dans la définition des paramètres d'une fonction. Voici l'ordre à respecter :
| Position | Type de paramètre | Exemple |
|---|---|---|
| 1 | Paramètres positionnels obligatoires | a, b |
| 2 | Paramètres avec valeur par défaut | c=10 |
| 3 | *args (arguments positionnels variables) | *args |
| 4 | Paramètres keyword-only | d, e=20 |
| 5 | **kwargs (arguments nommés variables) | **kwargs |
# Exemple avec tous les types de paramètres
def fonction_complete(a, b, c=10, *args, d, e=20, **kwargs):
print(f"a={a}, b={b}, c={c}")
print(f"args={args}")
print(f"d={d}, e={e}")
print(f"kwargs={kwargs}")
fonction_complete(1, 2, 3, 4, 5, d=100, e=200, extra="test")
# a=1, b=2, c=3
# args=(4, 5)
# d=100, e=200
# kwargs={'extra': 'test'}Les paramètres placés après *args (ici d et e) sont des paramètres keyword-only : ils doivent obligatoirement être passés en tant qu'arguments nommés.
Dépaquetage d'arguments (unpacking)
Python permet de dépaqueter des structures de données pour les passer comme arguments à une fonction. C'est une technique extrêmement utile qui rend votre code plus élégant.
Dépaquetage avec * (listes et tuples)
def additionner(a, b, c):
return a + b + c
# Dépaqueter une liste
nombres = [10, 20, 30]
resultat = additionner(*nombres)
print(resultat) # 60
# Dépaqueter un tuple
coordonnees = (5, 10, 15)
resultat = additionner(*coordonnees)
print(resultat) # 30
Dépaquetage avec ** (dictionnaires)
def creer_profil(nom, age, ville):
return f"{nom}, {age} ans, habite à {ville}"
# Dépaqueter un dictionnaire
infos = {"nom": "Alice", "age": 30, "ville": "Paris"}
profil = creer_profil(**infos)
print(profil) # Alice, 30 ans, habite à ParisLe dépaquetage est particulièrement utile avec les fonctions comme zip ou enumerate où vous manipulez des collections de données.
Arguments et fonctions lambda
Les fonctions lambda acceptent les mêmes types d'arguments que les fonctions classiques définies avec def, bien que leur utilisation soit généralement plus concise :
# Lambda avec arguments positionnels
multiplier = lambda x, y: x * y
print(multiplier(3, 4)) # 12
# Lambda avec argument par défaut
saluer = lambda nom, salutation="Bonjour": f"{salutation}, {nom} !"
print(saluer("Alice")) # Bonjour, Alice !
print(saluer("Bob", "Salut")) # Salut, Bob !
# Lambda avec *args
additionner = lambda *args: sum(args)
print(additionner(1, 2, 3, 4)) # 10
Bonnes pratiques pour les arguments en Python
Voici les bonnes pratiques essentielles à suivre lorsque vous travaillez avec les arguments en Python :
1. Nommez vos paramètres de manière descriptive
# ❌ MAUVAIS : noms peu descriptifs
def calc(a, b, c):
return a * b * (1 + c)
# ✅ BON : noms descriptifs
def calculer_prix_total(prix_unitaire, quantite, taux_taxe):
return prix_unitaire * quantite * (1 + taux_taxe)
2. Limitez le nombre d'arguments
Si une fonction nécessite plus de 4-5 arguments, envisagez d'utiliser un dict, une dataclass ou un namedtuple pour regrouper les paramètres liés :
from dataclasses import dataclass
# ❌ Trop d'arguments
def creer_commande(client_nom, client_email, client_tel,
produit_nom, produit_prix, quantite, remise):
pass
# ✅ Utiliser des dataclasses pour regrouper
@dataclass
class Client:
nom: str
email: str
tel: str
@dataclass
class Produit:
nom: str
prix: float
def creer_commande(client: Client, produit: Produit, quantite: int, remise: float = 0):
pass
3. Utilisez les annotations de type
Les annotations de type améliorent la lisibilité et permettent aux outils d'analyse statique de détecter les erreurs. Combinées avec des docstring, elles rendent votre code beaucoup plus compréhensible :
def rechercher_utilisateurs(
nom: str,
age_min: int = 0,
age_max: int = 120,
actif: bool = True
) -> list[dict]:
"""Recherche des utilisateurs selon les critères donnés.
Args:
nom: Le nom ou partie du nom à rechercher.
age_min: L'âge minimum (inclus). Par défaut 0.
age_max: L'âge maximum (inclus). Par défaut 120.
actif: Filtrer uniquement les utilisateurs actifs.
Returns:
Une liste de dictionnaires représentant les utilisateurs trouvés.
"""
pass
4. Préférez les arguments nommés pour plus de clarté
# ❌ Peu lisible : que signifie True et 5 ?
resultat = envoyer_email("alice@example.com", "Sujet", "Corps", True, 5)
# ✅ Lisible : chaque argument est explicite
resultat = envoyer_email(
destinataire="alice@example.com",
sujet="Sujet",
corps="Corps",
html=True,
tentatives_max=5
)
5. Utilisez / et * pour forcer le type d'argument
Depuis Python 3.8, vous pouvez utiliser / et * pour contrôler si les arguments doivent être positionnels ou nommés :
# Tout avant / doit être positionnel
# Tout après * doit être nommé
def configurer(host, port, /, *, timeout=30, retries=3):
print(f"Connexion à {host}:{port} (timeout={timeout}, retries={retries})")
# ✅ Correct
configurer("localhost", 8080, timeout=60)
# ❌ Erreur : host et port doivent être positionnels
# configurer(host="localhost", port=8080, timeout=60)
# ❌ Erreur : timeout doit être nommé
# configurer("localhost", 8080, 60)
Passage par référence ou par valeur ?
En Python, les arguments sont passés par affectation (parfois appelé passage par référence d'objet). Cela signifie que la variable locale dans la fonction pointe vers le même objet que l'argument passé. Le comportement dépend ensuite du type d'objet :
| Type d'objet | Mutable ? | Comportement |
|---|---|---|
int, float, str, tuple | Non (immuable) | Les modifications créent un nouvel objet |
| list, dict, sets | Oui (mutable) | Les modifications affectent l'objet original |
# Avec un objet immuable (int)
def modifier_nombre(n):
n = n + 10
print(f"Dans la fonction : n = {n}")
valeur = 5
modifier_nombre(valeur)
print(f"Après l'appel : valeur = {valeur}")
# Dans la fonction : n = 15
# Après l'appel : valeur = 5 ← Pas modifié !
# Avec un objet mutable (liste)
def modifier_liste(lst):
lst.append(4)
print(f"Dans la fonction : lst = {lst}")
ma_liste = [1, 2, 3]
modifier_liste(ma_liste)
print(f"Après l'appel : ma_liste = {ma_liste}")
# Dans la fonction : lst = [1, 2, 3, 4]
# Après l'appel : ma_liste = [1, 2, 3, 4] ← Modifié !Si vous souhaitez éviter les modifications involontaires d'un objet mutable, passez une copie de l'objet à la fonction en utilisant par exemple ma_liste.copy() ou ma_liste[:].
Questions fréquentes
Quelle est la différence entre un argument et un paramètre en Python ?
Un paramètre est la variable déclarée dans la définition de la fonction (par exemple def saluer(nom) où nom est le paramètre). Un argument est la valeur réelle que vous passez lors de l'appel de cette fonction (par exemple saluer("Alice") où "Alice" est l'argument). En pratique, les deux termes sont souvent utilisés de manière interchangeable, mais connaître cette distinction vous aide à mieux comprendre la documentation officielle de Python.
Quand utiliser *args et **kwargs ?
Utilisez *args lorsque vous souhaitez qu'une fonction accepte un nombre variable d'arguments positionnels (par exemple, une fonction qui calcule la somme de N nombres). Utilisez **kwargs lorsque vous voulez accepter un nombre variable d'arguments nommés (par exemple, une fonction de configuration avec de nombreuses options facultatives). Ces deux syntaxes sont particulièrement utiles dans les décorateurs, les fonctions d'enveloppement (wrapper), et les fonctions qui doivent transmettre des arguments à d'autres fonctions.
Pourquoi ne faut-il pas utiliser une liste comme valeur par défaut ?
En Python, les valeurs par défaut des paramètres sont évaluées une seule fois, au moment de la définition de la fonction, et non à chaque appel. Si vous utilisez une list (ou tout autre objet mutable) comme valeur par défaut, cette même instance sera partagée entre tous les appels de la fonction. Cela peut provoquer des bugs difficiles à repérer. La solution recommandée est d'utiliser None comme valeur par défaut et de créer un nouvel objet mutable dans le corps de la fonction.
Comment apprendre à maîtriser les arguments et les fonctions en Python ?
Pour maîtriser les arguments en Python, nous vous recommandons de pratiquer régulièrement en écrivant vos propres fonctions avec différents types d'arguments. Commencez par les arguments positionnels, puis explorez progressivement les arguments nommés, les valeurs par défaut, *args et **kwargs. Pour un apprentissage structuré et complet, notre formation dédiée à Python vous accompagne depuis les bases jusqu'aux concepts avancés, avec des exercices pratiques et des projets concrets qui vous permettront de maîtriser pleinement ces notions essentielles.