blocks|key|1509002|text|对于字典中没有的键，您可以将默认值传递给get()：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1509003|self.val2+=+kwargs.get('val2',"default+value")|code-block|syntax|javascript|1509004|但是，如果您计划使用具有特定默认值的特定参数，为什么不首先使用命名参数呢？|1509005|def+__init__(self,+val2="default+value",+**kwargs):|1509006|entityMap^0|K|5|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|$]]

You can pass a default value to <code>get()</code> for keys that are not in the dictionary:

<pre><code>self.val2 = kwargs.get('val2',"default value")
</code></pre>

However, if you plan on using a particular argument with a particular default value, why not use named arguments in the first place?

<pre><code>def __init__(self, val2="default value", **kwargs):
</code></pre>

blocks|key|1509401|text|我建议这样做|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1509402|def+testFunc(+**kwargs+):
++++options+=+{
++++++++++++'option1'+:+'default_value1',
++++++++++++'option2'+:+'default_value2',
++++++++++++'option3'+:+'default_value3',+}

++++options.update(kwargs)
++++print+options

testFunc(+option1='new_value1',+option3='new_value3'+)
#+{'option2':+'default_value2',+'option3':+'new_value3',+'option1':+'new_value1'}

testFunc(+option2='new_value2'+)
#+{'option1':+'default_value1',+'option3':+'default_value3',+'option2':+'new_value2'}|code-block|syntax|javascript|1509403|然后以任何您想要的方式使用这些值|1509404|dictionaryA.update(dictionaryB)将dictionaryB的内容添加到dictionaryA中，覆盖任何重复的键。|offset|length|style|CODE|1509405|entityMap^0|0|0|0|0|V|W|B|1D|B|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]|$K|W|L|X|M|N]|$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

I suggest something like this

<pre><code>def testFunc( **kwargs ):
 options = {
 'option1' : 'default_value1',
 'option2' : 'default_value2',
 'option3' : 'default_value3', }

 options.update(kwargs)
 print options

testFunc( option1='new_value1', option3='new_value3' )
# {'option2': 'default_value2', 'option3': 'new_value3', 'option1': 'new_value1'}

testFunc( option2='new_value2' )
# {'option1': 'default_value1', 'option3': 'default_value3', 'option2': 'new_value2'}
</code></pre>

And then use the values any way you want

<code>dictionaryA.update(dictionaryB)</code> adds the contents of <code>dictionaryB</code> to <code>dictionaryA</code> overwriting any duplicate keys.

blocks|key|1294449|text|你会做的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1294450|self.attribute+=+kwargs.pop('name',+default_value)|code-block|syntax|javascript|1294451|或|1294452|self.attribute+=+kwargs.get('name',+default_value)|1294453|如果您使用pop，那么您可以检查是否发送了任何伪值，并采取适当的操作(如果有)。|offset|length|style|CODE|1294454|entityMap^0|0|0|0|0|5|3|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You'd do

<pre><code>self.attribute = kwargs.pop('name', default_value)
</code></pre>

or

<pre><code>self.attribute = kwargs.get('name', default_value)
</code></pre>

If you use <code>pop</code>, then you can check if there are any spurious values sent, and take the appropriate action (if any).

blocks|key|1509341|text|使用**kwargs和默认值很容易。然而，有时你一开始就不应该使用**kwargs。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1509342|在这种情况下，我们并没有真正最好地利用**kwargs。|1509343|class+ExampleClass(+object+):
++++def+__init__(self,+**kwargs):
++++++++self.val+=+kwargs.get('val',"default1")
++++++++self.val2+=+kwargs.get('val2',"default2")|code-block|syntax|javascript|1509344|上面的问题是“何必麻烦？”声明。与以下内容相同|1509345|class+ExampleClass(+object+):
++++def+__init__(self,+val="default1",+val2="default2"):
++++++++self.val+=+val
++++++++self.val2+=+val2|1509346|当您使用**kwargs时，您的意思是关键字不仅是可选的，而且是有条件的。与简单的默认值相比，还有更复杂的规则。|1509347|当您使用**kwargs时，您的意思通常更类似于以下内容，其中不适用简单的缺省设置。|1509348|class+ExampleClass(+object+):
++++def+__init__(self,+**kwargs):
++++++++self.val+=+"default1"
++++++++self.val2+=+"default2"
++++++++if+"val"+in+kwargs:
++++++++++++self.val+=+kwargs["val"]
++++++++++++self.val2+=+2*self.val
++++++++elif+"val2"+in+kwargs:
++++++++++++self.val2+=+kwargs["val2"]
++++++++++++self.val+=+self.val2+/+2
++++++++else:
++++++++++++raise+TypeError(+"must+provide+val=+or+val2=+parameter+values"+)|1509349|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|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Using **kwargs and default values is easy. Sometimes, however, you shouldn't be using **kwargs in the first place.

In this case, we're not really making best use of **kwargs.

