blocks|key|1933088|text|kwargs只是一个添加到参数中的字典。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1933089|字典可以包含键、值对。这就是科瓦格人。好的，这是怎么做的。|1933090|原因并不是那么简单。|1933091|例如(非常假设的)你有一个接口，它只是调用其他例程来完成这项工作：|1933092|def+myDo(what,+where,+why):
+++if+what+==+'swim':
++++++doSwim(where,+why)
+++elif+what+==+'walk':
++++++doWalk(where,+why)
+++...|code-block|syntax|javascript|1933093|现在你得到了一个新的方法"drive"：|1933094|elif+what+==+'drive':
+++doDrive(where,+why,+vehicle)|1933095|但是等一下，有一个新参数"vehicle“--您之前并不知道它。现在，您必须将其添加到myDo函数的签名中。|1933096|在这里，您可以使用kwargs+--您只需将kwargs添加到签名：|1933097|def+myDo(what,+where,+why,+**kwargs):
+++if+what+==+'drive':
++++++doDrive(where,+why,+**kwargs)
+++elif+what+==+'swim':
++++++doSwim(where,+why,+**kwargs)|1933098|这样，您就不需要在每次被调用的例程发生更改时都更改接口函数的签名。|1933099|这只是一个很好的例子，你可以发现kwargs很有帮助。|1933100|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|J|7|1B|8|@]|9|@]|A|$K|L]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1D|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

kwargs is just a dictionary that is added to the parameters.

A dictionary can contain key, value pairs. And that are the kwargs. Ok, this is how.

The what for is not so simple.

For example (very hypothetical) you have an interface that just calls other routines to do the job:

<pre><code>def myDo(what, where, why):
 if what == 'swim':
 doSwim(where, why)
 elif what == 'walk':
 doWalk(where, why)
 ...
</code></pre>

Now you get a new method "drive":

<pre><code>elif what == 'drive':
 doDrive(where, why, vehicle)
</code></pre>

But wait a minute, there is a new parameter "vehicle" -- you did not know it before. Now you must add it to the signature of the myDo-function.

Here you can throw kwargs into play -- you just add kwargs to the signature:

<pre><code>def myDo(what, where, why, **kwargs):
 if what == 'drive':
 doDrive(where, why, **kwargs)
 elif what == 'swim':
 doSwim(where, why, **kwargs)
</code></pre>

This way you don't need to change the signature of your interface function every time some of your called routines might change.

This is just one nice example you could find kwargs helpful.

