Utilisation de *args et **kwargs

Question

J'ai donc des difficultés avec le concept de *args y **kwargs .

Jusqu'à présent, j'ai appris que :

• *args = liste d'arguments - en tant qu'arguments positionnels
• **kwargs = dictionnaire - dont les clés deviennent des arguments de mots-clés distincts et les valeurs deviennent des valeurs de ces arguments.

Je ne comprends pas en quoi cette tâche de programmation serait utile.

Peut-être :

Je pense entrer des listes et des dictionnaires comme arguments d'une fonction ET en même temps comme joker, donc je peux passer N'IMPORTE QUEL argument ?

Existe-t-il un exemple simple pour expliquer comment *args y **kwargs sont utilisés ?

De plus, le tutoriel que j'ai trouvé utilisait juste le "*" et un nom de variable.

Sont *args y **kwargs juste des emplacements ou utilisez-vous exactement *args y **kwargs dans le code ?

Answer 1

La syntaxe est la suivante * y ** . Les noms *args y **kwargs ne le sont que par convention, mais il n'y a aucune obligation de les utiliser.

Vous utiliseriez *args lorsque vous n'êtes pas sûr du nombre d'arguments qui peuvent être passés à votre fonction, c'est-à-dire qu'elle vous permet de passer un nombre arbitraire d'arguments à votre fonction. Par exemple :

>>> def print_everything(*args):
        for count, thing in enumerate(args):
...         print( '{0}. {1}'.format(count, thing))
...
>>> print_everything('apple', 'banana', 'cabbage')
0. apple
1. banana
2. cabbage

De même, **kwargs vous permet de gérer des arguments nommés que vous n'avez pas définis à l'avance :

>>> def table_things(**kwargs):
...     for name, value in kwargs.items():
...         print( '{0} = {1}'.format(name, value))
...
>>> table_things(apple = 'fruit', cabbage = 'vegetable')
cabbage = vegetable
apple = fruit

Vous pouvez également les utiliser avec les arguments nommés. Les arguments explicites obtiennent des valeurs en premier et ensuite tout le reste est passé à *args y **kwargs . Les arguments nommés viennent en premier dans la liste. Par exemple :

def table_things(titlestring, **kwargs)

Vous pouvez également utiliser les deux dans la même définition de fonction mais *args doit se produire avant **kwargs .

Vous pouvez également utiliser le * y ** lors de l'appel d'une fonction. Par exemple :

>>> def print_three_things(a, b, c):
...     print( 'a = {0}, b = {1}, c = {2}'.format(a,b,c))
...
>>> mylist = ['aardvark', 'baboon', 'cat']
>>> print_three_things(*mylist)
a = aardvark, b = baboon, c = cat

Comme vous pouvez le voir dans ce cas, il prend la liste (ou le tuple) d'éléments et la décompose. Ainsi, il les fait correspondre aux arguments de la fonction. Bien sûr, vous pourriez avoir un * à la fois dans la définition de la fonction et dans l'appel de la fonction.

Answer 2

Un endroit où l'utilisation de *args y **kwargs est très utile pour la sous-classification.

class Foo(object):
    def __init__(self, value1, value2):
        # do something with the values
        print value1, value2

class MyFoo(Foo):
    def __init__(self, *args, **kwargs):
        # do something else, don't care about the args
        print 'myfoo'
        super(MyFoo, self).__init__(*args, **kwargs)

De cette façon, vous pouvez étendre le comportement de la classe Foo, sans avoir à en savoir trop sur Foo. Cela peut être très pratique si vous programmez pour une API qui pourrait changer. MyFoo passe simplement tous les arguments à la classe Foo.

Answer 3

Voici un exemple qui utilise 3 types de paramètres différents.

def func(required_arg, *args, **kwargs):
    # required_arg is a positional-only parameter.
    print required_arg

    # args is a tuple of positional arguments,
    # because the parameter name has * prepended.
    if args: # If args is not empty.
        print args

    # kwargs is a dictionary of keyword arguments,
    # because the parameter name has ** prepended.
    if kwargs: # If kwargs is not empty.
        print kwargs

>>> func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: func() takes at least 1 argument (0 given)

>>> func("required argument")
required argument

>>> func("required argument", 1, 2, '3')
required argument
(1, 2, '3')

>>> func("required argument", 1, 2, '3', keyword1=4, keyword2="foo")
required argument
(1, 2, '3')
{'keyword2': 'foo', 'keyword1': 4}

Answer 4

Voici l'un de mes endroits préférés pour utiliser les ** syntaxe comme dans le dernier exemple de Dave Webb :

mynum = 1000
mystr = 'Hello World!'
print("{mystr} New-style formatting is {mynum}x more fun!".format(**locals()))

Je ne sais pas si c'est terriblement rapide par rapport à l'utilisation des noms eux-mêmes, mais c'est beaucoup plus facile à taper !

Answer 5

Un cas où *args et **kwargs sont utiles est celui de l'écriture de fonctions enveloppes (comme les décorateurs) qui doivent pouvoir accepter des arguments arbitraires à transmettre à la fonction enveloppée. Par exemple, un décorateur simple qui imprime les arguments et la valeur de retour de la fonction enveloppée :

def mydecorator( f ):
   @functools.wraps( f )
   def wrapper( *args, **kwargs ):
      print "Calling f", args, kwargs
      v = f( *args, **kwargs )
      print "f returned", v
      return v
   return wrapper