<pre><code>class ExampleClass( object ):
 def __init__(self, **kwargs):
 self.val = kwargs.get('val',"default1")
 self.val2 = kwargs.get('val2',"default2")
</code></pre>

The above is a "why bother?" declaration. It is the same as

<pre><code>class ExampleClass( object ):
 def __init__(self, val="default1", val2="default2"):
 self.val = val
 self.val2 = val2
</code></pre>

When you're using **kwargs, you mean that a keyword is not just optional, but conditional. There are more complex rules than simple default values.

When you're using **kwargs, you usually mean something more like the following, where simple defaults don't apply.

<pre><code>class ExampleClass( object ):
 def __init__(self, **kwargs):
 self.val = "default1"
 self.val2 = "default2"
 if "val" in kwargs:
 self.val = kwargs["val"]
 self.val2 = 2*self.val
 elif "val2" in kwargs:
 self.val2 = kwargs["val2"]
 self.val = self.val2 / 2
 else:
 raise TypeError( "must provide val= or val2= parameter values" )
</code></pre>

blocks|key|1509586|text|既然在参数数量未知的情况下使用**kwargs，为什么不这样做呢？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1509587|class+Exampleclass(object):
++def+__init__(self,+**kwargs):
++++for+k+in+kwargs.keys():
+++++++if+k+in+[acceptable_keys_list]:
++++++++++self.__setattr__(k,+kwargs[k])|code-block|syntax|javascript|1509588|entityMap^0|F|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Since <code>**kwargs</code> is used when the number of arguments is unknown, why not doing this?

<pre><code>class Exampleclass(object):
 def __init__(self, **kwargs):
 for k in kwargs.keys():
 if k in [acceptable_keys_list]:
 self.__setattr__(k, kwargs[k])
</code></pre>

blocks|key|1509420|text|这是另一种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1509421|def+my_func(arg1,+arg2,+arg3):
++++...+so+something+...

kwargs+=+{'arg1':+'Value+One',+'arg2':+'Value+Two',+'arg3':+'Value+Three'}
#+Now+you+can+call+the+function+with+kwargs+like+this:

my_func(**kwargs)|code-block|syntax|javascript|1509422|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's another approach:

<pre><code>def my_func(arg1, arg2, arg3):
 ... so something ...

kwargs = {'arg1': 'Value One', 'arg2': 'Value Two', 'arg3': 'Value Three'}
# Now you can call the function with kwargs like this:

my_func(**kwargs)
</code></pre>

blocks|key|1509647|text|我认为当涉及到默认值时，在Python语言中使用**kwargs的正确方法是使用字典方法setdefault，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1509648|class+ExampleClass:
++++def+__init__(self,+**kwargs):
++++++++kwargs.setdefault('val',+value1)
++++++++kwargs.setdefault('val2',+value2)|code-block|syntax|javascript|1509649|这样，如果用户在关键字args中传递了'val‘或'val2’，则将使用它们；否则，将使用已设置的默认值。|1509650|entityMap^0|O|8|18|A|0|0|B|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$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|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

I think the proper way to use <code>**kwargs</code> in Python when it comes to default values is to use the dictionary method <code>setdefault</code>, as given below:

<pre><code>class ExampleClass:
 def __init__(self, **kwargs):
 kwargs.setdefault('val', value1)
 kwargs.setdefault('val2', value2)
</code></pre>

In this way, if a user passes 'val' or 'val2' in the keyword <code>args</code>, they will be used; otherwise, the default values that have been set will be used.

blocks|key|1509161|text|你可以这样做|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1509162|class+ExampleClass:
++++def+__init__(self,+**kwargs):
++++++++arguments+=+{'val':1,+'val2':2}
++++++++arguments.update(kwargs)
++++++++self.val+=+arguments['val']
++++++++self.val2+=+arguments['val2']|code-block|syntax|javascript|1509163|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You could do something like this

<pre><code>class ExampleClass:
 def __init__(self, **kwargs):
 arguments = {'val':1, 'val2':2}
 arguments.update(kwargs)
 self.val = arguments['val']
 self.val2 = arguments['val2']
</code></pre>

blocks|key|1509485|text|如果你想把它和*args结合起来，你必须把*args和**kwargs放在定义的末尾。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1509486|所以：|1509487|def+method(foo,+bar=None,+*args,+**kwargs):
++++do_something_with(foo,+bar)
++++some_other_function(*args,+**kwargs)|code-block|syntax|javascript|1509488|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you want to combine this with *args you have to keep *args and **kwargs at the end of the definition.

So:

<pre><code>def method(foo, bar=None, *args, **kwargs):
 do_something_with(foo, bar)
 some_other_function(*args, **kwargs)
</code></pre>

blocks|key|1295191|text|处理未知或多个参数的另一个简单解决方案可以是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1295192|class+ExampleClass(object):

++++def+__init__(self,+x,+y,+**kwargs):
++++++self.x+=+x
++++++self.y+=+y
++++++self.attributes+=+kwargs

