En quoi les "arguments de mots clés" sont-ils différents des arguments classiques? Tous les arguments ne peuvent-ils pas être passés au name=valuelieu d'utiliser la syntaxe positionnelle?

Il existe deux concepts connexes, tous deux appelés " arguments de mots clés ".

Du côté appelant, ce que d'autres commentateurs ont mentionné, vous avez la possibilité de spécifier certains arguments de fonction par nom. Vous devez les mentionner après tous les arguments sans nom ( arguments positionnels ), et il doit y avoir des valeurs par défaut pour tous les paramètres qui n'ont pas été mentionnés du tout.

L'autre concept est du côté de la définition de fonction: vous pouvez définir une fonction qui prend les paramètres par nom - et vous n'avez même pas besoin de spécifier quels sont ces noms. Ce sont des arguments de mots clés purs et ne peuvent pas être passés de manière positionnelle. La syntaxe est

def my_function(arg1, arg2, **kwargs)

Tous les arguments de mots clés que vous transmettez à cette fonction seront placés dans un dictionnaire nommé kwargs. Vous pouvez examiner les clés de ce dictionnaire au moment de l'exécution, comme ceci:

def my_function(**kwargs):
    print str(kwargs)

my_function(a=12, b="abc")

{'a': 12, 'b': 'abc'}

Il y a une dernière fonction linguistique où la distinction est importante. Considérez la fonction suivante:

def foo(*positional, **keywords):
    print "Positional:", positional
    print "Keywords:", keywords

L' *positionalargument stockera tous les arguments de position transmis à foo(), sans limite au nombre que vous pouvez fournir.

>>> foo('one', 'two', 'three')
Positional: ('one', 'two', 'three')
Keywords: {}

L' **keywordsargument stockera tous les arguments de mots clés:

>>> foo(a='one', b='two', c='three')
Positional: ()
Keywords: {'a': 'one', 'c': 'three', 'b': 'two'}

Et bien sûr, vous pouvez utiliser les deux en même temps:

>>> foo('one','two',c='three',d='four')
Positional: ('one', 'two')
Keywords: {'c': 'three', 'd': 'four'}

Ces fonctionnalités sont rarement utilisées, mais elles sont parfois très utiles, et il est important de savoir quels arguments sont positionnels ou mots-clés.

L'utilisation d'arguments de mots clés est la même chose que les arguments normaux, sauf que l'ordre n'a pas d'importance. Par exemple, les deux appels de fonctions ci-dessous sont identiques:

def foo(bar, baz):
    pass

foo(1, 2)
foo(baz=2, bar=1)

Arguments positionnels

Ils n'ont aucun mot clé devant eux. L'ordre est important!

func(1,2,3, "foo")

Arguments des mots clés

Ils ont des mots clés à l'avant. Ils peuvent être dans n'importe quel ordre!

func(foo="bar", baz=5, hello=123)

func(baz=5, foo="bar", hello=123)

Vous devez également savoir que si vous utilisez des arguments par défaut et négligez d'insérer les mots clés, l'ordre importera alors!

def func(foo=1, baz=2, hello=3): ...
func("bar", 5, 123)

Il existe deux façons d'affecter des valeurs d'argument aux paramètres de fonction, les deux sont utilisées.

1. Par position. Les arguments positionnels n'ont pas de mots clés et sont attribués en premier.

2. Par mot-clé. Les arguments de mot-clé ont des mots-clés et sont attribués en second, après les arguments de position.

Notez que vous avez la possibilité d'utiliser des arguments positionnels.

Si vous n'utilisez pas d'arguments positionnels, alors - oui - tout ce que vous avez écrit se révèle être un argument mot-clé.

Lorsque vous appelez une fonction, vous décidez d'utiliser la position, le mot-clé ou un mélange. Vous pouvez choisir de faire tous les mots clés si vous le souhaitez. Certains d'entre nous ne font pas ce choix et utilisent des arguments positionnels.

Je suis surpris que personne ne semble avoir souligné que l'on peut passer un dictionnaire de paramètres d'argument à clé, qui satisfont les paramètres formels, comme ça.

>>> def func(a='a', b='b', c='c', **kwargs):
...    print 'a:%s, b:%s, c:%s' % (a, b, c)
... 
>>> func()
a:a, b:b, c:c
>>> func(**{'a' : 'z', 'b':'q', 'c':'v'})
a:z, b:q, c:v
>>> 

En utilisant Python 3, vous pouvez avoir à la fois des arguments de mots clés requis et non requis :

Facultatif : (valeur par défaut définie pour le paramètre 'b')

def func1(a, *, b=42):
    ...
func1(value_for_a) # b is optional and will default to 42

Obligatoire (aucune valeur par défaut définie pour le paramètre 'b'):

def func2(a, *, b):
    ... 
func2(value_for_a, b=21) # b is set to 21 by the function call
func2(value_for_a) # ERROR: missing 1 required keyword-only argument: 'b'`

Cela peut aider dans les cas où vous avez de nombreux arguments similaires les uns à côté des autres, surtout s'ils sont du même type, dans ce cas, je préfère utiliser des arguments nommés ou je crée une classe personnalisée si les arguments vont de pair.

Je suis surpris que personne n'ait mentionné le fait que vous pouvez mélanger des arguments de position et de mots clés pour faire des choses sournoises comme celle-ci en utilisant *argset **kwargs(à partir de ce site ):

def test_var_kwargs(farg, **kwargs):
    print "formal arg:", farg
    for key in kwargs:
        print "another keyword arg: %s: %s" % (key, kwargs[key])

Cela vous permet d'utiliser des arguments de mots clés arbitraires qui peuvent avoir des clés que vous ne souhaitez pas définir à l'avance.

Je cherchais un exemple qui avait des kwargs par défaut en utilisant l'annotation de type:

def test_var_kwarg(a: str, b: str='B', c: str='', **kwargs) -> str:
     return ' '.join([a, b, c, str(kwargs)])

exemple:

>>> print(test_var_kwarg('A', c='okay'))
A B okay {}
>>> d = {'f': 'F', 'g': 'G'}
>>> print(test_var_kwarg('a', c='c', b='b', **d))
a b c {'f': 'F', 'g': 'G'}
>>> print(test_var_kwarg('a', 'b', 'c'))
a b c {}

Il suffit de compléter / ajouter un moyen de définir la valeur par défaut des arguments qui ne sont pas attribués en mots clés lors de l'appel de la fonction:

def func(**keywargs):
if 'my_word' not in keywargs:
    word = 'default_msg'
else:
    word = keywargs['my_word']
return word

appelez cela par:

print(func())
print(func(my_word='love'))

tu auras:

default_msg
love

en savoir plus sur *argset **kwargsen python: https://www.digitalocean.com/community/tutorials/how-to-use-args-and-kwargs-in-python-3