Que font ** (double étoile/astérisque) et * (étoile/astérisque) pour les paramètres ?

Question

Dans les définitions de méthodes suivantes, que fait le * et ** faire pour param2 ?

def foo(param1, *param2):
def bar(param1, **param2):

Answer 1

Le site *args et **kwargs est une idiome commune pour permettre un nombre arbitraire d'arguments aux fonctions comme décrit dans la section plus sur la définition des fonctions dans la documentation Python.

Le site *args vous donnera tous les paramètres de la fonction comme un tuple :

def foo(*args):
    for a in args:
        print(a)        

foo(1)
# 1

foo(1,2,3)
# 1
# 2
# 3

Le site **kwargs vous donnera tout arguments de mots-clés sauf ceux qui correspondent à un paramètre formel comme un dictionnaire.

def bar(**kwargs):
    for a in kwargs:
        print(a, kwargs[a])  

bar(name='one', age=27)
# name one
# age 27

Les deux idiomes peuvent être mélangés avec des arguments normaux pour permettre un ensemble d'arguments fixes et certains variables :

def foo(kind, *args, **kwargs):
   pass

Il est également possible de l'utiliser dans l'autre sens :

def foo(a, b, c):
    print(a, b, c)

obj = {'b':10, 'c':'lee'}

foo(100,**obj)
# 100 10 lee

Une autre utilisation de la *l L'idiome est dépaqueter les listes d'arguments lors de l'appel d'une fonction.

def foo(bar, lee):
    print(bar, lee)

l = [1,2]

foo(*l)
# 1 2

En Python 3, il est possible d'utiliser la fonction *l à gauche d'une affectation ( Déballage d'un Iterable étendu ), bien qu'il donne une liste au lieu d'un tuple dans ce contexte :

first, *rest = [1,2,3,4]
first, *l, last = [1,2,3,4]

De plus, Python 3 ajoute une nouvelle sémantique (référence PEP 3102 ) :

def func(arg1, arg2, arg3, *, kwarg1, kwarg2):
    pass

Une telle fonction n'accepte que 3 arguments positionnels, et tout ce qui suit * ne peuvent être passés que comme arguments de mots-clés.

Note :

• Un python dict utilisés sémantiquement pour le passage des arguments des mots-clés, sont ordonnés arbitrairement. Toutefois, dans Python 3.6, il est garanti que les arguments des mots-clés se souviennent de l'ordre d'insertion.
• "L'ordre des éléments dans **kwargs correspond maintenant à l'ordre dans lequel les arguments des mots-clés ont été passés à la fonction." - Nouveautés de Python 3.6
• En fait, tous les dicts dans CPython 3.6 se souviendront de l'ordre d'insertion comme d'un détail d'implémentation, ceci devient standard dans Python 3.7.

Answer 2

Il est également intéressant de noter que vous pouvez utiliser * et ** lors de l'appel de fonctions également. Il s'agit d'un raccourci qui vous permet de passer plusieurs arguments à une fonction directement en utilisant soit une liste/tuple soit un dictionnaire. Par exemple, si vous avez la fonction suivante :

def foo(x,y,z):
    print("x=" + str(x))
    print("y=" + str(y))
    print("z=" + str(z))

Tu peux faire des choses comme :

>>> mylist = [1,2,3]
>>> foo(*mylist)
x=1
y=2
z=3

>>> mydict = {'x':1,'y':2,'z':3}
>>> foo(**mydict)
x=1
y=2
z=3

>>> mytuple = (1, 2, 3)
>>> foo(*mytuple)
x=1
y=2
z=3

Remarque : Les touches dans mydict doivent être nommés exactement comme les paramètres de la fonction foo . Sinon, un TypeError :

>>> mydict = {'x':1,'y':2,'z':3,'badnews':9}
>>> foo(**mydict)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() got an unexpected keyword argument 'badnews'

Answer 3

Le simple * signifie qu'il peut y avoir un nombre quelconque d'arguments positionnels supplémentaires. foo() peut être invoqué comme foo(1,2,3,4,5) . Dans le corps de foo() param2 est une séquence contenant 2-5.

Le double ** signifie qu'il peut y avoir un nombre quelconque de paramètres supplémentaires nommés. bar() peut être invoqué comme bar(1, a=2, b=3) . Dans le corps de bar() param2 est un dictionnaire contenant {'a':2, 'b':3 }

Avec le code suivant :

def foo(param1, *param2):
    print(param1)
    print(param2)

def bar(param1, **param2):
    print(param1)
    print(param2)

foo(1,2,3,4,5)
bar(1,a=2,b=3)

le résultat est

1
(2, 3, 4, 5)
1
{'a': 2, 'b': 3}

Answer 4

* et ** ont un usage particulier dans la liste des arguments de la fonction. * implique que l'argument est une liste et ** implique que l'argument est un dictionnaire. Cela permet aux fonctions de prendre un nombre arbitraire de arguments

Answer 5

Extrait de la documentation Python :

S'il y a plus d'arguments positionnels que d'emplacements de paramètres formels, une exception TypeError est levée, sauf si un paramètre formel utilisant la syntaxe "*identifier" est présent ; dans ce cas, ce paramètre formel reçoit un tuple contenant les arguments positionnels en excès (ou un tuple vide s'il n'y avait pas d'arguments positionnels en excès).

Si un argument de mot-clé ne correspond pas à un nom de paramètre formel, une exception TypeError est levée, à moins qu'un paramètre formel utilisant la syntaxe "**identifier" soit présent ; dans ce cas, ce paramètre formel reçoit un dictionnaire contenant les arguments de mot-clé excédentaires (en utilisant les mots-clés comme clés et les valeurs d'argument comme valeurs correspondantes), ou un (nouveau) dictionnaire vide s'il n'y avait pas d'arguments de mot-clé excédentaires.