++++def+SomeFunction(self):
++++++if+'something'+in+self.attributes:
++++++++dosomething()|code-block|syntax|javascript|1295193|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another simple solution for processing unknown or multiple arguments can be:

<pre><code>class ExampleClass(object):

 def __init__(self, x, y, **kwargs):
 self.x = x
 self.y = y
 self.attributes = kwargs

 def SomeFunction(self):
 if 'something' in self.attributes:
 dosomething()
</code></pre>

blocks|key|1295116|text|@AbhinavGupta和@Steef建议使用update()，我发现它对处理大型参数列表非常有帮助：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1295117|args.update(kwargs)|code-block|syntax|javascript|1295118|@VinaySajip指出，pop()可以用来迭代地处理参数列表。那么，任何剩余的参数都是虚假的。好的。|1295119|下面是另一种可能的方法，它保留了使用update()的简单语法|1295120|#+kwargs+=+dictionary+of+user-supplied+arguments
#+args+=+dictionary+containing+default+arguments

#+Check+that+user+hasn't+given+spurious+arguments
unknown_args+=+user_args.keys()+-+default_args.keys()
if+unknown_args:
++++raise+TypeError('Unknown+arguments:+{}'.format(unknown_args))

#+Update+args+to+contain+user-supplied+arguments
args.update(kwargs)|1295121|unknown_args是一个set，其中包含默认设置中不会出现的参数名称。|1295122|entityMap^0|O|8|0|0|E|5|0|I|8|0|0|0|C|F|3|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|T|$]]

@AbhinavGupta and @Steef suggested using <code>update()</code>, which I found very helpful for processing large argument lists:

<pre><code>args.update(kwargs)
</code></pre>

What if we want to check that the user hasn't passed any spurious/unsupported arguments? @VinaySajip pointed out that <code>pop()</code> can be used to iteratively process the list of arguments. Then, any leftover arguments are spurious. Nice.

Here's another possible way to do this, which keeps the simple syntax of using <code>update()</code>:

<pre><code># kwargs = dictionary of user-supplied arguments
# args = dictionary containing default arguments

# Check that user hasn't given spurious arguments
unknown_args = user_args.keys() - default_args.keys()
if unknown_args:
 raise TypeError('Unknown arguments: {}'.format(unknown_args))

# Update args to contain user-supplied arguments
args.update(kwargs)
</code></pre>

<code>unknown_args</code> is a <code>set</code> containing the names of arguments that don't occur in the defaults.

blocks|key|1509878|text|**kwargs允许自由添加任意数量的关键字参数。可以具有他可以为其设置默认值的键的列表。但是，为无限数量的键设置默认值似乎是没有必要的。最后，将键作为实例属性可能很重要。因此，我将执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1509879|class+Person(object):
listed_keys+=+['name',+'age']

def+__init__(self,+**kwargs):
++++_dict+=+{}
++++#+Set+default+values+for+listed+keys
++++for+item+in+self.listed_keys:+
++++++++_dict[item]+=+'default'
++++#+Update+the+dictionary+with+all+kwargs
++++_dict.update(kwargs)

++++#+Have+the+keys+of+kwargs+as+instance+attributes
++++self.__dict__.update(_dict)|code-block|syntax|javascript|1509880|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

**kwargs gives the freedom to add any number of keyword arguments. One may have a list of keys for which he can set default values. But setting default values for an indefinite number of keys seems unnecessary. Finally, it may be important to have the keys as instance attributes. So, I would do this as follows:

<pre><code>class Person(object):
listed_keys = ['name', 'age']

def __init__(self, **kwargs):
 _dict = {}
 # Set default values for listed keys
 for item in self.listed_keys: 
 _dict[item] = 'default'
 # Update the dictionary with all kwargs
 _dict.update(kwargs)

 # Have the keys of kwargs as instance attributes
 self.__dict__.update(_dict)
</code></pre>

What is the proper way to use <code>**kwargs</code> in Python when it comes to default values?

<code>kwargs</code> returns a dictionary, but what is the best way to set default values, or is there one? Should I just access it as a dictionary? Use get function? 

<pre><code>class ExampleClass:
 def __init__(self, **kwargs):
 self.val = kwargs['val']
 self.val2 = kwargs.get('val2')
</code></pre>

A simple question, but one that I can't find good resources on. People do it different ways in code that I've seen and it's hard to know what to use.

Proper way to use **kwargs in Python

Python

当涉及到默认值时，在Python中使用**kwargs的正确方式是什么？kwargs返回一个字典，但是设置缺省值的最佳方法是什么，或者有没有呢？我应该只把它当做字典来访问吗？使用get函数？class ExampleClass:    def __init__(self, **kwargs):        self.val = kwargs['val']        self.val2 = k

问在Python中正确使用**kwargs
EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python中正确使用**kwargsEN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python中正确使用**kwargs
EN