Яке призначення та використання ** кваргів?

Для чого використовують **kwargsPython?

Я знаю, що ви можете зробити objects.filterтаблицю і передати **kwargsаргумент.  

Чи можу я це зробити також для визначення часових дельт, тобто timedelta(hours = time1)?

Як саме це працює? Це класи як "розпакування"? Як a,b=1,2?

Ви можете використовувати, **kwargsщоб ваші функції брали довільну кількість аргументів ключових слів ("kwargs" означає "аргументи ключових слів"):

>>> def print_keyword_args(**kwargs):
...     # kwargs is a dict of the keyword args passed to the function
...     for key, value in kwargs.iteritems():
...         print "%s = %s" % (key, value)
... 
>>> print_keyword_args(first_name="John", last_name="Doe")
first_name = John
last_name = Doe

Ви також можете використовувати **kwargsсинтаксис під час виклику функцій, побудувавши словник аргументів ключового слова та передавши його своїй функції:

>>> kwargs = {'first_name': 'Bobby', 'last_name': 'Smith'}
>>> print_keyword_args(**kwargs)
first_name = Bobby
last_name = Smith

Python Підручник містить гарне пояснення того , як вона працює, поряд з деякими хорошими прикладами.

<--Оновити-->

Для людей, які використовують Python 3, замість iteritems () використовуйте items ()

Розпакування словників

** розпаковує словники.

Це

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

те саме, що

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

Це корисно, якщо вам потрібно побудувати параметри:

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)

Параметри упаковки функції

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

Це дозволяє використовувати таку функцію:

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

kwargs - це лише словник, який додається до параметрів.

Словник може містити пари ключів, значень. А це - гвардії. Гаразд, ось як.

Що робити не так просто.

Наприклад (дуже гіпотетично) у вас є інтерфейс, який просто викликає інші процедури, щоб виконати цю роботу:

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

Тепер ви отримуєте новий метод "привід":

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

Але зачекайте хвилинку, є новий параметр «транспортний засіб» - ви цього раніше не знали. Тепер ви повинні додати його до підпису функції myDo.

Тут ви можете кинути kwargs в гру - ви просто додасте kwargs до підпису:

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

Таким чином, вам не потрібно змінювати підпис функції вашого інтерфейсу щоразу, коли деякі з ваших викликів підпрограми можуть змінюватися.

Це лише один приємний приклад, який може вам стати корисним.

Виходячи з того, що хороший зразок іноді кращий за довгий дискурс, я напишу дві функції, використовуючи всі засоби передачі аргументів змінної python (як позиційні, так і названі аргументи). Ви можете легко бачити, що це робить самостійно:

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)

І ось вихід:

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

Мотив: *argsі **kwargsслужить заповнювачем аргументів, які потрібно передати на виклик функції

використання *argsта **kwargsвиклик функції

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

Тепер ми будемо використовувати *argsдля виклику вищеописаної функції

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

результат:

arg1: два
arg2: 3
arg3: 5

Тепер, використовуючи **kwargsдля виклику тієї ж функції

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

результат:

arg1: 5
arg2: two
arg3: 3

Підсумок: *argsне має інтелекту, він просто інтерполює передані аргументи до параметрів (у порядку зліва направо), при цьому **kwargsповодиться розумно, розміщуючи відповідне значення @ потрібне місце

