Czym różnią się „argumenty słów kluczowych” od zwykłych argumentów? Czy nie można przekazać wszystkich argumentów jako name=valuezamiast używania składni pozycyjnej?

Istnieją dwa powiązane pojęcia, oba nazywane „ argumentami słów kluczowych ”.

Po stronie wywołującej, o której wspominali inni komentatorzy, możesz podać niektóre argumenty funkcji według nazwy. Musisz wymienić je po wszystkich argumentach bez nazw ( argumenty pozycyjne ) i muszą istnieć wartości domyślne dla parametrów, które w ogóle nie zostały wymienione.

Druga koncepcja dotyczy definicji funkcji: możesz zdefiniować funkcję, która pobiera parametry według nazwy - i nie musisz nawet określać, jakie są te nazwy. Są to czyste argumenty słów kluczowych i nie można ich przekazywać pozycyjnie. Składnia jest następująca

def my_function(arg1, arg2, **kwargs)

Wszelkie argumenty słów kluczowych przekazane do tej funkcji zostaną umieszczone w słowniku o nazwie kwargs. Możesz sprawdzić klucze tego słownika w czasie wykonywania, w następujący sposób:

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

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

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

Jest jeszcze jedna ostatnia cecha językowa, w której rozróżnienie jest ważne. Rozważ następującą funkcję:

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

*positionalArgumentem będzie przechowywać wszystkie argumenty przekazywane do pozycyjnych foo(), bez limitu do ilu można zapewnić.

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

**keywordsArgumentem będzie przechowywać żadnych argumentów słowa kluczowego:

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

I oczywiście możesz korzystać z obu jednocześnie:

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

Te funkcje są rzadko używane, ale czasami są bardzo przydatne i ważne jest, aby wiedzieć, które argumenty są pozycjonujące lub słowa kluczowe.

Używanie argumentów słów kluczowych jest tym samym, co zwykłe argumenty, tyle że kolejność nie ma znaczenia. Na przykład dwie poniższe funkcje są takie same:

def foo(bar, baz):
    pass

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

Argumenty pozycyjne

Nie mają przed nimi słów kluczowych. Kolejność jest ważna!

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

Argumenty słów kluczowych

Mają słowa kluczowe z przodu. Mogą być w dowolnej kolejności!

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

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

Powinieneś także wiedzieć, że jeśli użyjesz domyślnych argumentów i zaniedbasz wstawianie słów kluczowych, wtedy kolejność będzie miała znaczenie!

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

Istnieją dwa sposoby przypisywania wartości argumentów do parametrów funkcji, oba są używane.

1. Według pozycji. Argumenty pozycyjne nie mają słów kluczowych i są przypisywane jako pierwsze.

2. Według słowa kluczowego. Argumenty słów kluczowych zawierają słowa kluczowe i są przypisywane jako drugie, po argumentach pozycyjnych.

Zauważ, że masz opcję użycia argumentów pozycyjnych.

Jeśli ty nie używać argumentów pozycyjnych, a następnie - tak - wszystko Ci napisałem okazuje się być argumentem kluczowym.

Kiedy ty wywołać funkcję w podjęciu decyzji do pozycji użytkowej lub słowa kluczowego lub mieszaniny. Jeśli chcesz, możesz wybrać wykonanie wszystkich słów kluczowych. Niektórzy z nas nie dokonują tego wyboru i używają argumentów pozycyjnych.

Dziwi mnie, że nikt nie zauważył, że można przekazać słownik kluczowych parametrów argumentu, które spełniają parametry formalne.

>>> 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
>>> 

Korzystanie Python 3 można mieć zarówno wymagane, a nie wymaganych słów kluczowych argumentów :

Opcjonalne : (wartość domyślna zdefiniowana dla parametru „b”)

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

Wymagane (nie zdefiniowano wartości domyślnej dla parametru „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'`

Może to pomóc w przypadkach, gdy masz wiele podobnych argumentów obok siebie, szczególnie jeśli są one tego samego typu, w takim przypadku wolę używać nazwanych argumentów lub tworzę niestandardową klasę, jeśli argumenty należą do siebie.

Dziwię się, że nikt nie wspominał o tym, że można łączyć argumenty pozycyjne i słowa kluczowego, aby robić podstępne rzeczy przy użyciu *argsi **kwargs( z tej strony ):

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

Pozwala to na użycie dowolnych argumentów słów kluczowych, które mogą mieć klucze, których nie chcesz definiować z góry.

Szukałem przykładu z domyślnymi kwargsami wykorzystującymi adnotacje typu:

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

przykład:

>>> 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 {}

Wystarczy uzupełnić / dodać sposób definiowania domyślnej wartości argumentów, które nie są przypisywane słowami kluczowymi podczas wywoływania funkcji:

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

nazwij to przez:

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

dostaniesz:

default_msg
love

czytaj więcej na temat *argsoraz **kwargsw python: https://www.digitalocean.com/community/tutorials/how-to-use-args-and-kwargs-in-python-3