Introduction
Dans ce laboratoire, nous allons explorer comment définir et utiliser des fonctions avec des paramètres en Python. Les fonctions deviennent beaucoup plus puissantes lorsqu'elles peuvent accepter des entrées, ce qui les rend dynamiques et réutilisables.
Nous couvrirons plusieurs types de paramètres de fonction, y compris les paramètres positionnels, les valeurs par défaut, les arguments par mot-clé (keyword arguments) et les arguments de longueur variable. Grâce à des exemples pratiques, vous apprendrez à créer des fonctions flexibles capables de gérer une variété d'entrées.
Définir des Fonctions avec des Paramètres Positionnels
Les paramètres nous permettent de transmettre des données à une fonction, rendant son comportement adaptable en fonction de l'entrée qu'elle reçoit. Commençons par le type le plus courant : les paramètres positionnels. Les arguments passés à une fonction sont assignés à ces paramètres en fonction de leur ordre.
Tout d'abord, localisez le fichier positional_params.py dans l'explorateur de fichiers sur le côté gauche du WebIDE et ouvrez-le.
Maintenant, définissons une fonction nommée hello qui accepte un paramètre, name. Ajoutez le code suivant au fichier positional_params.py :
def hello(name):
print(f'Hello, {name}!')
hello('John')
hello('Alice')
Dans ce code, name est un paramètre, qui agit comme un espace réservé dans la définition de la fonction. Lorsque nous appelons la fonction, comme hello('John'), la valeur 'John' est un argument qui est assigné au paramètre name.
Pour exécuter le script, ouvrez un nouveau terminal dans le WebIDE en cliquant sur Terminal -> New Terminal dans le menu supérieur. Ensuite, exécutez la commande suivante :
python3 ~/project/positional_params.py
Vous verrez la sortie suivante, montrant que la fonction a produit des résultats différents pour des arguments différents :
Hello, John!
Hello, Alice!
Si une fonction est définie avec des paramètres positionnels, vous devez fournir un argument correspondant pour chacun d'eux lors de son appel. Oublier de le faire entraînera une erreur.
Utiliser des Valeurs de Paramètres par Défaut
Il est souvent utile de fournir une valeur par défaut pour un paramètre. Si aucun argument pour ce paramètre n'est fourni lors de l'appel de la fonction, la valeur par défaut est utilisée. Cela rend le paramètre optionnel.
Voyons ce qui se passe lorsque nous appelons une fonction sans argument requis. Ouvrez le fichier default_params.py et ajoutez le code suivant :
def hello(name):
print(f'Hello, {name}!')
hello()
Sauvegardez le fichier et exécutez-le depuis le terminal :
python3 ~/project/default_params.py
Ceci produira une TypeError car la fonction hello attendait un argument mais n'en a reçu aucun.
Traceback (most recent call last):
File "/home/labex/project/default_params.py", line 4, in <module>
hello()
TypeError: hello() missing 1 required positional argument: 'name'
Pour corriger cela, nous pouvons assigner une valeur par défaut au paramètre name. Modifiez le fichier default_params.py en remplaçant son contenu par le code suivant :
def hello(name="World"):
print(f'Hello, {name}!')
hello()
hello("Jobs")
Maintenant, exécutez à nouveau le script :
python3 ~/project/default_params.py
La sortie sera :
Hello, World!
Hello, Jobs!
Le premier appel utilise la valeur par défaut "World", tandis que le second appel utilise l'argument fourni "Jobs".
Règle Importante : Dans une définition de fonction, tous les paramètres sans valeur par défaut doivent précéder tous les paramètres avec des valeurs par défaut. Par exemple, def func(a, b="default") est correct, mais def func(a="default", b) provoquera une SyntaxError.
Passer des Arguments en Utilisant des Mots-Clés
Lors de l'appel d'une fonction, vous pouvez nommer explicitement les paramètres pour lesquels vous fournissez des arguments. Ce sont les arguments par mot-clé (keyword arguments). Leur principal avantage est que l'ordre n'a pas d'importance, ce qui peut rendre votre code plus lisible.
Ouvrez le fichier keyword_args.py et ajoutez le code suivant :
def person(name, age):
print(f"{name} is {age} years old.")
## Appel avec des arguments par mot-clé - l'ordre n'a pas d'importance
person(name="Zhang San", age=25)
person(age=50, name="Li Si")
Sauvegardez le fichier et exécutez-le depuis le terminal :
python3 ~/project/keyword_args.py
Vous verrez que les deux appels fonctionnent correctement, quelle que soit l'ordre des arguments :
Zhang San is 25 years old.
Li Si is 50 years old.
Vous pouvez également mélanger des arguments positionnels et des arguments par mot-clé dans un seul appel de fonction. Cependant, vous devez respecter une règle : tous les arguments positionnels doivent précéder tous les arguments par mot-clé.
Maintenant, remplacez le contenu de keyword_args.py par ce qui suit pour voir cette règle en action :
def person(name, age):
print(f"{name} is {age} years old.")
## Ceci est un mélange valide d'arguments positionnels et par mot-clé
person("Wang Wu", age=26)
## Ceci provoquerait une SyntaxError: positional argument follows keyword argument
## person(age=28, "Zhao Liu")
Exécutez à nouveau le script. L'appel valide s'exécutera comme prévu.
python3 ~/project/keyword_args.py
Sortie attendue :
Wang Wu is 26 years old.
Gérer un Nombre Variable d'Arguments
Les fonctions Python peuvent être conçues pour accepter un nombre variable d'arguments. Ceci est utile lorsque vous ne savez pas à l'avance combien d'arguments seront passés à votre fonction.
Arguments Positionnels Variables (*args)
En plaçant un astérisque * avant le nom d'un paramètre, vous pouvez collecter un nombre arbitraire d'arguments positionnels dans un tuple. Le nom args est une convention, mais vous pouvez utiliser n'importe quel nom de paramètre valide.
Arguments Mots-Clés Variables (**kwargs)
En plaçant un double astérisque ** avant le nom d'un paramètre, vous pouvez collecter un nombre arbitraire d'arguments par mot-clé dans un dictionnaire. Le nom kwargs est également une convention.
Combinons ces concepts. Ouvrez le fichier variable_args.py et ajoutez le code suivant :
## Utilisation de *args pour sommer un nombre variable de nombres
def calculate_sum(*numbers):
print(f"Arguments received as a tuple: {numbers}")
total = sum(numbers)
print(f"Sum: {total}\n")
## Utilisation de **kwargs pour capturer des informations de profil supplémentaires
def person_profile(name, age, **other_info):
print(f"Name: {name}")
print(f"Age: {age}")
print(f"Other Info: {other_info}\n")
## Appel des fonctions
calculate_sum(1, 2, 3)
calculate_sum(10, 20, 30, 40, 50)
person_profile('Wang Wu', 26, gender="Male", job="Writer")
person_profile('Zhao Liu', 28, city="Beijing", status="Active")
Exécutez le script depuis le terminal :
python3 ~/project/variable_args.py
La sortie montre que numbers est un tuple et other_info est un dictionnaire :
Arguments received as a tuple: (1, 2, 3)
Sum: 6
Arguments received as a tuple: (10, 20, 30, 40, 50)
Sum: 150
Name: Wang Wu
Age: 26
Other Info: {'gender': 'Male', 'job': 'Writer'}
Name: Zhao Liu
Age: 28
Other Info: {'city': 'Beijing', 'status': 'Active'}
Explorer les Types de Paramètres Spéciaux
Python vous permet d'imposer la manière dont les arguments peuvent être passés à une fonction, rendant la signature de votre fonction plus claire et moins ambiguë. Vous pouvez spécifier des paramètres comme étant uniquement positionnels (positional-only) ou uniquement par mot-clé (keyword-only).
Paramètres Uniquement Positionnels (/)
Pour spécifier que les paramètres ne peuvent être passés que par position, placez-les avant une barre oblique (/) dans la définition de la fonction.
Paramètres Uniquement par Mot-Clé (*)
Pour spécifier que les paramètres ne peuvent être passés que par mot-clé, placez-les après un astérisque (*). Si le * n'est pas suivi d'un nom de paramètre, cela signifie que tous les paramètres suivants doivent être uniquement par mot-clé.
Voyons comment combiner ces types. Ouvrez le fichier special_params.py et ajoutez le code suivant. Cet exemple définit une fonction avec des paramètres uniquement positionnels, des paramètres standards et des paramètres uniquement par mot-clé.
def school_info(name, /, standard_param, *, city):
print(f'Positional-Only (name): {name}')
print(f'Standard (standard_param): {standard_param}')
print(f'Keyword-Only (city): {city}')
print('---')
## Dans cette fonction :
## - `name` doit être passé par position.
## - `standard_param` peut être passé par position ou par mot-clé.
## - `city` doit être passé par mot-clé.
## Appels valides
school_info("Peking University", "PKU", city="Beijing")
school_info("Tsinghua University", standard_param="THU", city="Beijing")
## Exemples d'appels invalides (commentés pour éviter les erreurs)
## school_info(name="Zhejiang University", "ZJU", city="Hangzhou") ## TypeError: name is positional-only
## school_info("Fudan University", "FDU", "Shanghai") ## TypeError: city is keyword-only
Exécutez le script pour voir le résultat des appels valides :
python3 ~/project/special_params.py
La sortie sera :
Positional-Only (name): Peking University
Standard (standard_param): PKU
Keyword-Only (city): Beijing
---
Positional-Only (name): Tsinghua University
Standard (standard_param): THU
Keyword-Only (city): Beijing
---
Cette syntaxe aide à créer des fonctions robustes et auto-documentées, réduisant l'ambiguïté quant à la manière dont elles doivent être appelées.
Résumé
Dans ce laboratoire, vous avez appris les fondamentaux de l'utilisation des paramètres dans les fonctions Python. Nous avons couvert comment définir et appeler des fonctions avec des paramètres positionnels, comment rendre les paramètres optionnels en fournissant des valeurs par défaut, et comment utiliser les arguments par mot-clé (keyword arguments) pour un code plus lisible. Vous avez également exploré comment créer des fonctions flexibles capables d'accepter un nombre variable d'arguments positionnels (*args) et d'arguments par mot-clé (**kwargs). Enfin, nous avons examiné la syntaxe spéciale (/ et *) pour imposer la manière dont les arguments doivent être passés, ce qui améliore la clarté et la robustesse de vos fonctions.
