Introduction
Les *args et **kwargs de Python sont des fonctionnalités puissantes qui vous permettent d'écrire des fonctions plus flexibles et dynamiques. Dans ce tutoriel, nous allons explorer comment combiner ces deux techniques pour créer des appels de fonction polyvalents capables de gérer un nombre variable d'arguments et d'arguments clé-valeur. À la fin, vous aurez une bonne compréhension de la manière d'utiliser *args et **kwargs pour écrire un code Python plus robuste et adaptable.
Comprendre *args et **kwargs
Qu'est-ce que *args et **kwargs ?
En Python, *args et **kwargs sont des syntaxes spéciales utilisées dans les définitions de fonction pour gérer un nombre variable d'arguments. Elles permettent aux fonctions d'accepter un nombre arbitraire d'arguments positionnels (*args) et/ou d'arguments clé-valeur (**kwargs).
*args (Arguments non clé-valeur)
La syntaxe *args permet à une fonction d'accepter n'importe quel nombre d'arguments positionnels. Ces arguments sont ensuite regroupés dans un tuple qui peut être itéré à l'intérieur de la fonction. Cela est utile lorsque vous ne savez pas à l'avance combien d'arguments la fonction recevra.
def print_numbers(*args):
for arg in args:
print(arg)
print_numbers(1, 2, 3) ## Output: 1 2 3
print_numbers(4, 5, 6, 7, 8) ## Output: 4 5 6 7 8
**kwargs (Arguments clé-valeur)
La syntaxe **kwargs permet à une fonction d'accepter n'importe quel nombre d'arguments clé-valeur. Ces arguments sont ensuite regroupés dans un dictionnaire, où les clés sont les noms des arguments et les valeurs sont les valeurs correspondantes des arguments. Cela est utile lorsque vous souhaitez passer un nombre arbitraire de paramètres nommés à une fonction.
def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
print_info(name="LabEx", age=30, city="New York")
## Output:
## name: LabEx
## age: 30
## city: New York
Combiner *args et **kwargs
Vous pouvez utiliser à la fois *args et **kwargs dans la même définition de fonction. *args collectera tous les arguments positionnels, tandis que **kwargs collectera tous les arguments clé-valeur.
def print_all(*args, **kwargs):
for arg in args:
print(arg)
for key, value in kwargs.items():
print(f"{key}: {value}")
print_all(1, 2, 3, name="LabEx", age=30)
## Output:
## 1
## 2
## 3
## name: LabEx
## age: 30
Dans cet exemple, la fonction print_all() peut accepter n'importe quel nombre d'arguments positionnels (*args) et n'importe quel nombre d'arguments clé-valeur (**kwargs).
Utilisation de *args et **kwargs dans les appels de fonction
Passage de *args à une fonction
Pour passer un nombre variable d'arguments positionnels à une fonction qui accepte *args, vous pouvez simplement déballer les arguments en utilisant l'opérateur *.
def print_numbers(*args):
for arg in args:
print(arg)
numbers = [1, 2, 3, 4, 5]
print_numbers(*numbers)
## Output:
## 1
## 2
## 3
## 4
## 5
Dans cet exemple, l'expression *numbers déballer les éléments de la liste numbers et les passe en tant qu'arguments individuels à la fonction print_numbers().
Passage de **kwargs à une fonction
Pour passer un nombre variable d'arguments clé-valeur à une fonction qui accepte **kwargs, vous pouvez utiliser l'opérateur ** pour déballer un dictionnaire en arguments clé-valeur.
def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
info = {"name": "LabEx", "age": 30, "city": "New York"}
print_info(**info)
## Output:
## name: LabEx
## age: 30
## city: New York
Dans cet exemple, l'expression **info déballer les paires clé-valeur du dictionnaire info et les passe en tant qu'arguments clé-valeur individuels à la fonction print_info().
Combinaison de *args et **kwargs dans les appels de fonction
Vous pouvez également combiner *args et **kwargs dans le même appel de fonction. *args collectera tous les arguments positionnels, tandis que **kwargs collectera tous les arguments clé-valeur.
def print_all(*args, **kwargs):
for arg in args:
print(arg)
for key, value in kwargs.items():
print(f"{key}: {value}")
print_all(1, 2, 3, name="LabEx", age=30)
## Output:
## 1
## 2
## 3
## name: LabEx
## age: 30
Dans cet exemple, 1, 2 et 3 sont passés en tant qu'arguments positionnels à *args, tandis que name et age sont passés en tant qu'arguments clé-valeur à **kwargs.
Exemples pratiques de *args et **kwargs
Fonction variadique pour les opérations arithmétiques
Créons une fonction qui peut effectuer diverses opérations arithmétiques sur un nombre quelconque d'arguments.
def arithmetic_operations(*args, operator='+'):
result = args[0]
for i in range(1, len(args)):
if operator == '+':
result += args[i]
elif operator == '-':
result -= args[i]
elif operator == '*':
result *= args[i]
elif operator == '/':
result /= args[i]
return result
print(arithmetic_operations(1, 2, 3, 4, operator='+')) ## Output: 10
print(arithmetic_operations(10, 3, 2, operator='-')) ## Output: 5
print(arithmetic_operations(2, 3, 4, operator='*')) ## Output: 24
print(arithmetic_operations(20, 4, operator='/')) ## Output: 5.0
Dans cet exemple, la fonction arithmetic_operations() peut accepter un nombre quelconque d'arguments en utilisant *args, et l'opération arithmétique souhaitée est spécifiée à l'aide de l'argument clé-valeur operator.
Collecte des entrées utilisateur avec *args
Supposons que vous souhaitiez créer une fonction qui collecte un nombre arbitraire d'entrées utilisateur et les stocke dans une liste.
def collect_inputs(*args):
user_inputs = []
for arg in args:
user_input = input(f"Enter {arg}: ")
user_inputs.append(user_input)
return user_inputs
names = collect_inputs("name", "age", "city")
print(names)
## Output:
## Enter name: LabEx
## Enter age: 30
## Enter city: New York
## ['LabEx', '30', 'New York']
Dans cet exemple, la fonction collect_inputs() utilise *args pour accepter un nombre arbitraire d'invites, puis collecte les réponses de l'utilisateur et les stocke dans une liste.
Fonction de journalisation avec **kwargs
Imaginez que vous souhaitiez créer une fonction de journalisation qui peut enregistrer des messages avec différents niveaux (par exemple, debug, info, warning, error) et inclure des métadonnées supplémentaires.
def log_message(**kwargs):
log_level = kwargs.get('level', 'info')
message = kwargs['message']
metadata = kwargs.get('metadata', {})
print(f"[{log_level.upper()}] {message}")
for key, value in metadata.items():
print(f" {key}: {value}")
log_message(level='debug', message='This is a debug message')
## Output:
## [DEBUG] This is a debug message
log_message(level='warning', message='Something unusual happened', metadata={'user': 'LabEx', 'timestamp': '2023-04-18 12:34:56'})
## Output:
## [WARNING] Something unusual happened
## user: LabEx
## timestamp: 2023-04-18 12:34:56
Dans cet exemple, la fonction log_message() utilise **kwargs pour accepter un nombre arbitraire d'arguments clé-valeur, y compris le niveau de journalisation, le message et les métadonnées facultatives.
Résumé
Dans ce tutoriel Python, vous avez appris à combiner efficacement *args et **kwargs pour créer des appels de fonction flexibles et dynamiques. En comprenant les différences entre ces deux techniques et comment les utiliser ensemble, vous pouvez écrire des fonctions Python plus puissantes et adaptables capables de gérer une grande variété de scénarios d'entrée. Cette connaissance vous aidera à écrire un code plus efficace et plus facilement maintenable, vous faisant ainsi devenir un programmeur Python plus compétent.
