Introduction
Les fonctions Python sont une partie essentielle de tout langage de programmation, nous permettant d'encapsuler des blocs de code réutilisables. Un aspect crucial des fonctions est la capacité à transmettre des arguments, qui sont des valeurs que nous fournissons à la fonction pour qu'elle puisse travailler. Dans ce guide définitif, nous explorerons les différents types d'arguments de fonction en Python et apprendrons à les utiliser efficacement.
Comprendre les arguments des fonctions Python
Les arguments des fonctions Python jouent un rôle crucial dans la création d'un code flexible et efficace. Grâce aux arguments de position, de mot-clé et par défaut, les développeurs peuvent adapter les fonctions à divers besoins. Les arguments de fonction sont les valeurs que nous transmettons à une fonction lorsque nous l'appelons. Ces arguments fournissent les entrées nécessaires à la fonction pour accomplir sa tâche. Python prend en charge différents types d'arguments de fonction, notamment les arguments de position, les arguments de mots-clés et les arguments arbitraires.
Arguments de position
Les arguments positionnels sont le type le plus basique d’arguments de fonction Python. Ils sont définis dans la signature de la fonction et sont transmis dans l'ordre dans lequel ils sont définis. Explorons différents aspects des arguments positionnels.
Argument de position unique
Une fonction peut avoir un ou plusieurs arguments positionnels. Un seul argument de position est défini en spécifiant son nom dans la signature de la fonction. Par exemple
Code:
def greet(name):
print(f"Hello, {name}!")
greet("Alice")Dans cet exemple, la fonction « greet » prend un seul argument de position, « nom ». Lorsque nous appelons la fonction avec l'argument `"Alice"`, elle affiche "Bonjour, Alice!".
Arguments de position multiples
Une fonction peut également avoir plusieurs arguments de position. Ces arguments sont séparés par des virgules dans la signature de la fonction. Par exemple:
Code:
def add_numbers(a, b):
return a + b
result = add_numbers(3, 5)Dans cet exemple, la fonction `add_numbers` prend deux arguments de position, `a` et `b`. Lorsque nous appelons la fonction avec les arguments « 3 » et « 5 », elle renvoie la somme des deux nombres : « 8 ».
Valeurs par défaut pour les arguments positionnels
Python nous permet d'attribuer des valeurs par défaut aux arguments de position. Ces valeurs par défaut sont utilisées lorsque l'appelant ne fournit pas de valeur pour l'argument. Par exemple:
Code:
def greet(name="World"):
print(f"Hello, {name}!")
greet() # Output: Hello, World!
greet("Alice") # Output: Hello, Alice!Dans cet exemple, la fonction `greet` a un argument de position `name` avec une valeur par défaut de `”World”`. Lorsque nous appelons la fonction sans arguments, elle utilise la valeur par défaut et affiche « Hello, World ! ». Si nous fournissons un argument, tel que « Alice », il utilise la valeur fournie et affiche « Bonjour, Alice ! ».
Déballage des arguments de position
Python fournit un moyen de décompresser une liste ou un tuple et de transmettre ses éléments comme arguments de position à une fonction. Ceci est utile lorsque nous avons une collection de valeurs que nous voulons transmettre comme arguments séparés. Par exemple:
Code:
def add_numbers(a, b):
return a + b
numbers = [3, 5]
result = add_numbers(*numbers)Dans cet exemple, nous avons une liste de « nombres » contenant les valeurs « [3, 5] ». En utilisant l'opérateur `*` avant la liste, nous décompressons ses éléments et les passons comme arguments de position à la fonction `add_numbers`. Le résultat est « 8 », la somme de « 3 » et « 5 ».
Arguments de mots clés
Les arguments de mots-clés sont un autre type d’argument de fonction en Python. Contrairement aux arguments de position, les arguments de mots clés sont identifiés par leur nom plutôt que par leur position. Explorons différents aspects des arguments de mots clés.
Argument de mot clé unique
Une fonction peut avoir un ou plusieurs arguments mot-clé. Un seul argument de mot-clé est défini en spécifiant son nom et sa valeur par défaut dans la signature de la fonction. Par exemple:
Code:
def greet(name="World"):
print(f"Hello, {name}!")
greet() # Output: Hello, World!
greet(name="Alice") # Output: Hello, Alice!Dans cet exemple, la fonction `greet` a un argument mot-clé `name` avec une valeur par défaut de `”World”`. Nous pouvons appeler la fonction sans aucun argument et elle utilise la valeur par défaut. Alternativement, nous pouvons fournir une valeur pour l'argument `name` en utilisant explicitement son nom.
Arguments de mots clés multiples
Une fonction peut avoir plusieurs arguments de mot-clé. Ces arguments sont définis en spécifiant leurs noms et valeurs par défaut dans la signature de la fonction. Par exemple:
Code:
def calculate_area(length=1, width=1):
return length * width
area = calculate_area(length=5, width=3)Dans cet exemple, la fonction « calculer_area » a deux arguments de mot-clé, « longueur » et « largeur », avec des valeurs par défaut de « 1 ». Nous pouvons appeler la fonction et fournir explicitement des valeurs pour ces arguments en utilisant leurs noms. Le résultat est « 15 », le produit de « 5 » et « 3 ».
Valeurs par défaut pour les arguments de mots clés
Semblable aux arguments de position, nous pouvons attribuer des valeurs par défaut aux arguments de mots-clés. Ces valeurs par défaut sont utilisées lorsque l'appelant ne fournit pas de valeur pour l'argument. Par exemple:
Code:
def greet(name="World"):
print(f"Hello, {name}!")
greet() # Output: Hello, World!
greet(name="Alice") # Output: Hello, Alice!Dans cet exemple, la fonction `greet` a un argument mot-clé `name` avec une valeur par défaut de `”World”`. Lorsque nous appelons la fonction sans arguments, elle utilise la valeur par défaut et affiche « Hello, World ! ». Si nous fournissons un argument, tel que « Alice », il utilise la valeur fournie et affiche « Bonjour, Alice ! ».
Déballage des arguments de mots clés
Python fournit un moyen de décompresser un dictionnaire et de transmettre ses paires clé-valeur comme arguments de mot-clé à une fonction. Ceci est utile lorsque nous avons une collection de valeurs que nous voulons transmettre comme arguments de mots-clés distincts. Par exemple:
Code:
def greet(name):
print(f"Hello, {name}!")
person = {"name": "Alice"}
greet(**person)Dans cet exemple, nous avons un dictionnaire `person` contenant la paire clé-valeur `{"nom": "Alice"}.` En utilisant l'opérateur `**` avant le dictionnaire, nous décompressons ses paires clé-valeur et les transmettons comme arguments de mot-clé à la fonction `greet`. Le résultat est « Bonjour, Alice ! ».
Arguments arbitraires
Python nous permet de définir des fonctions pouvant accepter un nombre variable d'arguments. Ceux-ci sont appelés arguments arbitraires et sont utiles lorsque nous avons besoin de savoir combien d’arguments seront transmis à la fonction. Il existe deux types d'arguments arbitraires : `*args` pour les arguments positionnels de longueur variable et `**kwargs` pour les arguments de mots-clés de longueur variable.
*args : arguments positionnels de longueur variable
La syntaxe `*args` nous permet de passer un nombre variable d'arguments positionnels à une fonction. Les arguments sont rassemblés dans un tuple, accessible dans la fonction. Voyons un exemple :
Code:
def add_numbers(*args):
total = 0
for num in args:
total += num
return total
result = add_numbers(1, 2, 3, 4, 5)Dans cet exemple, la fonction `add_numbers` accepte n'importe quel nombre d'arguments de position en utilisant la syntaxe `*args`. Les arguments « 1, 2, 3, 4, 5 » sont rassemblés dans un tuple « args ». Nous parcourons ensuite le tuple et calculons la somme de tous les nombres : « 15 ».
**kwargs : arguments de mots clés de longueur variable
La syntaxe `**kwargs` nous permet de passer un nombre variable d'arguments mots-clés à une fonction. Les arguments sont rassemblés dans un dictionnaire, accessible dans la fonction. Voyons un exemple :
Code:
def greet(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
greet(name="Alice", age=25, city="New York")Dans cet exemple, la fonction « greet » accepte n'importe quel nombre d'arguments de mot-clé en utilisant la syntaxe « **kwargs ». Les arguments « nom » : « Alice », « « âge » : 25 » et « ville » : « New York » sont rassemblés dans un dictionnaire « kwargs ». Nous parcourons ensuite le dictionnaire et imprimons chaque clé. -paire de valeurs.
Mélanger différents types d'arguments
Python nous permet de mélanger différents types d'arguments dans une fonction. Nous pouvons avoir des arguments de position, de mot-clé et arbitraires dans la même signature de fonction. Explorons quelques exemples.
Arguments positionnels avec arguments de mots clés
Une fonction peut avoir à la fois des arguments de position et des arguments de mots-clés. Les arguments positionnels sont définis en premier, suivis des arguments mot-clé. Par exemple:
Code:
def greet(name, age=30):
print(f"Hello, {name}! You are {age} years old.")
greet("Alice") # Output: Hello, Alice! You are 30 years old.
greet("Bob", age=25) # Output: Hello, Bob! You are 25 years old.Dans cet exemple, la fonction `greet` a un argument de position `name` et un argument de mot-clé `age` avec une valeur par défaut de `30`. Nous pouvons appeler la fonction avec uniquement l'argument « nom », et elle utilise la valeur par défaut pour « âge ». Alternativement, nous pouvons fournir explicitement une valeur pour « âge » en utilisant son nom.
Arguments de mots clés avec arguments de position
Une fonction peut également avoir des arguments de mot-clé suivis d'arguments de position. Les arguments de mots-clés sont définis en premier, suivis des arguments de position. Par exemple:
Code:
def greet(age=30, name):
print(f"Hello, {name}! You are {age} years old.")
greet(name="Alice") # Output: Hello, Alice! You are 30 years old.
greet(age=25, name="Bob") # Output: Hello, Bob! You are 25 years old.Dans cet exemple, la fonction `greet` a un argument de mot-clé `age` avec une valeur par défaut de `30` et un argument de position `name.` Nous pouvons appeler la fonction avec uniquement l'argument `name`, et elle utilise la valeur par défaut valeur pour « age ». Alternativement, nous pouvons fournir explicitement une valeur pour « age » en utilisant son nom.
Mélanger des arguments positionnels, des arguments de mots clés et des arguments arbitraires
Python nous permet de mélanger des arguments positionnels, mots-clés et arbitraires dans la même fonction. Les arguments de position et de mot-clé sont définis en premier, suivis des arguments arbitraires. Par exemple
Code:
def greet(name, age=30, *args, **kwargs):
print(f"Hello, {name}! You are {age} years old.")
print("Additional arguments:")
for arg in args:
print(arg)
print("Additional keyword arguments:")
for key, value in kwargs.items():
print(f"{key}: {value}")
greet(" Alice," 25, " Hello," " World," city=" New York," country=" USA ")Dans cet exemple, la fonction `greet` a un argument de position `name`, un argument de mot-clé `age` avec une valeur par défaut de `30` et des arguments arbitraires `*args` et `**kwargs`. Nous pouvons appeler le fonction avec les arguments `name` et `age`, suivis d'arguments de position et de mot-clé supplémentaires. La sortie inclut le nom, l’âge, les arguments de position supplémentaires et le mot-clé.
Meilleures pratiques d'utilisation des arguments de fonction
Lorsque vous utilisez des arguments de fonction en Python, il est essentiel de suivre certaines bonnes pratiques pour garantir un code propre et maintenable. Explorons certaines de ces meilleures pratiques.
Choisir des noms d'arguments descriptifs
Lors de la définition des arguments de fonction, il est crucial de choisir des noms descriptifs qui traduisent leur objectif. Cela rend le code lisible et aide les autres développeurs à comprendre le comportement de la fonction. Par exemple:
Code:
def calculate_area(length, width):
return length * widthDans cet exemple, les arguments « longueur » et « largeur » indiquent clairement les dimensions de la zone en cours de calcul.
Garder le nombre d’arguments raisonnable
Il est généralement recommandé de maintenir un nombre raisonnable d'arguments dans une fonction. Plus d'arguments doivent être avancés pour rendre la fonction plus facile à comprendre et à utiliser. Si une fonction nécessite de nombreuses entrées, cela peut être le signe qu’elle en fait trop et qu’elle doit être refactorisée en fonctions plus petites et plus ciblées.
Documenter les arguments de la fonction Python
Documenter les arguments des fonctions Python est essentiel pour permettre aux autres développeurs (y compris votre futur moi) de comprendre et d'utiliser plus facilement vos fonctions. Cela peut être fait en utilisant des docstrings et des commentaires multilignes immédiatement après la signature de la fonction. Par exemple:
Code:
def greet(name):
"""
Greets the specified name.
Args:
name (str): The name to greet.
"""
print(f"Hello, {name}!")Dans cet exemple, la docstring décrit clairement l'argument `name` et son type attendu.
Éviter les valeurs d'argument par défaut mutables
Lors de la définition des valeurs par défaut pour les arguments des fonctions Python, il est généralement recommandé d'éviter d'utiliser des objets mutables tels que des listes ou des dictionnaires. En effet, les valeurs par défaut mutables sont partagées entre plusieurs appels de fonction, ce qui entraîne un comportement inattendu. Au lieu de cela, utilisez des objets immuables ou « Aucun » comme valeurs par défaut et gérez les objets mutables dans la fonction. Par exemple:
Code:
def add_item(item, items=None):
if items is None:
items = []
items.append(item)
return itemsDans cet exemple, la fonction `add_item` prend un argument `item` et un argument facultatif `items`, dont la valeur par défaut est `Aucun.` Si `items` est `Aucun`, nous créons une nouvelle liste vide. Cela garantit que chaque appel de fonction a sa liste de stockage des éléments.
Utilisation des astuces de type pour les arguments de fonction Python
Python prend en charge les indicateurs de type, qui nous permettent de spécifier les types attendus d'arguments de fonction. Les astuces de type améliorent la lisibilité du code et peuvent aider à détecter les erreurs potentielles liées au type. Par exemple:
Code:
def calculate_area(length: float, width: float) -> float:
return length * widthDans cet exemple, les indications de type « float » indiquent que les arguments « length » et « width » doivent être des nombres à virgule flottante. L'indice de type de retour « float » indique que la fonction renverra un nombre à virgule flottante.
Erreurs et pièges courants avec les arguments de fonction Python
Lorsque vous travaillez avec des arguments de fonction Python, il est important de comprendre les erreurs et les pièges courants qui peuvent survenir avec les arguments de fonction. Cette section explorera certaines de ces erreurs et fournira des exemples pour vous aider à les éviter.
Oublier de fournir les arguments requis
Une erreur courante consiste à oublier de fournir les arguments requis lors de l’appel d’une fonction. Cela peut entraîner des erreurs et un comportement inattendu. Prenons un exemple :
Code:
def greet(name):
print(f"Hello, {name}!")
greet() # Error: missing 1 required positional argument: 'name'Dans l'exemple ci-dessus, la fonction `greet()` nécessite un argument `name`. Cependant, lorsque nous appelons la fonction sans fournir aucun argument, Python génère une erreur indiquant qu'un argument requis est manquant.
Fournissez toujours les arguments requis lors de l’appel d’une fonction pour éviter cette erreur.
Utilisation abusive des valeurs d'argument par défaut
Python nous permet de définir des valeurs par défaut pour les arguments de fonction. Cependant, une mauvaise utilisation des valeurs d’argument par défaut peut conduire à des résultats inattendus. Prenons l'exemple suivant :
Code:
def multiply(a, b=2):
return a * b
result = multiply(3)
print(result)
# Output: 6Dans l'exemple ci-dessus, la fonction `multiply()` a un argument par défaut `b` défini sur 2. Lorsque nous appelons la fonction avec un seul argument (`multiply(3)`), Python utilise la valeur par défaut pour `b` et renvoie le résultat de la multiplication de 3 par 2.
Pour éviter d'utiliser à mauvais escient les valeurs d'argument par défaut, examinez attentivement le comportement de votre fonction et choisissez les valeurs par défaut appropriées.
Abuser des arguments arbitraires
Python nous permet de définir des fonctions avec des arguments arbitraires en utilisant la syntaxe `*args`. Bien que cela puisse être utile dans certaines situations, l'utilisation d'arguments arbitraires peut rendre le code plus facile à comprendre et à maintenir. Voyons un exemple :
Code:
def calculate_average(*numbers):
total = sum(numbers)
average = total / len(numbers)
return average
result = calculate_average(1, 2, 3, 4, 5)
print(result) # Output: 3.0Dans l'exemple ci-dessus, la fonction `calculate_average()` accepte n'importe quel nombre d'arguments et calcule leur moyenne. Bien que cela puisse être pratique, d'autres développeurs peuvent ne pas savoir ce que la fonction attend en entrée.
Pour éviter d'abuser d'arguments arbitraires, envisagez d'utiliser des arguments explicites lorsque cela est possible et n'utilisez « *args » que lorsque cela est nécessaire.
Ignorer l'ordre des arguments
Une autre erreur courante consiste à ignorer l’ordre des arguments lors de l’appel d’une fonction. Cela peut conduire à des résultats inattendus et à des bugs dans votre code. Prenons un exemple :
Code:
def divide(a, b):
return a / b
result = divide(2, 4)
print(result) # Output: 0.5
result = divide(4, 2)
print(result) # Output: 2.0Dans l'exemple ci-dessus, la fonction `divide()` attend deux arguments : `a` et `b.` Si nous ignorons l'ordre des arguments lors de l'appel de la fonction, nous obtiendrons des résultats différents.
Pour éviter cette erreur, fournissez toujours les arguments dans le bon ordre lorsque vous appelez une fonction.
Ne pas gérer les arguments inattendus
Python nous permet de définir des fonctions avec divers arguments en utilisant la syntaxe `**kwargs`. Cependant, ne pas gérer les arguments inattendus peut entraîner des erreurs et un comportement inattendu. Voyons un exemple :
Code:
def print_person_info(name, age):
print(f"Name: {name}")
print(f"Age: {age}")
print_person_info(name="John", age=25, city="New York")Dans l'exemple ci-dessus, la fonction `print_person_info()` attend deux arguments : `name` et `age.` Cependant, nous fournissons également un argument supplémentaire, `city.` Puisque la fonction ne gère pas les arguments inattendus, Python génère une erreur .
Pour éviter cette erreur, gérez explicitement les arguments inattendus ou utilisez des arguments de mots clés pour fournir des informations supplémentaires.
Concepts avancés d'arguments de fonction Python
En plus des erreurs et pièges courants, Python fournit des concepts avancés pour travailler avec les arguments de fonction. Dans cette section, nous explorerons certains de ces concepts.
Déballage de l'argument avec *
Python nous permet de décompresser une liste ou un tuple et de transmettre ses éléments sous forme d'arguments individuels à une fonction à l'aide de l'opérateur `*`. Cela peut être utile lorsque vous travaillez avec des listes d'arguments de longueur variable. Prenons un exemple :
Code:
def multiply(a, b, c):
return a * b * c
numbers = [2, 3, 4]
result = multiply(*numbers)
print(result) # Output: 24L'exemple ci-dessus définit une liste « numéros » contenant trois éléments. En utilisant l'opérateur `*` avant la liste lors de l'appel de la fonction `multiply()`, Python décompresse la liste et transmet ses éléments comme arguments individuels.
Déballage de l'argument avec **
Comme le déballage des arguments avec `*,` Python nous permet également de décompresser un dictionnaire et de transmettre ses paires clé-valeur comme arguments de mot-clé à une fonction à l'aide de l'opérateur `**`. Voyons un exemple :
Code:
def print_person_info(name, age):
print(f"Name: {name}")
print(f"Age: {age}")
person = {"name": "John", "age": 25}
print_person_info(**person)L'exemple ci-dessus définit un dictionnaire « personne » contenant deux paires clé-valeur. En utilisant l'opérateur `**` avant le dictionnaire lors de l'appel de la fonction `print_person_info()`, Python décompresse le dictionnaire et transmet ses paires clé-valeur comme arguments de mot-clé.
Annotation d’arguments et vérification de type
Python nous permet d'annoter les arguments de fonction avec des types en utilisant la syntaxe `:`. Bien que l'interpréteur n'applique pas ces annotations, elles peuvent être utiles pour la documentation et les outils de vérification de type. Prenons un exemple :
Code:
def greet(name: str) -> None:
print(f"Hello, {name}!")
greet("John")Dans l'exemple ci-dessus, nous annotons l'argument `name` de la fonction `greet()` avec le type `str`. Cela indique que la fonction attend un argument de chaîne. Bien que Python n'applique pas ce type, les outils de vérification de type peuvent utiliser ces annotations pour détecter les erreurs de type potentielles.
Décorateurs d’arguments de fonction
Python nous permet de définir des décorateurs, qui modifient le comportement d'autres fonctions. Nous pouvons utiliser des décorateurs pour ajouter des fonctionnalités supplémentaires aux arguments de la fonction. Voyons un exemple :
Code:
def uppercase_arguments(func):
def wrapper(*args, **kwargs):
args = [arg.upper() for arg in args]
kwargs = {key: value.upper() for key, value in kwargs.items()}
return func(*args, **kwargs)
return wrapper
@uppercase_arguments
def greet(name):
print(f"Hello, {name}!")
greet("John")L'exemple ci-dessus définit un décorateur `uppercase_arguments` qui convertit tous les arguments en majuscules avant d'appeler la fonction décorée. En appliquant le décorateur `uppercase_arguments` à la fonction `greet()`, nous modifions son comportement pour saluer la personne en majuscule.
Conclusion
Dans ce guide définitif des arguments de fonction Python, nous avons abordé divers aspects de l'utilisation des arguments de fonction. Nous avons exploré les erreurs courantes, les pièges et les concepts avancés tels que les annotations de déballage des arguments et les décorateurs.
Vous pouvez écrire du code Python plus robuste et plus maintenable en comprenant ces concepts et en évitant les erreurs courantes. Fournissez toujours les arguments requis, utilisez judicieusement les valeurs par défaut et gérez les arguments inattendus de manière appropriée.
Prêt à booster votre carrière ? Rejoignez notre exclusivité cours de science des données et démarrez avec Python, le langage leader du secteur. Aucune formation en codage ou en science des données ? Aucun problème! Ce cours est fait sur mesure pour les débutants comme vous. Saisissez l’opportunité de lancer votre aventure en science des données dès aujourd’hui. Ne manquez pas cette chance d’acquérir de précieuses compétences Python qui vous distingueront. Inscrivez-vous maintenant et faites le premier pas vers une carrière réussie et enrichissante dans la science des données !
Continuez votre parcours Python en explorant davantage les arguments de fonction et en expérimentant différents exemples. Bon codage !
Services Connexes
- Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
- PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
- PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
- PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
- PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
- La source: https://www.analyticsvidhya.com/blog/2024/01/a-comprehensive-guide-to-python-function-arguments/
