blocks|key|1097881|text|通过这种构造，调用者可以使用标准的关键字参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1097882|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|$]]

With this construct, the caller can use standard keyword arguments.

blocks|key|2113258|text|其中一种用法是当您想要转发参数时。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2113259|def+do_some_work(kwd1=None,+kwd2=None,+...):
++++....

def+intermediate_function(some_other_params,+**kwargs):
++++...
++++do_some_work(**kwargs)

def+main():
++++intermediate_function(some_other_params,+kwd1=5,+kwd2='foo')|code-block|syntax|javascript|2113260|这样，如果您向do_some_work添加一个参数，则不必将其同时添加到intermediate_function的定义和其中的do_some_work调用中。|offset|length|style|CODE|2113261|2113262|它的另一个用途是在Django的信号处理程序中。在编写处理程序时，您可以将其写入以下格式|2113263|def+handle_signal(sender,+instance,+**kwargs):|2113264|因此，API可以更改为在将来传递额外的参数，而不需要用户将参数添加到一堆不使用它们的方法中。|2113265|entityMap^0|0|0|7|C|10|L|1S|C|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|X|8|@$I|Y|J|Z|K|L]|$I|10|J|11|K|L]|$I|12|J|13|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|15|8|@]|9|@]|A|$]]|$1|P|3|Q|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|R|3|S|5|6|7|17|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|U|$]]

One use is when you want to forward parameters along. For example:

<pre><code>def do_some_work(kwd1=None, kwd2=None, ...):
 ....

def intermediate_function(some_other_params, **kwargs):
 ...
 do_some_work(**kwargs)

def main():
 intermediate_function(some_other_params, kwd1=5, kwd2='foo')
</code></pre>

That way if you add a parameter to <code>do_some_work</code>, you don't have to add it to both the definition of <code>intermediate_function</code> and the call to <code>do_some_work</code> within there.

<hr />

Another place it gets used is in Django's signal handlers. When you write a handler, you write it in the form

<pre><code>def handle_signal(sender, instance, **kwargs):
</code></pre>

so that the API can be changed to pass additional arguments in the future without requiring users to go add parameters to a bunch of methods that won't use them.

blocks|key|87080|text|从历史上看，参数传递要么通过位置传递，要么通过关键字参数传递。将复杂对象作为参数传递是一种相对较新的添加，人们更习惯于将值作为参数传递|type|unstyled|depth|inlineStyleRanges|entityRanges|data|87081|87082|Its+simple|ordered-list-item|87083|Readability|87084|87085|现在扩展这个概念，在支持时传递变量位置和关键字参数，从而产生上述构造。|87086|有趣的是，通过构造传递字典仍然是可能的，但是意图变得不那么明显了，这是负责任的程序员不想要的。|87087|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|R|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Historically Parameter passing has been either through positional or via keyword argument. Passing complex objects as parameters is a relatively recent addition and people are more comfortable in passing values as parameters

<ol>
<li>Its simple</li>
<li>Readability</li>
</ol>

Now extending the concept, passing variable positional and keywords arguments when supported gives rise to the above construct. 

Interestingly passing a dictionary is still possible though the construct, but the intent becomes less obvious which responsible programmer wouldn't want.

blocks|key|1731281|text|如果使用字典，则调用函数将如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1731282|myfunv({"key1":+"value1",+"key2":+"value2"})|code-block|syntax|javascript|1731283|使用**kwargs这就变成了|1731284|myfunc(key1="value1",+key2="value2")|1731285|很多人更喜欢后者。|1731286|当您透明地将参数传递给另一个函数或类时，此构造也非常有用。例如，在对Tkinter小部件进行子类化时，我经常使用它。我想要支持基类的所有选项，所以我这样编写代码：|1731287|class+MyFrame(tk.Frame):
++++def+__init__(self,+*args,+**kwargs):
++++++++tk.Frame.__init__(self,+*args,+**kwargs)
++++++++<more+code+here>|1731288|这使我可以支持所有相同的论点，而不必显式列出所有论点。|1731289|entityMap^0|0|0|0|0|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|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

If you use a dictionary, calling a function would look like this:

<pre><code>myfunv({"key1": "value1", "key2": "value2"})
</code></pre>

Using **kwargs this becomes

<pre><code>myfunc(key1="value1", key2="value2")
</code></pre>

Many people prefer the latter.

This construct is also very useful when you are transparently passing arguments to another function or class. For example, I use this a lot when subclassing Tkinter widgets. I want to support all of the options of the base class, so I code it like this:

<pre><code>class MyFrame(tk.Frame):
 def __init__(self, *args, **kwargs):
 tk.Frame.__init__(self, *args, **kwargs)
 &lt;more code here&gt;
</code></pre>

This allows me to support all the same arguments without having to explicitly list them all.

What exactly is the purpose of the "formal parameter of the form **keyword"? I put it in quotations, because that's what its referred to as in the docs, but I've had difficulty finding information on it and thought that maybe there's a formal term for it. 

From what I understand, it allows the user to do something like

<pre><code>def foo(**keywords):
 for i in keywords:
 print(i, ":", keywords[i])

foo(val1="1", val2="2", val3="3")
</code></pre>

Output:

<pre><code>val1 : 1
val2 : 2
val3 : 3
</code></pre>

What exactly is the advantage of this? Wouldn't passing a dictionary variable work better for ease of understanding?

Formal parameter of the form **keyword

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

“表单的形式参数**关键字”的目的到底是什么？我把它放在引文中，因为这是文档中提到的，但我很难找到关于它的信息，我想也许有一个正式的术语来描述它。据我所知，它允许用户执行以下操作def foo(**keywords):   for i in keywords:       print(i, ":", keywords[...

问表单形参**关键字
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问表单形参**关键字EN