blocks|key|1829080|text|您可以使用**kwargs让您的函数接受任意数量的关键字参数("kwargs“表示”关键字参数“)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1829081|>>>+def+print_keyword_args(**kwargs):
...+++++#+kwargs+is+a+dict+of+the+keyword+args+passed+to+the+function
...+++++for+key,+value+in+kwargs.iteritems():
...+++++++++print+"%25s+=+%25s"+%25+(key,+value)
...+
>>>+print_keyword_args(first_name="John",+last_name="Doe")
first_name+=+John
last_name+=+Doe|code-block|syntax|javascript|1829082|通过构造关键字参数字典并将其传递给函数，还可以在调用函数时使用**kwargs语法：|1829083|>>>+kwargs+=+{'first_name':+'Bobby',+'last_name':+'Smith'}
>>>+print_keyword_args(**kwargs)
first_name+=+Bobby
last_name+=+Smith|1829084|Python+Tutorial很好地解释了它是如何工作的，并提供了一些很好的示例。|1829085|Python+3更新|1829086|对于Python3，请使用items()而不是iteritems()|1829087|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/tutorial/controlflow.html#keyword-arguments|1|https://docs.python.org/3/library/stdtypes.html#dict.items^0|5|8|0|0|V|8|0|0|0|F|0|0|0|D|7|N|B|D|7|1|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1C|8|@]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|Q|3|R|5|6|7|1G|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@$9|1M|A|1N|1|1O]]|E|$]]|$1|U|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]|12|$5|X|Y|Z|E|$10|13]]]]

You can use <code>**kwargs</code> to let your functions take an arbitrary number of keyword arguments (&quot;kwargs&quot; means &quot;keyword arguments&quot;):
<pre><code>&gt;&gt;&gt; def print_keyword_args(**kwargs):
... # kwargs is a dict of the keyword args passed to the function
... for key, value in kwargs.iteritems():
... print &quot;%s = %s&quot; % (key, value)
... 
&gt;&gt;&gt; print_keyword_args(first_name=&quot;John&quot;, last_name=&quot;Doe&quot;)
first_name = John
last_name = Doe
</code></pre>
You can also use the <code>**kwargs</code> syntax when calling functions by constructing a dictionary of keyword arguments and passing it to your function:
<pre><code>&gt;&gt;&gt; kwargs = {'first_name': 'Bobby', 'last_name': 'Smith'}
&gt;&gt;&gt; print_keyword_args(**kwargs)
first_name = Bobby
last_name = Smith
</code></pre>
The <a href="http://docs.python.org/tutorial/controlflow.html#keyword-arguments" rel="noreferrer">Python Tutorial</a> contains a good explanation of how it works, along with some nice examples.
<h2>Python 3 update</h2>
For Python 3, instead of <code>iteritems()</code>, use <a href="https://docs.python.org/3/library/stdtypes.html#dict.items" rel="noreferrer"><code>items()</code></a>

blocks|key|1831247|text|拆开字典|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1831248|**拆开字典。|offset|length|style|CODE|1831249|这|1831250|func(a=1,+b=2,+c=3)|code-block|syntax|javascript|1831251|等同于|1831252|args+=+{'a':+1,+'b':+2,+'c':3}
func(**args)|1831253|如果你必须构造参数，它是很有用的：|1831254|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)|1831255|1831256|打包函数的参数|1831257|1831258|对python+3|unordered-list-item|1831259|使用.items()而不是.iteritems()|1831260|def+setstyle(**styles):
++++for+key,+value+in+styles.iteritems():++++++#+styles+is+a+regular+dictionary
++++++++setattr(someobject,+key,+value)|1831261|这使您可以像这样使用函数：|1831262|setstyle(color="red",+bold=False)|1831263|1831264|备注|1831265|1831266|kwargs是用于关键字参数的变量名，可以使用其他变量名。重要的是，它是一个字典，它是用双星号运算符解包的，**.|1831267|Other迭代器是用单星号运算符*|1831268|To解包的，防止混淆，对于字典和其他迭代器respectively.|1831269|，最好使用可识别的变量名kwargs和args|1831270|1831271|资源|1831272|1831273|PEP+448:+Additional+Unpacking+Generalizations|1831274|Real+Python:+Python+args+and+kwargs:+Demystified|1831275|What+do+*+and+**+before+a+variable+name+mean+in+a+function+signature?|1831276|1831277|entityMap|0|LINK|mutability|MUTABLE|url|https://www.python.org/dev/peps/pep-0448/|1|https://realpython.com/python-kwargs-and-args/|2|https://stackoverflow.com/q/11315010/7758804^0|0|0|2|0|0|0|0|0|0|0|0|0|0|0|2|8|D|C|0|0|0|0|0|0|0|0|6|1I|2|0|G|1|0|0|C|6|J|4|0|0|0|0|0|19|0|0|0|1C|1|0|0|1X|2|0|0^^$0|@$1|2|3|4|5|6|7|2A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2B|8|@$D|2C|E|2D|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|2E|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|2F|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|2G|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|2H|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|2I|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|2J|8|@]|9|@]|A|$M|N]]|$1|W|3|-4|5|6|7|2K|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|2L|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|2M|8|@]|9|@]|A|$]]|$1|10|3|11|5|12|7|2N|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|2O|8|@$D|2P|E|2Q|F|G]|$D|2R|E|2S|F|G]]|9|@]|A|$]]|$1|15|3|16|5|L|7|2T|8|@]|9|@]|A|$M|N]]|$1|17|3|18|5|6|7|2U|8|@]|9|@]|A|$]]|$1|19|3|1A|5|L|7|2V|8|@]|9|@]|A|$M|N]]|$1|1B|3|-4|5|6|7|2W|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|2X|8|@]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|12|7|2Z|8|@$D|30|E|31|F|G]|$D|32|E|33|F|G]]|9|@]|A|$]]|$1|1H|3|1I|5|12|7|34|8|@$D|35|E|36|F|G]]|9|@]|A|$]]|$1|1J|3|1K|5|12|7|37|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|6|7|38|8|@$D|39|E|3A|F|G]|$D|3B|E|3C|F|G]]|9|@]|A|$]]|$1|1N|3|-4|5|6|7|3D|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|6|7|3E|8|@]|9|@]|A|$]]|$1|1Q|3|-4|5|6|7|3F|8|@]|9|@]|A|$]]|$1|1R|3|1S|5|12|7|3G|8|@]|9|@$D|3H|E|3I|1|3J]]|A|$]]|$1|1T|3|1U|5|12|7|3K|8|@]|9|@$D|3L|E|3M|1|3N]]|A|$]]|$1|1V|3|1W|5|12|7|3O|8|@]|9|@$D|3P|E|3Q|1|3R]]|A|$]]|$1|1X|3|-4|5|6|7|3S|8|@]|9|@]|A|$]]|$1|1Y|3|-4|5|6|7|3T|8|@]|9|@]|A|$]]]|1Z|$20|$5|21|22|23|A|$24|25]]|26|$5|21|22|23|A|$24|27]]|28|$5|21|22|23|A|$24|29]]]]

<h2>Unpacking dictionaries</h2>
<code>**</code> unpacks dictionaries.
This
<pre><code>func(a=1, b=2, c=3)
</code></pre>
is the same as
<pre><code>args = {'a': 1, 'b': 2, 'c':3}
func(**args)
</code></pre>
It's useful if you have to construct parameters:
<pre><code>args = {'name': person.name}
if hasattr(person, &quot;address&quot;):
 args[&quot;address&quot;] = person.address
func(**args) # either expanded to func(name=person.name) or
 # func(name=person.name, address=person.address)
