Jaki jest cel i zastosowanie * * kwargs?

Rozpakowywanie słowników

** rozpakowuje słowniki.

To

func(a=1, b=2, c=3)

Jest tym samym co

args = {'a': 1, 'b': 2, 'c':3}
func(**args)

Jest to przydatne, jeśli trzeba konstruować parametry:

args = {'name': person.name}
if hasattr(person, "address"):
    args["address"] = person.address
func(**args)  # either expanded to func(name=person.name) or
              #                    func(name=person.name, address=person.address)

Parametry pakowania funkcji

def setstyle(**styles):
    for key, value in styles.iteritems():      # styles is a regular dictionary
        setattr(someobject, key, value)

To pozwala używać funkcji w ten sposób:

setstyle(color="red", bold=False)

Kwargs to tylko słownik, który jest dodawany do parametrów.

Słownik może zawierać pary klucz, wartość. A to są kwargowie. Ok, oto jak.

Na przykład (bardzo hipotetycznie) masz interfejs, który wywołuje inne procedury do wykonania zadania:

def myDo(what, where, why):
   if what == 'swim':
      doSwim(where, why)
   elif what == 'walk':
      doWalk(where, why)
   ...

Teraz otrzymujesz nową metodę "drive":

elif what == 'drive':
   doDrive(where, why, vehicle)

Ale zaraz, jest nowy parametr "pojazd" -- nie znałeś go wcześniej. Teraz musisz dodać go do sygnatura funkcji myDo.

Tutaj możesz wrzucić kwargsa do gry-wystarczy dodać kwargsa do podpisu:

def myDo(what, where, why, **kwargs):
   if what == 'drive':
      doDrive(where, why, **kwargs)
   elif what == 'swim':
      doSwim(where, why, **kwargs)

W ten sposób nie musisz zmieniać podpisu funkcji interfejsu za każdym razem, gdy niektóre z wywoływanych procedur mogą się zmienić.

To tylko jeden miły przykład, który może okazać się pomocny dla kwargsa.

Na podstawie tego, że dobra próbka jest czasami lepsza niż długi dyskurs, napiszę dwie funkcje używając wszystkich funkcji przekazujących argumenty zmiennych Pythona (zarówno pozycyjnych, jak i nazwanych). Powinieneś być w stanie zobaczyć, co robi Sam:

def f(a = 0, *args, **kwargs):
    print("Received by f(a, *args, **kwargs)")
    print("=> f(a=%s, args=%s, kwargs=%s" % (a, args, kwargs))
    print("Calling g(10, 11, 12, *args, d = 13, e = 14, **kwargs)")
    g(10, 11, 12, *args, d = 13, e = 14, **kwargs)

def g(f, g = 0, *args, **kwargs):
    print("Received by g(f, g = 0, *args, **kwargs)")
    print("=> g(f=%s, g=%s, args=%s, kwargs=%s)" % (f, g, args, kwargs))

print("Calling f(1, 2, 3, 4, b = 5, c = 6)")
f(1, 2, 3, 4, b = 5, c = 6)

A oto Wyjście:

Calling f(1, 2, 3, 4, b = 5, c = 6)
Received by f(a, *args, **kwargs) 
=> f(a=1, args=(2, 3, 4), kwargs={'c': 6, 'b': 5}
Calling g(10, 11, 12, *args, d = 13, e = 14, **kwargs)
Received by g(f, g = 0, *args, **kwargs)
=> g(f=10, g=11, args=(12, 2, 3, 4), kwargs={'c': 6, 'b': 5, 'e': 14, 'd': 13})

Motif: *args i **kwargs służy jako symbol zastępczy dla argumentów, które muszą zostać przekazane do wywołania funkcji

Użycie *args i **kwargs do wywołania funkcji

def args_kwargs_test(arg1, arg2, arg3):
    print "arg1:", arg1
    print "arg2:", arg2
    print "arg3:", arg3

Teraz użyjemy *args do wywołania powyższej zdefiniowanej funkcji

#args can either be a "list" or "tuple"
>>> args = ("two", 3, 5)  
>>> args_kwargs_test(*args)

Wynik:

Arg1: dwa
arg2: 3
arg3: 5

Teraz, używając **kwargs do wywołania tej samej funkcji

#keyword argument "kwargs" has to be a dictionary
>>> kwargs = {"arg3":3, "arg2":'two', "arg1":5}
>>> args_kwargs_test(**kwargs)

Wynik:

Arg1: 5
arg2: dwa
arg3: 3

Bottomline: *args nie ma inteligencji, po prostu interpoluje przekazane args do parametrów (w kolejności od lewej do prawej), podczas gdy **kwargs zachowuje się inteligentnie, umieszczając odpowiednią wartość @ wymagane miejsce

• kwargs w **kwargs jest tylko nazwą zmiennej. Możesz bardzo dobrze mieć **anyVariableName
• kwargs oznacza "argumenty słów kluczowych". Ale uważam, że lepiej je nazywać "nazwanymi argumentami", ponieważ są to po prostu argumenty przekazywane wraz z nazwami (nie znajduję żadnego znaczenia dla słowa "keyword" w słowie "keyword arguments". Domyślam się, że słowo kluczowe zwykle oznacza słowa zarezerwowane przez język programowania i dlatego nie może być używane przez programistę do nazw zmiennych. Nic takiego się nie dzieje tutaj w przypadku kwargów.). Więc podajemy nazwiska param1 i param2 do dwóch wartości parametrów przekazywanych do funkcji w następujący sposób: func(param1="val1",param2="val2"), zamiast przekazywania tylko wartości: func(val1,val2). Dlatego uważam, że powinny one być odpowiednio nazywane "dowolną liczbą nazwanych argumentów" , ponieważ możemy określić dowolną liczbę tych parametrów (czyli argumentów), jeśli func ma podpis func(**kwargs)

Więc powiem, że najpierw wyjaśnię "nazwane argumenty", a potem " dowolną liczbę nazwanych argumentów" kwargs.

Nazwane argumenty

• nazwane args powinny podążać za pozycyjnymi args
• kolejność nazw args nie jest ważna

• Przykład

  def function1(param1,param2="arg2",param3="arg3"):
      print("\n"+str(param1)+" "+str(param2)+" "+str(param3)+"\n")
  
  function1(1)                      #1 arg2 arg3   #1 positional arg
  function1(param1=1)               #1 arg2 arg3   #1 named arg
  function1(1,param2=2)             #1 2 arg3      #1 positional arg, 1 named arg
  function1(param1=1,param2=2)      #1 2 arg3      #2 named args       
  function1(param2=2, param1=1)     #1 2 arg3      #2 named args out of order
  function1(1, param3=3, param2=2)  #1 2 3         #
  
  #function1()                      #invalid: required argument missing
  #function1(param2=2,1)            #invalid: SyntaxError: non-keyword arg after keyword arg
  #function1(1,param1=11)           #invalid: TypeError: function1() got multiple values for argument 'param1'
  #function1(param4=4)              #invalid: TypeError: function1() got an unexpected keyword argument 'param4'
  

Dowolna liczba nazwanych argumentów kwargs

• Sekwencja parametrów funkcji:
  1. parametry pozycyjne
  2. parametr formalny przechwytujący dowolną liczbę argumentów (poprzedzony*)
  3. nazwa formalna parametry
  4. parametr formalny przechwytujący dowolną liczbę nazwanych parametrów (poprzedzonych**)

• Przykład

  def function2(param1, *tupleParams, param2, param3, **dictionaryParams):
      print("param1: "+ param1)
      print("param2: "+ param2)
      print("param3: "+ param3)
      print("custom tuple params","-"*10)
      for p in tupleParams:
          print(str(p) + ",")
      print("custom named params","-"*10)
      for k,v in dictionaryParams.items():
          print(str(k)+":"+str(v))
  
  function2("arg1",
            "custom param1",
            "custom param2",
            "custom param3",
            param3="arg3",
            param2="arg2", 
            customNamedParam1 = "val1",
            customNamedParam2 = "val2"
            )
  
  # Output
  #
  #param1: arg1
  #param2: arg2
  #param3: arg3
  #custom tuple params ----------
  #custom param1,
  #custom param2,
  #custom param3,
  #custom named params ----------
  #customNamedParam2:val2
  #customNamedParam1:val1
  

Przekazywanie zmiennych krotki i dict dla niestandardowych args

Aby to zakończyć, pozwolę sobie również zauważyć, że możemy przejść

• "parametr formalny przechwytujący dowolną liczbę argumentów" jako zmienną krotki i
• "parametr formalny zapisujący dowolną liczbę nazwanych parametrów" jako dict zmienna

Tak samo powyższe wywołanie może być wykonane w następujący sposób:

tupleCustomArgs = ("custom param1", "custom param2", "custom param3")
dictCustomNamedArgs = {"customNamedParam1":"val1", "customNamedParam2":"val2"}

function2("arg1",
      *tupleCustomArgs,    #note *
      param3="arg3",
      param2="arg2", 
      **dictCustomNamedArgs     #note **
      )

Na koniec zauważ * i ** w wywołaniach funkcji powyżej. Jeśli je pominiemy, możemy mieć złe wyniki.

Pominięcie * w krotce args:

function2("arg1",
      tupleCustomArgs,   #omitting *
      param3="arg3",
      param2="arg2", 
      **dictCustomNamedArgs
      )

Druki

param1: arg1
param2: arg2
param3: arg3
custom tuple params ----------
('custom param1', 'custom param2', 'custom param3'),
custom named params ----------
customNamedParam2:val2
customNamedParam1:val1

Powyżej krotka ('custom param1', 'custom param2', 'custom param3') jest wydrukowana tak, jak jest.

Pominięcie dict args:

function2("arg1",
      *tupleCustomArgs,   
      param3="arg3",
      param2="arg2", 
      dictCustomNamedArgs   #omitting **
      )

Daje

dictCustomNamedArgs
         ^
SyntaxError: non-keyword arg after keyword arg

Jako dodatek, możesz również mieszać różne sposoby użycia podczas wywoływania funkcji kwargs:

def test(**kwargs):
    print kwargs['a']
    print kwargs['b']
    print kwargs['c']


args = { 'b': 2, 'c': 3}

test( a=1, **args )

Daje to wyjście:

1
2
3

Zauważ, że * * kwargs musi być ostatnim argumentem

Oto prosta funkcja, która służy do wyjaśnienia użycia:

def print_wrap(arg1, *args, **kwargs):
    print(arg1)
    print(args)
    print(kwargs)
    print(arg1, *args, **kwargs)

Wszelkie argumenty, które nie są określone w definicji funkcji, zostaną umieszczone na liście args lub liście kwargs, w zależności od tego, czy są argumentami słów kluczowych, czy nie:

>>> print_wrap('one', 'two', 'three', end='blah', sep='--')
one
('two', 'three')
{'end': 'blah', 'sep': '--'}
one--two--threeblah

Jeśli dodasz argument słowa kluczowego, który nigdy nie zostanie przekazany do funkcji, pojawi się błąd:

>>> print_wrap('blah', dead_arg='anything')
TypeError: 'dead_arg' is an invalid keyword argument for this function

Kwargi są cukrem składniowym do przekazywania argumentów nazw jako słowników(dla func) lub słowników jako nazwanych argumentów (dla func)

Oto przykład, który mam nadzieję jest pomocny:

#! /usr/bin/env python
#
def g( **kwargs) :
  print ( "In g ready to print kwargs" )
  print kwargs
  print ( "in g, calling f")
  f ( **kwargs )
  print ( "In g, after returning from f")

def f( **kwargs ) :
  print ( "in f, printing kwargs")
  print ( kwargs )
  print ( "In f, after printing kwargs")


g( a="red", b=5, c="Nassau")

g( q="purple", w="W", c="Charlie", d=[4, 3, 6] )

Po uruchomieniu programu otrzymujesz:

$ python kwargs_demo.py 
In g ready to print kwargs
{'a': 'red', 'c': 'Nassau', 'b': 5}
in g, calling f
in f, printing kwargs
{'a': 'red', 'c': 'Nassau', 'b': 5}
In f, after printing kwargs
In g, after returning from f
In g ready to print kwargs
{'q': 'purple', 'c': 'Charlie', 'd': [4, 3, 6], 'w': 'W'}
in g, calling f
in f, printing kwargs
{'q': 'purple', 'c': 'Charlie', 'd': [4, 3, 6], 'w': 'W'}
In f, after printing kwargs
In g, after returning from f

Kluczem Jest to, że zmienna liczba nazwanych argumentów w wywołaniu przekłada się na słownik w funkcji.

Argumenty słów kluczowych są często skracane do kwargs w Pythonie. W programowanie komputerowe ,

Argumenty słów kluczowych odnoszą się do obsługi funkcji języka komputerowego wywołania, które jasno określają nazwę każdego parametru w wywołanie funkcji.

Użycie dwóch gwiazdek przed nazwą parametru, * * kwargs , jest wtedy, gdy nie wiadomo, ile argumentów słów kluczowych zostanie przekazanych do funkcji. W takim przypadku nazywa się Arbitralne / Wieloznaczne Argumenty Słów Kluczowych.

Przykładem tego są funkcje odbiorcze Django .

def my_callback(sender, **kwargs):
    print("Request finished!")

Zauważ, że funkcja pobiera argument sender wraz z symbolami wieloznacznymi argumenty słów kluczowych (**kwargs); wszystkie programy obsługi sygnałów muszą przyjmować te argumenty. Wszystkie sygnały wysyłają argumenty słów kluczowych i mogą zmienić te argumenty słów kluczowych w dowolnym momencie. W przypadku request_finished , to udokumentowane jako nie wysyłanie argumentów, co oznacza, że możemy być kuszony do Zapisz naszą obsługę sygnału jako my_callback (sender).

To byłoby złe – w rzeczywistości Django wyrzuci błąd, jeśli to zrobisz więc. To dlatego, że w każdym momencie argumenty mogą zostać dodane do sygnał i odbiornik muszą być w stanie obsłużyć te nowe argumenty.

Zauważ, że nie musi być nazywany kwargs , ale musi mieć * *(Nazwa kwargs jest konwencją).

Jest to prosty przykład do zrozumienia o python rozpakowywanie ,

>>> def f(*args, **kwargs):
...    print 'args', args, 'kwargs', kwargs

Eg1:

>>>f(1, 2)
>>> args (1,2) kwargs {} #args return parameter without reference as a tuple
>>>f(a = 1, b = 2)
>>> args () kwargs {'a': 1, 'b': 2} #args is empty tuple and kwargs return parameter with reference as a dictionary

W Javie, konstruktory służą do przeciążania klas i zezwalają na wiele parametrów wejściowych. W Pythonie możesz użyć kwargs, aby zapewnić podobne zachowanie.

Przykład Javy: https://beginnersbook.com/2013/05/constructor-overloading/

Przykład Pythona:

class Robot():
    # name is an arg and color is a kwarg
    def __init__(self,name, color='red'):
        self.name = name
        self.color = color

red_robot = Robot('Bob')
blue_robot = Robot('Bob', color='blue')

print("I am a {color} robot named {name}.".format(color=red_robot.color, name=red_robot.name))
print("I am a {color} robot named {name}.".format(color=blue_robot.color, name=blue_robot.name))

>>> I am a red robot named Bob.
>>> I am a blue robot named Bob.