• kwargsв **kwargs- просто ім'я змінної. Можна дуже добре**anyVariableName
• kwargsозначає "аргументи ключових слів". Але я вважаю, що їх краще називати "названими аргументами", оскільки це просто аргументи, передані разом з іменами (я не знаходжу жодного значення для слова "ключове слово" у терміні "аргументи ключових слів". Я здогадуюсь, що "ключове слово" зазвичай означає слова, зарезервовані мовою програмування, і тому програміст не повинен використовуватись для змінних імен. Нічого подібного не відбувається у випадку з кворгами.). Таким чином , ми даємо імена param1і param2двох значень параметрів , що передаються в функцію наступним чином : func(param1="val1",param2="val2")замість проходження тільки значення: func(val1,val2). Таким чином, я вважаю, що їх слід відповідно називати "довільною кількістю названих аргументів", оскільки ми можемо вказати будь-яку кількість цих параметрів (тобтоfuncfunc(**kwargs)

Тож сказано, що дозвольте мені пояснити спочатку "названі аргументи", а потім "довільну кількість названих аргументів" kwargs.

Названі аргументи

• названі арги повинні слідувати позиційними
• Порядок названих аргів не важливий

• Приклад

  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'

Довільна кількість названих аргументів kwargs

• Послідовність параметрів функції:
  1. позиційні параметри
  2. формальний параметр, що фіксує довільну кількість аргументів (з префіксом *)
  3. названі формальні параметри
  4. формальний параметр, що фіксує довільну кількість названих параметрів (з префіксом **)

• Приклад

  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

Передача змінних кортежу та дікта для спеціальних аргументів

Щоб закінчити це, дозвольте також зазначити, що ми можемо пройти

• "формальний параметр, що фіксує довільну кількість аргументів" як змінна кортеж і
• "формальний параметр, що фіксує довільну кількість названих параметрів" як змінну dict

Таким чином, той самий вище виклик можна здійснити так:

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

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

Нарешті , зверніть увагу , *і **у викликах функцій вище. Якщо ми їх опустимо, ми можемо отримати погані результати.

Опущення *в кортежах:

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

відбитки

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

Зверху кортеж ('custom param1', 'custom param2', 'custom param3')друкується як є.

Опущення dictаргументів:

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

дає

dictCustomNamedArgs
         ^
SyntaxError: non-keyword arg after keyword arg

Крім того, ви також можете змішувати різні способи використання під час виклику функцій kwargs:

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


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

test( a=1, **args )

дає такий вихід:

1
2
3

Зауважте, що ** kwargs має бути останнім аргументом

kwargs - синтаксичний цукор для передачі аргументів імен як словників (для func), або словників як іменованих аргументів (to func)

Ось проста функція, яка служить для пояснення використання:

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

Будь-які аргументи, які не визначені у визначенні функції, будуть розміщені у argsсписку чи kwargsсписку, залежно від того, чи вони є аргументами ключового слова чи ні:

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

Якщо ви додасте аргумент ключового слова, який ніколи не передається функції, з’явиться помилка:

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

Ось приклад, який я сподіваюся, є корисним:

#! /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] )

Запустивши програму, ви отримаєте:

$ 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

Ключовим фактором тут є те, що змінна кількість названих аргументів у виклику перекладається у словник функції.

Це простий приклад для розуміння розпакування python ,

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

У Java ви використовуєте конструктори для перевантаження класів і дозволу для декількох вхідних параметрів. У python ви можете використовувати kwargs для надання подібної поведінки.

Приклад java: https://beginnersbook.com/2013/05/constructor-overloading/

Приклад пітона:

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.

просто ще один спосіб подумати про це.

Аргументи ключових слів часто скорочуються до kwargs в Python. У комп'ютерному програмуванні ,

Аргументи ключових слів відносяться до підтримки комп'ютерної мови для функціональних викликів, в яких чітко зазначено ім'я кожного параметра в межах виклику функції.

Використання двох зірочок перед назвою параметра ** kwargs - це коли людина не знає, скільки аргументів ключового слова буде передано у функцію. У такому випадку воно називається Аргументи довільного / шаблонного ключового слова.

Одним із прикладів цього є приймачі Django .

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

Зауважте, що функція бере аргумент відправника разом із аргументами ключового слова (** kwargs); всі обробники сигналів повинні приймати ці аргументи. Усі сигнали надсилають аргументи ключових слів і можуть змінювати ці аргументи ключового слова в будь-який час. У випадку з request_finished , це задокументовано як надсилання аргументів, а це означає, що ми можемо спокуситись записати обробку сигналу як my_callback (відправник).

Це було б неправильно - насправді Джанго викине помилку, якщо ви це зробите. Це тому, що в будь-який момент аргументи можуть бути додані до сигналу, і ваш приймач повинен мати можливість обробляти ці нові аргументи.

Зауважте, що його не потрібно називати kwargs , але він повинен мати ** (назва kwargs - це умовна умова ).