</code></pre>
<hr />
<h2>Packing parameters of a function</h2>
<ul>
<li>Use <code>.items()</code> instead of <code>.iteritems()</code> for python 3</li>
</ul>
<pre class="lang-py prettyprint-override"><code>def setstyle(**styles):
 for key, value in styles.iteritems(): # styles is a regular dictionary
 setattr(someobject, key, value)
</code></pre>
This lets you use the function like this:
<pre><code>setstyle(color=&quot;red&quot;, bold=False)
</code></pre>
<hr />
<h2>Notes</h2>
<ul>
<li><code>kwargs</code> is variable name used for keyword arguments, another variable name can be used. The important part is that it's a dictionary and it's unpacked with the double asterisk operator <code>**</code>.</li>
<li>Other iterables are unpacked with the single asterisk operator <code>*</code></li>
<li>To prevent confusion, it's probably best to stick with the recognized variable names, <code>kwargs</code> and <code>args</code>, for dictionaries and other iterables respectively.</li>
</ul>
<hr />
<h2>Resources</h2>
<ul>
<li><a href="https://www.python.org/dev/peps/pep-0448/" rel="noreferrer">PEP 448: Additional Unpacking Generalizations</a></li>
<li><a href="https://realpython.com/python-kwargs-and-args/" rel="noreferrer">Real Python: Python args and kwargs: Demystified</a></li>
<li><a href="https://stackoverflow.com/q/11315010/7758804">What do * and ** before a variable name mean in a function signature?</a></li>
</ul>

blocks|key|529562|text|kwargs是一种语法糖，可以将名称参数作为字典(对于func)传递，或者将字典作为命名参数(传递给func)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|529563|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

kwargs are a syntactic sugar to pass name arguments as dictionaries(for func), or dictionaries as named arguments(to func)

blocks|key|529581|text|Motif:+*args+和+`kwargs`**+用作需要传递给函数调用的参数的占位符|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|529582|使用*args和**kwargs调用函数|529583|def+args_kwargs_test(arg1,+arg2,+arg3):
++++print+"arg1:",+arg1
++++print+"arg2:",+arg2
++++print+"arg3:",+arg3|code-block|syntax|javascript|529584|现在我们将使用*args来调用上面定义的函数|529585|#args+can+either+be+a+"list"+or+"tuple"
>>>+args+=+("two",+3,+5)++
>>>+args_kwargs_test(*args)|529586|结果：|529587|arg1:两个|529588|arg2:+3|529589|arg3:+5|529590|529591|现在，使用**kwargs调用相同的函数|529592|#keyword+argument+"kwargs"+has+to+be+a+dictionary
>>>+kwargs+=+{"arg3":3,+"arg2":'two',+"arg1":5}
>>>+args_kwargs_test(**kwargs)|529593|529594|arg1:+5|529595|arg2:两个|529596|arg3:+3|529597|结论：*args没有智能，它只是将传递的参数(按从左到右的顺序)插入到参数中，而**kwargs则智能地将适当的值放在所需的位置|529598|entityMap^0|0|6|7|5|D|1|F|1|Q|B|7|5|0|2|5|8|8|0|0|7|5|0|0|0|0|0|0|0|5|8|0|0|0|0|0|0|3|5|14|8|0^^$0|@$1|2|3|4|5|6|7|1F|8|@$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|1S|8|@$9|1T|A|1U|B|D]|$9|1V|A|1W|B|D]]|E|@]|F|$]]|$1|I|3|J|5|K|7|1X|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|1Y|8|@$9|1Z|A|20|B|D]]|E|@]|F|$]]|$1|P|3|Q|5|K|7|21|8|@]|E|@]|F|$L|M]]|$1|R|3|S|5|6|7|22|8|@]|E|@]|F|$]]|$1|T|3|U|5|6|7|23|8|@]|E|@]|F|$]]|$1|V|3|W|5|6|7|24|8|@]|E|@]|F|$]]|$1|X|3|Y|5|6|7|25|8|@]|E|@]|F|$]]|$1|Z|3|-4|5|6|7|26|8|@]|E|@]|F|$]]|$1|10|3|11|5|6|7|27|8|@$9|28|A|29|B|D]]|E|@]|F|$]]|$1|12|3|13|5|K|7|2A|8|@]|E|@]|F|$L|M]]|$1|14|3|S|5|6|7|2B|8|@]|E|@]|F|$]]|$1|15|3|16|5|6|7|2C|8|@]|E|@]|F|$]]|$1|17|3|18|5|6|7|2D|8|@]|E|@]|F|$]]|$1|19|3|1A|5|6|7|2E|8|@]|E|@]|F|$]]|$1|1B|3|1C|5|6|7|2F|8|@$9|2G|A|2H|B|D]|$9|2I|A|2J|B|D]]|E|@]|F|$]]|$1|1D|3|-4|5|6|7|2K|8|@]|E|@]|F|$]]]|1E|$]]

Motif: <code>*args</code> and <code>**kwargs</code> serves as a placeholder for the arguments that need to be passed to a function call

using <code>*args</code> and <code>**kwargs</code> to call a function 

<pre><code>def args_kwargs_test(arg1, arg2, arg3):
 print "arg1:", arg1
 print "arg2:", arg2
 print "arg3:", arg3
</code></pre>

Now we'll use <code>*args</code> to call the above defined function 

