Arguments de la fonction Python
Arguments de la fonction Python
En Python, vous pouvez définir une fonction qui prend un nombre variable d'arguments. Dans cet article, vous apprendrez à définir de telles fonctions à l'aide d'arguments par défaut, de mots-clés et arbitraires.
Vidéo :Arguments de la fonction Python :positionnel, mots-clés et valeur par défaut
Arguments
Dans la rubrique sur les fonctions définies par l'utilisateur, nous avons appris à définir une fonction et à l'appeler. Sinon, l'appel de la fonction entraînera une erreur. Voici un exemple.
def greet(name, msg):
"""This function greets to
the person with the provided message"""
print("Hello", name + ', ' + msg)
greet("Monica", "Good morning!") Sortie
Hello Monica, Good morning!
Ici, la fonction greet() a deux paramètres.
Puisque nous avons appelé cette fonction avec deux arguments, elle s'exécute sans problème et nous n'obtenons aucune erreur.
Si nous l'appelons avec un nombre différent d'arguments, l'interpréteur affichera un message d'erreur. Vous trouverez ci-dessous un appel à cette fonction avec un et aucun argument avec leurs messages d'erreur respectifs.
>>> greet("Monica") # only one argument
TypeError: greet() missing 1 required positional argument: 'msg' >>> greet() # no arguments TypeError: greet() missing 2 required positional arguments: 'name' and 'msg'
Arguments de fonction variable
Jusqu'à présent, les fonctions avaient un nombre fixe d'arguments. En Python, il existe d'autres façons de définir une fonction qui peut prendre un nombre variable d'arguments.
Trois formes différentes de ce type sont décrites ci-dessous.
Arguments Python par défaut
Les arguments de fonction peuvent avoir des valeurs par défaut en Python.
Nous pouvons fournir une valeur par défaut à un argument en utilisant l'opérateur d'affectation (=). Voici un exemple.
def greet(name, msg="Good morning!"):
"""
This function greets to
the person with the
provided message.
If the message is not provided,
it defaults to "Good
morning!"
"""
print("Hello", name + ', ' + msg)
greet("Kate")
greet("Bruce", "How do you do?") Sortie
Hello Kate, Good morning! Hello Bruce, How do you do?
Dans cette fonction, le paramètre name n'a pas de valeur par défaut et est requis (obligatoire) lors d'un appel.
Par contre, le paramètre msg a une valeur par défaut de "Good morning!" . Il est donc facultatif lors d'un appel. Si une valeur est fournie, elle écrasera la valeur par défaut.
N'importe quel nombre d'arguments dans une fonction peut avoir une valeur par défaut. Mais une fois que nous avons un argument par défaut, tous les arguments à sa droite doivent également avoir des valeurs par défaut.
Cela signifie que les arguments non par défaut ne peuvent pas suivre les arguments par défaut. Par exemple, si nous avions défini l'en-tête de la fonction ci-dessus comme :
def greet(msg = "Good morning!", name):
Nous obtiendrions une erreur comme :
SyntaxError: non-default argument follows default argument
Arguments des mots clés Python
Lorsque nous appelons une fonction avec certaines valeurs, ces valeurs sont affectées aux arguments en fonction de leur position.
Par exemple, dans la fonction ci-dessus greet() , lorsque nous l'avons appelé greet("Bruce", "How do you do?") , la valeur "Bruce" est assigné à l'argument nom et de même "How do you do?" à msg .
Python permet d'appeler des fonctions à l'aide d'arguments de mots-clés. Lorsque nous appelons des fonctions de cette manière, l'ordre (position) des arguments peut être modifié. Les appels suivants à la fonction ci-dessus sont tous valides et produisent le même résultat.
# 2 keyword arguments
greet(name = "Bruce",msg = "How do you do?")
# 2 keyword arguments (out of order)
greet(msg = "How do you do?",name = "Bruce")
1 positional, 1 keyword argument
greet("Bruce", msg = "How do you do?") Comme nous pouvons le voir, nous pouvons mélanger des arguments de position avec des arguments de mots-clés lors d'un appel de fonction. Mais nous devons garder à l'esprit que les arguments de mot-clé doivent suivre les arguments de position.
Avoir un argument de position après les arguments de mots-clés entraînera des erreurs. Par exemple, l'appel de fonction comme suit :
greet(name="Bruce","How do you do?") Entraînera une erreur :
SyntaxError: non-keyword arg after keyword arg
Arguments arbitraires Python
Parfois, on ne sait pas à l'avance le nombre d'arguments qui seront passés dans une fonction. Python nous permet de gérer ce genre de situation grâce à des appels de fonction avec un nombre arbitraire d'arguments.
Dans la définition de la fonction, nous utilisons un astérisque (*) avant le nom du paramètre pour désigner ce type d'argument. Voici un exemple.
def greet(*names):
"""This function greets all
the person in the names tuple."""
# names is a tuple with arguments
for name in names:
print("Hello", name)
greet("Monica", "Luke", "Steve", "John") Sortie
Hello Monica Hello Luke Hello Steve Hello John
Ici, nous avons appelé la fonction avec plusieurs arguments. Ces arguments sont regroupés dans un tuple avant d'être transmis à la fonction. Dans la fonction, nous utilisons un for boucle pour récupérer tous les arguments.
Python