Arguments de fonction en

À propos de Arguments de fonction

Pour les bases sur les arguments de fonction, consulte le concept de fonction.

Noms des paramètres

Les noms de paramètres, comme les noms de variables, doivent commencer par une lettre ou un tiret bas, et peuvent contenir des lettres, des tirets bas ou des chiffres. Les noms de paramètres ne doivent pas contenir d'espaces ni de ponctuation.

Arguments positionnels

Les arguments positionnels sont des valeurs transmises à une fonction dans le même ordre que les paramètres auxquels ils sont liés. On peut aussi les passer en utilisant le nom de leur paramètre, ce qui est facultatif :

def concat(greeting, name):
    return f"{greeting}{name}"

# Passing data to the function by position.
print(concat("Hello, ", "Lilly"))
#->  Hello, Lilly

# Passing data to the function using the parameter name.
print(concat(name="Glenn", greeting="Hello, "))
#-> Hello, Glenn

Le premier appel à concat passe les arguments par position. Le second appel à concat passe les arguments par nom, ce qui permet de modifier leur position.

Note que les arguments positionnels ne peuvent pas suivre des arguments passés par nom (aussi appelés arguments nommés. À ne pas confondre avec les paramètres positionnels variables ni avec **kwargs).

Cet ensemble d'arguments :

print(concat(greeting="Hello, ", "Gregor"))

Produit cette erreur :

SyntaxError: positional argument follows keyword argument

On peut exiger des arguments exclusivement positionnels lors de l'appel d'une fonction en utilisant l'opérateur / dans la liste des paramètres :

# Parameters showing a position-only operator. 
def concat(greeting, name, /):
    return f"{greeting}{name}"

print(concat("Hello, ", "Ginnie"))
#-> Hello, Ginnie

# Call to the function using keyword arguments.
print(concat(name="Franklin", greeting="Hello, "))
Traceback (most recent call last):
    print(concat(name="Franklin", greeting="Hello, "))
TypeError: concat() got some positional-only arguments passed as keyword arguments: 'greeting, name'

Arguments nommés

Les arguments nommés utilisent le nom du paramètre lors de l'appel d'une fonction. On peut aussi les désigner par leur position, ce qui est facultatif :

def concat(greeting, name):
    return f"{greeting}{name}"

# Function call using parameter names as argument keywords.
print(concat(name="Eliza", greeting="Hello, "))
#-> Hello, Eliza

# Function call with positional data as arguments.
print(concat("Hello, ", "Tim"))
#-> Hello, Tim

On peut exiger des arguments exclusivement nommés lors de l'appel d'une fonction en utilisant l'opérateur * dans la liste des paramètres :

# Function definition requiring keyword-only arguments.
def concat(*, greeting, name):
    return f"{greeting}{name}"

# Keyword arguments can be in an arbitrary order.
print(concat(name="Kimmie", greeting="Hello, "))
#-> Hello, Kimmie

# Calling the function with positional data raises an error.
print(concat("Hello, ", "Coleen"))
Traceback (most recent call last):
    print(concat("Hello, ", "Coleen"))
TypeError: concat() takes 0 positional arguments but 2 were given

Valeurs par défaut des arguments

On peut fournir des valeurs par défaut pour un ou plusieurs arguments dans la liste des paramètres. Cela permet d'appeler la fonction avec moins d'arguments si besoin. Ces valeurs par défaut peuvent être écrasées en appelant la fonction avec une nouvelle valeur d'argument :