<pre><code>#args can either be a "list" or "tuple"
&gt;&gt;&gt; args = ("two", 3, 5) 
&gt;&gt;&gt; args_kwargs_test(*args)
</code></pre>

<h3>result:</h3>

arg1: two 
arg2: 3 
arg3: 5

<hr/>

Now, using <code>**kwargs</code> to call the same function

<pre><code>#keyword argument "kwargs" has to be a dictionary
&gt;&gt;&gt; kwargs = {"arg3":3, "arg2":'two', "arg1":5}
&gt;&gt;&gt; args_kwargs_test(**kwargs)
</code></pre>

<h3>result:</h3>

arg1: 5 
arg2: two 
arg3: 3 

Bottomline : <code>*args</code> has no intelligence, it simply interpolates the passed args to the parameters(in left-to-right order) while <code>**kwargs</code> behaves intelligently by placing the appropriate value @ the required place

blocks|key|1831350|text|基于好的示例有时比冗长的论述更好这一点，我将使用所有python变量参数传递工具(位置参数和命名参数)编写两个函数。您应该可以很容易地看到它自己做了什么：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1831351|def+f(a+=+0,+*args,+**kwargs):
++++print("Received+by+f(a,+*args,+**kwargs)")
++++print("=>+f(a=%25s,+args=%25s,+kwargs=%25s"+%25+(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=%25s,+g=%25s,+args=%25s,+kwargs=%25s)"+%25+(f,+g,+args,+kwargs))

print("Calling+f(1,+2,+3,+4,+b+=+5,+c+=+6)")
f(1,+2,+3,+4,+b+=+5,+c+=+6)|code-block|syntax|javascript|1831352|下面是输出：|1831353|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})|1831354|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

On the basis that a good sample is sometimes better than a long discourse I will write two functions using all python variable argument passing facilities (both positional and named arguments). You should easily be able to see what it does by yourself:

<pre><code>def f(a = 0, *args, **kwargs):
 print("Received by f(a, *args, **kwargs)")
 print("=&gt; 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("=&gt; 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)
</code></pre>

And here is the output:

<pre><code>Calling f(1, 2, 3, 4, b = 5, c = 6)
Received by f(a, *args, **kwargs) 
=&gt; 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)
=&gt; g(f=10, g=11, args=(12, 2, 3, 4), kwargs={'c': 6, 'b': 5, 'e': 14, 'd': 13})
</code></pre>

blocks|key|529475|text|此外，您还可以在调用kwargs函数时混合使用不同的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|529476|def+test(**kwargs):
++++print+kwargs['a']
++++print+kwargs['b']
++++print+kwargs['c']


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

test(+a=1,+**args+)|code-block|syntax|javascript|529477|输出如下：|529478|1
2
3|529479|请注意，**kwargs必须是最后一个参数|529480|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

As an addition, you can also mix different ways of usage when calling kwargs functions:

<pre><code>def test(**kwargs):
 print kwargs['a']
 print kwargs['b']
 print kwargs['c']


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

test( a=1, **args )
</code></pre>

gives this output:

<pre><code>1
2
3
</code></pre>

Note that **kwargs has to be the last argument

blocks|key|1933399|text|下面是一个简单的函数，用于解释用法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1933400|def+print_wrap(arg1,+*args,+**kwargs):
++++print(arg1)
++++print(args)
++++print(kwargs)
++++print(arg1,+*args,+**kwargs)|code-block|syntax|javascript|1933401|函数定义中未指定的任何参数都将被放入args列表或kwargs列表中，具体取决于它们是否是关键字参数：|offset|length|style|CODE|1933402|>>>+print_wrap('one',+'two',+'three',+end='blah',+sep='--')
one
('two',+'three')
{'end':+'blah',+'sep':+'--'}
one--two--threeblah|1933403|如果您添加了一个从未传递给函数的关键字参数，则会引发错误：|1933404|>>>+print_wrap('blah',+dead_arg='anything')
TypeError:+'dead_arg'+is+an+invalid+keyword+argument+for+this+function|1933405|entityMap^0|0|0|I|4|P|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

Here's a simple function that serves to explain the usage:

<pre><code>def print_wrap(arg1, *args, **kwargs):
 print(arg1)
 print(args)
 print(kwargs)
 print(arg1, *args, **kwargs)
</code></pre>

Any arguments that are not specified in the function definition will be put in the <code>args</code> list, or the <code>kwargs</code> list, depending on whether they are keyword arguments or not:

<pre><code>&gt;&gt;&gt; print_wrap('one', 'two', 'three', end='blah', sep='--')
one
('two', 'three')
{'end': 'blah', 'sep': '--'}
one--two--threeblah
</code></pre>

If you add a keyword argument that never gets passed to a function, an error will be raised:

<pre><code>&gt;&gt;&gt; print_wrap('blah', dead_arg='anything')
TypeError: 'dead_arg' is an invalid keyword argument for this function
</code></pre>

blocks|key|1933434|text|这里有一个我希望对你有帮助的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1933435|#!+/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]+)|code-block|syntax|javascript|1933436|当你运行这个程序时，你会得到：|1933437|$+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|1933438|这里的关键是，调用中的命名参数的可变数量将转换为函数中的字典。|1933439|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here is an example that I hope is helpful:

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

