วัตถุประสงค์และการใช้ ** kwargs คืออะไร?

อะไรคือความหมายสำหรับ**kwargsในงูใหญ่?

ฉันรู้ว่าคุณสามารถทำได้objects.filterบนโต๊ะและผ่านการ**kwargsโต้แย้ง  

ฉันสามารถทำเช่นนี้เพื่อระบุเวลา delta 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 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 เป็นเพียงพจนานุกรมที่เพิ่มลงในพารามิเตอร์

พจนานุกรมสามารถมีคู่คีย์และค่า และนั่นคือ 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)

ด้วยวิธีนี้คุณไม่จำเป็นต้องเปลี่ยนลายเซ็นของฟังก์ชันอินเทอร์เฟซของคุณทุกครั้งที่รูทีนที่เรียกของคุณอาจเปลี่ยนแปลง

นี่เป็นเพียงหนึ่งตัวอย่างที่ดีที่คุณสามารถพบ 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})

Motif: *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: สอง
arg3: 3

Bottomline: *argsไม่มีความเฉลียวฉลาดเพียงแค่สอดแทรก args ที่ผ่านไปยังพารามิเตอร์ (ตามลำดับจากซ้ายไปขวา) ในขณะที่**kwargsทำงานอย่างชาญฉลาดโดยการวางค่าที่เหมาะสม @ สถานที่ที่ต้องการ

• kwargsใน**kwargsเป็นเพียงชื่อตัวแปร คุณทำได้ดีมาก**anyVariableName
• kwargsย่อมาจาก "อาร์กิวเมนต์ของคำหลัก" แต่ฉันรู้สึกว่าพวกเขาควรจะเรียกว่า "อาร์กิวเมนต์ที่มีชื่อ" ดีกว่าเพราะสิ่งเหล่านี้เป็นเพียงอาร์กิวเมนต์ที่ส่งไปพร้อมกับชื่อ (ฉันไม่พบความสำคัญใด ๆ กับคำว่า "คำหลัก" ในคำว่า "อาร์กิวเมนต์ของคำหลัก" คำที่สงวนไว้โดยภาษาการเขียนโปรแกรมและดังนั้นจึงไม่ควรใช้โดยโปรแกรมเมอร์สำหรับชื่อตัวแปรไม่มีสิ่งนี้เกิดขึ้นที่นี่ในกรณีของ kwargs.) ดังนั้นเราจึงให้ชื่อ param1และparam2สองค่าพารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชั่นดังต่อไปนี้แทนการส่งผ่านค่าเท่านั้น:func(param1="val1",param2="val2") func(val1,val2)ดังนั้นฉันรู้สึกว่าพวกเขาควรจะเรียกว่า"จำนวนข้อโต้แย้งที่มีชื่ออย่างเหมาะสม"อย่างเหมาะสมเนื่องจากเราสามารถระบุจำนวนพารามิเตอร์เหล่านี้ได้ (นั่นคือfuncfunc(**kwargs)

ดังนั้นที่ถูกกล่าวว่าให้ฉันอธิบาย "อาร์กิวเมนต์ที่มีชื่อ" ครั้งแรกแล้ว kwargs"จำนวนข้อของการขัดแย้งชื่อ"

อาร์กิวเมนต์ที่มีชื่อ

• args ชื่อควรปฏิบัติตาม args ตำแหน่ง
• ลำดับของ args ที่ระบุชื่อนั้นไม่สำคัญ

• ตัวอย่าง

  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

การส่งผ่านตัวแปร tuple และ dict สำหรับ args แบบกำหนดเอง

เพื่อให้มันจบลงขอผมทราบด้วยว่าเราสามารถผ่านได้

• "พารามิเตอร์ทางการจับจำนวนอาร์กิวเมนต์โดยพลการ" เป็นตัวแปร tuple และ
• "พารามิเตอร์ทางการจับจำนวนพารามิเตอร์ที่กำหนดชื่อโดยพลการ" เป็นตัวแปร dict

ดังนั้นการโทรข้างต้นเดียวกันสามารถทำได้ดังนี้:

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

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

ในที่สุดก็ทราบ*และ**ในการเรียกใช้ฟังก์ชั่นด้านบน หากเราละเว้นพวกเขาเราอาจได้รับผลลัพธ์ที่ไม่ดี

การละเว้น*tuple args:

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

tuple ด้านบน('custom param1', 'custom param2', 'custom param3')จะถูกพิมพ์ตามที่เป็น

ละเว้นdictargs:

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

สิ่งที่สำคัญที่ต้องใช้ในที่นี้คือจำนวนตัวแปรของอาร์กิวเมนต์ที่มีชื่อในการโทรแปลเป็นพจนานุกรมในฟังก์ชัน

นี่คือตัวอย่างที่ง่ายต่อการเข้าใจเกี่ยวกับงูหลามเอาออก ,

>>> 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 คุณใช้ Constructor เพื่อโอเวอร์โหลดคลาสและอนุญาตให้มีพารามิเตอร์อินพุตจำนวนมาก ในไพ ธ อนคุณสามารถใช้ 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คือเมื่อไม่มีใครรู้ว่าจะมีการส่งผ่านอาร์กิวเมนต์ของคำหลักไปยังฟังก์ชันกี่ครั้ง เมื่อเป็นกรณีนี้จะเรียกว่าอาร์กิวเมนต์คำหลัก Arbitrary / Wildcard

หนึ่งในตัวอย่างนี้คือDjango ของฟังก์ชั่นรับสัญญาณ

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

ขอให้สังเกตว่าฟังก์ชั่นใช้เวลาอาร์กิวเมนต์ผู้ส่งพร้อมกับอาร์กิวเมนต์คำหลักตัวแทน (** kwargs); ตัวจัดการสัญญาณทั้งหมดต้องรับอาร์กิวเมนต์เหล่านี้ สัญญาณทั้งหมดส่งข้อโต้แย้งคำหลักและอาจเปลี่ยนข้อโต้แย้งคำหลักเหล่านั้นได้ตลอดเวลา ในกรณีของrequest_finishedจะมีการบันทึกว่าไม่มีการขัดแย้งซึ่งหมายความว่าเราอาจถูกล่อลวงให้เขียนการจัดการสัญญาณของเราเป็น my_callback (ผู้ส่ง)

นี่จะผิด - จริง ๆ แล้ว Django จะโยนข้อผิดพลาดถ้าคุณทำเช่นนั้น นั่นเป็นเพราะข้อโต้แย้งใด ๆ ที่จุดสามารถได้รับการเพิ่มสัญญาณและผู้รับของคุณจะต้องสามารถจัดการกับข้อโต้แย้งใหม่เหล่านั้น

โปรดทราบว่าไม่จำเป็นต้องเรียกว่าkwargsแต่จำเป็นต้องมี ** (ชื่อkwargsเป็นแบบแผน)