# Function with default argument values.
def concat(greeting, name="you", punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

print(concat("Hello"))
#-> Hello, you!

# Overriding the default values
print(concat("Hello", name="Polly", punctuation="."))
#-> Hello, Polly.

Arguments positionnels ou nommés

Les arguments peuvent être positionnels ou nommés si ni l'opérateur / ni l'opérateur * ne sont utilisés dans la définition des paramètres. Autrement, on peut placer les arguments positionnels ou nommés entre les paramètres exclusivement positionnels à gauche et les paramètres exclusivement nommés à droite :

# Position-only argument followed by position-or-keyword, followed by keyword-only.
def concat(greeting, /, name, *, ending):
    return f"{greeting}{name}{ending}"

print(concat("Hello, ", "Mark", ending="!"))
#-> Hello, Mark!

print(concat("Hello, ", name="Rachel", ending="!"))
#-> Hello, Rachel!

print(concat(greeting="Hello, ", name="JoJo", ending="!"))
Traceback (most recent call last):
    print(concat(greeting="Hello, ", name="JoJo", ending="!"))
TypeError: concat() got some positional-only arguments passed as keyword arguments: 'greeting'

*args

Les exemples de code utilisent souvent une définition de fonction ressemblant à ceci :

def my_function(*args, **kwargs):
    # code snipped

*args est un nom en deux parties qui représente un tuple contenant un nombre indéfini d'arguments positionnels séparés, aussi appelé variadic argument. args est le nom donné au tuple d'arguments, mais il pourrait s'agir de n'importe quel autre nom Python valide, comme my_args, arguments, etc. Le * est l'opérateur qui transforme le groupe d'arguments séparés en un tuple.

Comme on peut itérer sur un tuple, args peut être transmis à n'importe quelle autre fonction qui prend un itérable. Bien que *args soit souvent juxtaposé à **kwargs, ce n'est pas obligatoire :

def add(*args):
    # args is passed to the sum function, which iterates over it.
    return sum(args)

print(add(1, 2, 3))
#-> 6

Si *args suit un ou plusieurs arguments positionnels, alors *args contiendra ce qui reste après ces arguments positionnels :

def add(first, *args):
    # first will be 1, leaving the values 2 and 3 in *args
    return first + sum(args)

print(add(1, 2, 3))
#-> 6

Si un ou plusieurs arguments par défaut sont définis après *args, ils sont distincts des valeurs de *args :

def add(first, *args, last=0):
    return first + sum(args) + last
 
print(add(1, 2, 3))
#-> 6

print(add(1, 2, 3, last=4))
#-> 10

# This uses the unpacking operator * to separate the list elements into positional arguments.
# It does not have the same behavior as the * (packing) in *args.
print(add(*[1, 2, 3]))
#-> 6

Note que lorsqu'un argument se trouve déjà à l'intérieur d'un iterable (comme un tuple ou une list), il faut le dépaqueter avant de le transmettre à une fonction qui prend un nombre arbitraire d'arguments séparés. On y parvient en utilisant *, qui est l'opérateur de dépaquetage.

Dans ce contexte, * dépaquette le conteneur en ses éléments séparés, que *args transforme ensuite en un tuple. Lorsqu'il n'y a que des arguments positionnels, le dépaquetage doit produire autant d'arguments qu'il y a de paramètres formels définis.

Sans dépaqueter la liste passée à add, le programme produirait une erreur :

def add(first, *args, last=0):
    return first + sum(args) + last

print(add([1, 2, 3]))
Traceback (most recent call last):
    print(add([1, 2, 3]))
    return first + sum(args) + last
TypeError: can only concatenate list (not "int") to list

**kwargs

**kwargs est un nom en deux parties qui représente un nombre indéfini d'arguments séparés de type paire clé-valeur. kwargs est le nom du groupe d'arguments et pourrait être n'importe quel autre nom, comme my_args, arguments, etc. Le ** transforme le groupe d'arguments nommés en un dictionary de paires {argument name: argument value}.

Comme on peut itérer sur un dictionnaire, kwargs peut être transmis à n'importe quelle autre fonction qui prend un itérable. Bien que **kwargs soit souvent juxtaposé à *args, ce n'est pas obligatoire :

def add(**kwargs):
    return sum(kwargs.values())

print(add(one=1, two=2, three=3))
#-> 6

Note que la méthode dict.values() est appelée pour parcourir les values du dictionnaire kwargs. Lorsqu'on itère sur un dictionnaire, le comportement par défaut est de parcourir les keys, il faut donc préciser dict.values() explicitement :

def concat(**kwargs):
    # Join concatenates the tuples from `kwargs.items()`
    return " ".join((str(item) for item in kwargs.items()))

print(concat(one=1, two=2, three=3))
#-> ('one', 1) ('two', 2) ('three', 3)