When you run the program, you get:

<pre><code>$ 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
</code></pre>

The key take away here is that the variable number of named arguments in the call translate into a dictionary in the function.

blocks|key|1829289|text|**kwargs中的|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1829290|kwargs只是变量名。你可以用**anyVariableName|unordered-list-item|1829291|kwargs代表“关键字参数”。但我觉得它们最好被称为“命名参数”，因为这些简单的参数与名称一起传递(我在术语“关键字参数”中找不到“关键字”一词的任何意义。我猜“关键字”通常是指由编程语言保留的单词，因此程序员不会将其用于变量名。对于kwargs，这里没有发生这样的事情。)因此，我们为传递给函数的两个参数值分别命名为param1和param2，如下所示：func(param1="val1",param2="val2")，而不是只传递值：func(val1,val2)。因此，我认为它们应该被恰当地称为“命名参数的任意数量”，因为如果func具有签名func(**kwargs)|1829292|，我们可以指定任意数量的这些参数(即，参数)。|1829293|因此，让我先解释一下“命名参数”，然后再解释“命名参数的任意数量”kwargs。|1829294|命名参数|BOLD|1829295|命名参数的顺序应遵循位置参数，命名参数的顺序不是important|1829296|Example+|1829297|1829298|+args+is+not+important|1829299|Example|1829300|1829301|1829302|def+function1(param1，param2="+arg2+"，param3="+arg3+")：print("\n"%2Bstr(param1)%2B“"%2Bstr(param2)%2B”"%2Bstr(param3)%2B"\n")+function1(1)+#1+arg2+arg3+#1位置参数function1(param1=1)+#1+arg2+arg3+#1命名参数function1(1，param2=2)+#1+2+arg3+#1位置参数，1命名参数(，param2=2)+#1+2+arg3+#2命名args+function1(param2=2，param1=1)+#1+2+arg3+#2命名args乱序function1(1，param3=3，param2=2)+#1+2+3#+#function1()+#invalid:必需的参数缺失#function1(param2=2,1)+#invalid:+SyntaxError:关键字arg之后的非关键字arg+#function1(1，param1=11)+#invalid:+TypeError:+function1()获取了参数'param1‘的多个值#function1(param4=4)+#invalid:+TypeError:+function1()获取了意外的关键字参数'param4'|1829303|kwargs的命名参数的任意数量|1829304|1829305|函数参数序列：|1829306|位置parameters|ordered-list-item|1829307|formal参数捕获任意数量的实参(以*为前缀)|1829308|命名的形式parameters|1829309|formal参数捕获任意数量的命名参数(以**)|1829310|1829311|为前缀|1829312|​|1829313|1829314|示例|1829315|1829316|def+function2(param1，*tupleParams，param2，param3，**dictionaryParams)：print("param1："%2B+param1)+print("param2："%2B+param2)+print("param3："%2B+param3)+print(“自定义元组参数"，"-"*10)对于tupleParams中的p:+print(str(p)+%2B”，")+print(“自定义命名参数”，"-"*10)对于k，V+in+dictionaryParams.items()：print(str(k)%2B":"%2Bstr(v))+function2("arg1"，“自定义param1"，”自定义param2"，“自定义param3"，param3="arg3"，param2="arg2"，customNamedParam1+=+"val1"，customNamedParam2+=+"val2“)#+Output+#+#param1:+arg1+#param2:+arg2+#param3:+arg3+#自定义元组参数-#自定义param1，#自定义param2，#自定义param3，#自定义命名参数-+#customNamedParam2:val2+val2|1829317|为自定义参数传递元组和字典变量的|1829318|为了完成它，让我也注意到，我们可以通过|1829319|1829320|“捕获任意数量的参数”作为元组变量，|1829321|“捕获任意数量的命名参数”作为字典变量|1829322|1829323|因此，可以按如下方式进行相同的调用：|1829324|tupleCustomArgs+=+("custom+param1",+"custom+param2",+"custom+param3")
dictCustomNamedArgs+=+{"customNamedParam1":"val1",+"customNamedParam2":"val2"}

