Les fonctions sont la pierre angulaire d’un code Python modulaire et réutilisable. Ce tutoriel explore les subtilités des arguments de fonction, vous donnant les moyens d’écrire des programmes plus propres, plus efficaces et moins sujets aux erreurs.
Table des matières
- Arguments positionnels
- Arguments mots-clés
- Arguments par défaut
- Nombre variable d’arguments (*args et **kwargs)
- Arguments mutables vs. immuables
Arguments positionnels
Les arguments positionnels sont la forme la plus simple. Ils sont passés à une fonction dans l’ordre où ils sont définis. L’ordre est strictement appliqué ; une discordance dans l’ordre des arguments lors de l’appel de la fonction entraînera des résultats incorrects ou des erreurs.
def greet(name, greeting):
print(f"{greeting}, {name}!")
greet("Alice", "Hello") # Ordre correct
greet("Hello", "Alice") # Ordre incorrect - affichera "Alice, Hello!"
Arguments mots-clés
Les arguments mots-clés vous permettent de spécifier le nom de l’argument lors de l’appel d’une fonction. Cela rend votre code plus lisible et moins sujet aux erreurs, notamment lorsque vous traitez des fonctions comportant de nombreux paramètres. L’ordre des arguments mots-clés n’a pas d’importance.
def describe_pet(animal_type, pet_name, age=None):
print(f"nJ'ai un {animal_type}.")
print(f"Le nom de mon {animal_type} est {pet_name.title()}.")
if age:
print(f"Mon {animal_type} a {age} ans.")
describe_pet(animal_type='hamster', pet_name='harry')
describe_pet(pet_name='willie', animal_type='chien', age=5)
Arguments par défaut
Les arguments par défaut fournissent une valeur de secours pour les paramètres de fonction. Si une valeur n’est pas fournie lors de l’appel de la fonction, la valeur par défaut est utilisée. Les arguments par défaut doivent toujours être placés après les arguments non par défaut dans la définition de la fonction.
def power(base, exponent=2):
return base ** exponent
print(power(3)) # Sortie : 9 (l'exposant prend la valeur par défaut 2)
print(power(3, 3)) # Sortie : 27
Nombre variable d’arguments (*args et **kwargs)
La syntaxe `*args` et `**kwargs` vous permet de gérer un nombre variable d’arguments positionnels et d’arguments mots-clés, respectivement. `*args` collecte les arguments positionnels dans un tuple, tandis que `**kwargs` collecte les arguments mots-clés dans un dictionnaire.
def my_function(*args, **kwargs):
print("Arguments positionnels :", args)
print("Arguments mots-clés :", kwargs)
my_function(1, 2, 3, name="Alice", age=30)
Arguments mutables vs. immuables
La compréhension de la mutabilité est cruciale lorsque l’on travaille avec des arguments de fonction. Les objets immuables (comme les nombres, les chaînes de caractères, les tuples) ne peuvent pas être modifiés au sein d’une fonction ; toute modification crée un nouvel objet. Les objets mutables (comme les listes, les dictionnaires) peuvent être modifiés sur place, affectant l’objet original en dehors de la fonction. Cela peut entraîner des effets secondaires inattendus s’il n’est pas géré avec soin.
def modify_list(my_list):
my_list.append(4) # Modifie la liste originale
my_list = [1, 2, 3]
modify_list(my_list)
print(my_list) # Sortie : [1, 2, 3, 4] (liste originale modifiée)
def modify_string(my_string):
my_string += "!!!" # Crée une nouvelle chaîne de caractères
my_string = "Hello"
modify_string(my_string)
print(my_string) # Sortie : Hello (chaîne de caractères originale inchangée)
Ce guide complet fournit une base solide pour travailler avec les arguments de fonction en Python. La maîtrise de ces concepts améliorera considérablement la qualité et la maintenabilité de votre code.