function2("arg1",
++++++*tupleCustomArgs,++++#note+*
++++++param3="arg3",
++++++param2="arg2",+
++++++**dictCustomNamedArgs+++++#note+**
++++++)|code-block|syntax|javascript|1829325|最后，请注意上述函数调用中的*和**。如果我们忽略它们，我们可能会得到不好的结果。|1829326|在元组参数中省略*：|1829327|function2("arg1",
++++++tupleCustomArgs,+++#omitting+*
++++++param3="arg3",
++++++param2="arg2",+
++++++**dictCustomNamedArgs
++++++)|1829328|打印|1829329|param1:+arg1
param2:+arg2
param3:+arg3
custom+tuple+params+----------
('custom+param1',+'custom+param2',+'custom+param3'),
custom+named+params+----------
customNamedParam2:val2
customNamedParam1:val1|1829330|上面的元组('custom+param1',+'custom+param2',+'custom+param3')是按原样打印的。|1829331|省略dict参数：|1829332|function2("arg1",
++++++*tupleCustomArgs,+++
++++++param3="arg3",
++++++param2="arg2",+
++++++dictCustomNamedArgs+++#omitting+**
++++++)|1829333|给出|1829334|dictCustomNamedArgs
+++++++++%5E
SyntaxError:+non-keyword+arg+after+keyword+arg|1829335|entityMap^0|0|8|0|0|6|G|H|0|0|6|4G|6|4N|6|4Z|X|65|F|7H|4|7P|E|0|0|X|6|0|0|4|0|0|0|0|0|0|0|0|0|0|6|7|9|0|6|0|0|0|7|1|0|C|1|0|O|1|0|F|1|0|O|1|0|0|3|0|0|1|0|0|0|2|0|0|0|FD|0|0|G|0|0|J|0|0|0|I|0|0|J|0|0|0|I|0|0|0|15|E|1|G|2|0|0|A|8|1|0|0|0|2|0|0|0|1S|5|1F|0|0|9|2|4|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|2W|8|@$9|2X|A|2Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|2Z|8|@$9|30|A|31|B|C]|$9|32|A|33|B|C]]|D|@]|E|$]]|$1|I|3|J|5|H|7|34|8|@$9|35|A|36|B|C]|$9|37|A|38|B|C]|$9|39|A|3A|B|C]|$9|3B|A|3C|B|C]|$9|3D|A|3E|B|C]|$9|3F|A|3G|B|C]|$9|3H|A|3I|B|C]]|D|@]|E|$]]|$1|K|3|L|5|6|7|3J|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|3K|8|@$9|3L|A|3M|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|3N|8|@$9|3O|A|3P|B|Q]]|D|@]|E|$]]|$1|R|3|S|5|6|7|3Q|8|@]|D|@]|E|$]]|$1|T|3|U|5|H|7|3R|8|@]|D|@]|E|$]]|$1|V|3|-4|5|H|7|3S|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|3T|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|3U|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|3V|8|@]|D|@]|E|$]]|$1|11|3|-4|5|6|7|3W|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|3X|8|@]|D|@]|E|$]]|$1|14|3|15|5|6|7|3Y|8|@$9|3Z|A|40|B|Q]|$9|41|A|42|B|Q]|$9|43|A|44|B|C]]|D|@]|E|$]]|$1|16|3|-4|5|6|7|45|8|@]|D|@]|E|$]]|$1|17|3|18|5|H|7|46|8|@$9|47|A|48|B|Q]]|D|@]|E|$]]|$1|19|3|1A|5|1B|7|49|8|@$9|4A|A|4B|B|Q]]|D|@]|E|$]]|$1|1C|3|1D|5|1B|7|4C|8|@$9|4D|A|4E|B|Q]]|D|@]|E|$]]|$1|1E|3|1F|5|1B|7|4F|8|@$9|4G|A|4H|B|Q]]|D|@]|E|$]]|$1|1G|3|1H|5|1B|7|4I|8|@$9|4J|A|4K|B|Q]]|D|@]|E|$]]|$1|1I|3|-4|5|6|7|4L|8|@]|D|@]|E|$]]|$1|1J|3|1K|5|6|7|4M|8|@$9|4N|A|4O|B|Q]]|D|@]|E|$]]|$1|1L|3|1M|5|6|7|4P|8|@$9|4Q|A|4R|B|Q]]|D|@]|E|$]]|$1|1N|3|-4|5|6|7|4S|8|@]|D|@]|E|$]]|$1|1O|3|1P|5|H|7|4T|8|@$9|4U|A|4V|B|Q]]|D|@]|E|$]]|$1|1Q|3|-4|5|6|7|4W|8|@]|D|@]|E|$]]|$1|1R|3|1S|5|6|7|4X|8|@$9|4Y|A|4Z|B|Q]]|D|@]|E|$]]|$1|1T|3|1U|5|6|7|50|8|@$9|51|A|52|B|Q]]|D|@]|E|$]]|$1|1V|3|1W|5|6|7|53|8|@$9|54|A|55|B|Q]]|D|@]|E|$]]|$1|1X|3|-4|5|6|7|56|8|@]|D|@]|E|$]]|$1|1Y|3|1Z|5|H|7|57|8|@$9|58|A|59|B|Q]]|D|@]|E|$]]|$1|20|3|21|5|H|7|5A|8|@$9|5B|A|5C|B|Q]]|D|@]|E|$]]|$1|22|3|-4|5|6|7|5D|8|@]|D|@]|E|$]]|$1|23|3|24|5|6|7|5E|8|@$9|5F|A|5G|B|Q]]|D|@]|E|$]]|$1|25|3|26|5|27|7|5H|8|@]|D|@]|E|$28|29]]|$1|2A|3|2B|5|6|7|5I|8|@$9|5J|A|5K|B|Q]|$9|5L|A|5M|B|C]|$9|5N|A|5O|B|C]]|D|@]|E|$]]|$1|2C|3|2D|5|6|7|5P|8|@$9|5Q|A|5R|B|Q]|$9|5S|A|5T|B|C]]|D|@]|E|$]]|$1|2E|3|2F|5|27|7|5U|8|@]|D|@]|E|$28|29]]|$1|2G|3|2H|5|6|7|5V|8|@$9|5W|A|5X|B|Q]]|D|@]|E|$]]|$1|2I|3|2J|5|27|7|5Y|8|@]|D|@]|E|$28|29]]|$1|2K|3|2L|5|6|7|5Z|8|@$9|60|A|61|B|Q]|$9|62|A|63|B|C]]|D|@]|E|$]]|$1|2M|3|2N|5|6|7|64|8|@$9|65|A|66|B|Q]|$9|67|A|68|B|C]]|D|@]|E|$]]|$1|2O|3|2P|5|27|7|69|8|@]|D|@]|E|$28|29]]|$1|2Q|3|2R|5|6|7|6A|8|@$9|6B|A|6C|B|Q]]|D|@]|E|$]]|$1|2S|3|2T|5|27|7|6D|8|@]|D|@]|E|$28|29]]|$1|2U|3|-4|5|6|7|6E|8|@]|D|@]|E|$]]]|2V|$]]

<ul>
<li><code>kwargs</code> in <code>**kwargs</code> is just variable name. You can very well have <code>**anyVariableName</code></li>
<li><code>kwargs</code> stands for "keyword arguments". But I feel they should better be called as "named arguments", as these are simply arguments passed along with names (I dont find any significance to the word "keyword" in the term "keyword arguments". I guess "keyword" usually means words reserved by programming language and hence not to be used by the programmer for variable names. No such thing is happening here in case of kwargs.). So we give names 
<code>param1</code> and <code>param2</code> to two parameter values passed to the function as follows: <code>func(param1="val1",param2="val2")</code>, instead of passing only values: <code>func(val1,val2)</code>. Thus, I feel they should be appropriately called "arbitrary number of named arguments" as we can specify any number of these parameters (that is, arguments) if <code>func</code> has signature <code>func(**kwargs)</code></li>
</ul>

So being said that let me explain "named arguments" first and then "arbitrary number of named arguments" <code>kwargs</code>.

Named arguments

<ul>
<li>named args should follow positional args</li>
<li>order of named args is not important</li>
<li>Example

<pre><code>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'
</code></pre></li>
</ul>

Arbitrary number of named arguments <code>kwargs</code>

<ul>
<li>Sequence of function parameters:

<ol>
<li>positional parameters</li>
<li>formal parameter capturing arbitrary number of arguments (prefixed with *)</li>
<li>named formal parameters</li>
<li>formal parameter capturing arbitrary number of named parameters (prefixed with **)</li>
</ol></li>
<li>Example

<pre><code>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
</code></pre></li>
</ul>

Passing tuple and dict variables for custom args

To finish it up, let me also note that we can pass 

<ul>
<li>"formal parameter capturing arbitrary number of arguments" as tuple variable and</li>
<li>"formal parameter capturing arbitrary number of named parameters" as dict variable</li>
</ul>

Thus the same above call can be made as follows:

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

function2("arg1",
 *tupleCustomArgs, #note *
 param3="arg3",
 param2="arg2", 
 **dictCustomNamedArgs #note **
 )
</code></pre>

Finally note <code>*</code> and <code>**</code> in function calls above. If we omit them, we may get ill results.

Omitting <code>*</code> in tuple args:

<pre><code>function2("arg1",
 tupleCustomArgs, #omitting *
 param3="arg3",
 param2="arg2", 
 **dictCustomNamedArgs
 )
</code></pre>

prints 

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

Above tuple <code>('custom param1', 'custom param2', 'custom param3')</code> is printed as is. 

Omitting <code>dict</code> args:

<pre><code>function2("arg1",
 *tupleCustomArgs, 
 param3="arg3",
 param2="arg2", 
 dictCustomNamedArgs #omitting **
 )
</code></pre>

gives 

<pre><code>dictCustomNamedArgs
 ^
SyntaxError: non-keyword arg after keyword arg
</code></pre>

blocks|key|529570|text|这是一个关于python解压的简单示例，|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|529571|>>>+def+f(*args,+**kwargs):
...++++print+'args',+args,+'kwargs',+kwargs|code-block|syntax|javascript|529572|eg1：|529573|>>>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|529574|entityMap^0|6|8|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

This is the simple example to understand about python unpacking,

<pre><code>&gt;&gt;&gt; def f(*args, **kwargs):
... print 'args', args, 'kwargs', kwargs
</code></pre>

eg1:

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

blocks|key|1829376|text|在Java中，您可以使用构造函数来重载类并允许多个输入参数。在python中，您可以使用kwargs来提供类似的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1829377|java示例：https://beginnersbook.com/2013/05/constructor-overloading/|offset|length|1829378|python示例：|1829379|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.|code-block|syntax|javascript|1829380|只是思考它的另一种方式。|1829381|entityMap|0|LINK|mutability|MUTABLE|url|https://beginnersbook.com/2013/05/constructor-overloading/^0|0|7|1M|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

In Java, you use constructors to overload classes and allow for multiple input parameters. In python, you can use kwargs to provide similar behavior.

java example: <a href="https://beginnersbook.com/2013/05/constructor-overloading/" rel="nofollow noreferrer">https://beginnersbook.com/2013/05/constructor-overloading/</a>

python example:

<pre><code>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))

&gt;&gt;&gt; I am a red robot named Bob.
&gt;&gt;&gt; I am a blue robot named Bob.
</code></pre>

just another way to think about it.

blocks|key|1933643|text|在Python中，关键字参数通常被缩短为kwargs。在computer+programming中，|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1933644|1933645|关键字参数指的是计算机语言对函数调用的支持，它清楚地说明了函数调用中每个参数的名称。|blockquote|1933646|1933647|1933648|参数名**kwargs前的两个星号的用法是，当不知道将有多少关键字参数传递给函数时。在这种情况下，它被称为任意/通配符关键字参数。|1933649|Django's+receiver+functions就是一个这样的例子。|1933650|def+my_callback(sender,+**kwargs):
++++print("Request+finished!")|code-block|syntax|javascript|1933651|1933652|注意，该函数接受一个发送方参数以及通配符关键字参数(**kwargs)；所有信号处理程序都必须接受这些参数。所有信号都会发送关键字参数，并且可以随时更改这些关键字参数。在request_finished的情况下，它被记录为不发送参数，这意味着我们可能会尝试将我们的信号处理编写为my_callback(发送方)。|1933653|1933654|这将是错误的-事实上，如果您这样做，Django将抛出一个错误。这是因为在任何时候，参数都可以添加到信号中，并且您的接收器必须能够处理这些新参数。|1933655|1933656|注意，它不一定要称为kwargs，但需要有**+(+kwargs这个名称是一个约定)。|1933657|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Named_parameter|1|https://docs.djangoproject.com/en/3.0/topics/signals/#receiver-functions|2|https://docs.djangoproject.com/en/3.0/ref/signals/#django.core.signals.request_finished^0|S|K|0|0|0|0|0|0|0|0|R|1|0|0|0|2D|G|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@$A|1E|B|1F|1|1G]]|C|$]]|$1|D|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|1I|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|1J|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|1L|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1M|8|@]|9|@$A|1N|B|1O|1|1P]]|C|$]]|$1|N|3|O|5|P|7|1Q|8|@]|9|@]|C|$Q|R]]|$1|S|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]|$1|T|3|U|5|G|7|1S|8|@]|9|@$A|1T|B|1U|1|1V]]|C|$]]|$1|V|3|-4|5|6|7|1W|8|@]|9|@]|C|$]]|$1|W|3|X|5|6|7|1X|8|@]|9|@]|C|$]]|$1|Y|3|-4|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|Z|3|10|5|6|7|1Z|8|@]|9|@]|C|$]]|$1|11|3|-4|5|6|7|20|8|@]|9|@]|C|$]]]|12|$13|$5|14|15|16|C|$17|18]]|19|$5|14|15|16|C|$17|1A]]|1B|$5|14|15|16|C|$17|1C]]]]

Keyword Arguments are often shortened to kwargs in Python. In <a href="https://en.wikipedia.org/wiki/Named_parameter" rel="nofollow noreferrer">computer programming</a>,

<blockquote>
 keyword arguments refer to a computer language's support for function
 calls that clearly state the name of each parameter within the
 function call.
</blockquote>

The usage of the two asterisk before the parameter name, **kwargs, is when one doesn't know how many keyword arguments will be passed into the function. When that's the case, it's called Arbitrary / Wildcard Keyword Arguments.

One example of this is <a href="https://docs.djangoproject.com/en/3.0/topics/signals/#receiver-functions" rel="nofollow noreferrer">Django's receiver functions</a>.

<pre><code>def my_callback(sender, **kwargs):
 print("Request finished!")
</code></pre>

<blockquote>
 Notice that the function takes a sender argument, along with wildcard
 keyword arguments (**kwargs); all signal handlers must take these
 arguments.
 All signals send keyword arguments, and may change those
 keyword arguments at any time. In the case of <a href="https://docs.djangoproject.com/en/3.0/ref/signals/#django.core.signals.request_finished" rel="nofollow noreferrer">request_finished</a>, it’s
 documented as sending no arguments, which means we might be tempted to
 write our signal handling as my_callback(sender).
 
 This would be wrong – in fact, Django will throw an error if you do
 so. That’s because at any point arguments could get added to the
 signal and your receiver must be able to handle those new arguments.
</blockquote>

Note that it doesn't have to be called kwargs, but it needs to have ** (the name kwargs is a convention).

What are the uses for <code>**kwargs</code> in Python?

I know you can do an <code>objects.filter</code> on a table and pass in a <code>**kwargs</code> argument. &nbsp;

Can I also do this for specifying time deltas i.e. <code>timedelta(hours = time1)</code>? 

How exactly does it work? Is it classes as 'unpacking'? Like <code>a,b=1,2</code>?

What is the purpose and use of **kwargs?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

**kwargs在Python中的用途是什么？我知道您可以在表上执行objects.filter并传入**kwargs参数。3.我也可以这样做来指定时间增量，即timedelta(hours = time1)吗？它到底是如何工作的？它的类是“解包”吗？像a,b=1,2一样

问**kwargs的目的和用途是什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问**kwargs的目的和用途是什么？EN