blocks|key|4436624|text|显式比隐式好...所以，你可以让它变得更简洁：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4436625|def+__init__(self,a,b,c):
++++for+k,v+in+locals().items():
++++++++if+k+!=+"self":
+++++++++++++setattr(self,k,v)|code-block|syntax|javascript|4436626|更好的问题是:你应该这样做吗？|4436627|..。也就是说，如果你想要一个命名的元组，我推荐使用命名的元组(记住，元组有一定的附加条件)……也许你想要一个OrderedDict或者仅仅是一个字典..。|4436628|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|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Explicit is better than implicit ...
so sure, you could make it more concise:
<pre><code>def __init__(self,a,b,c):
 for k,v in locals().items():
 if k != &quot;self&quot;:
 setattr(self,k,v)
</code></pre>
The better question is: should you?
... that said if you want a named tuple I would recommend using a namedtuple (remember tuples have certain conditions attached to them) ... perhaps you want an OrderedDict or even just a dict ...

blocks|key|4436434|text|您还可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4436435|locs+=+locals()
for+arg+in+inspect.getargspec(self.__init__)[0][1:]:
++++setattr(self,+arg,+locs[arg])|code-block|syntax|javascript|4436436|当然，您必须导入inspect模块。|offset|length|style|CODE|4436437|entityMap^0|0|0|8|7|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|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You could also do:

<pre><code>locs = locals()
for arg in inspect.getargspec(self.__init__)[0][1:]:
 setattr(self, arg, locs[arg])
</code></pre>

Of course, you would have to import the <code>inspect</code> module.

blocks|key|4436482|text|正如其他人所提到的，重复是不错的，但在某些情况下，命名元组可能非常适合这种类型的问题。这避免了使用locals()或kwargs，这通常不是一个好主意。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4436483|from+collections+import+namedtuple
#+declare+a+new+object+type+with+three+properties;+x+y+z
#+the+first+arg+of+namedtuple+is+a+typename
#+the+second+arg+is+comma-separated+or+space-separated+property+names
XYZ+=+namedtuple("XYZ",+"x,+y,+z")

#+create+an+object+of+type+XYZ.+properties+are+in+order
abc+=+XYZ("one",+"two",+3)
print+abc.x
print+abc.y
print+abc.z|code-block|syntax|javascript|4436484|我发现它的用法有限，但你可以像继承任何其他对象一样继承一个命名元组(示例继续)：|4436485|class+MySuperXYZ(XYZ):
++++"""+I+add+a+helper+function+which+returns+the+original+properties+"""
++++def+properties(self):
++++++++return+self.x,+self.y,+self.z

abc2+=+MySuperXYZ(4,+"five",+"six")
print+abc2.x
print+abc2.y
print+abc2.z
print+abc2.properties()|4436486|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|$]]

As others have mentioned, the repetition isn't bad, but in some cases a namedtuple can be a great fit for this type of issue. This avoids using locals() or kwargs, which are usually a bad idea. 

<pre><code>from collections import namedtuple
# declare a new object type with three properties; x y z
# the first arg of namedtuple is a typename
# the second arg is comma-separated or space-separated property names
XYZ = namedtuple("XYZ", "x, y, z")

# create an object of type XYZ. properties are in order
abc = XYZ("one", "two", 3)
print abc.x
print abc.y
print abc.z
</code></pre>

I've found limited use for it, but you can inherit a namedtuple as with any other object (example continued):

<pre><code>class MySuperXYZ(XYZ):
 """ I add a helper function which returns the original properties """
 def properties(self):
 return self.x, self.y, self.z

abc2 = MySuperXYZ(4, "five", "six")
print abc2.x
print abc2.y
print abc2.z
print abc2.properties()
</code></pre>

blocks|key|4436552|text|编辑:如果您有python+3.7%2B，只需使用dataclasses|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4436553|一个保持签名的装饰器解决方案：|4436554|import+decorator
import+inspect
import+sys


@decorator.decorator
def+simple_init(func,+self,+*args,+**kws):
++++"""
++++@simple_init
++++def+__init__(self,a,b,...,z)
++++++++dosomething()

++++behaves+like

++++def+__init__(self,a,b,...,z)
++++++++self.a+=+a
++++++++self.b+=+b
++++++++...
++++++++self.z+=+z
++++++++dosomething()
++++"""

++++#init_argumentnames_without_self+=+['a','b',...,'z']
++++if+sys.version_info.major+==+2:
++++++++init_argumentnames_without_self+=+inspect.getargspec(func).args[1:]
++++else:
++++++++init_argumentnames_without_self+=+tuple(inspect.signature(func).parameters.keys())[1:]

++++positional_values+=+args
++++keyword_values_in_correct_order+=+tuple(kws[key]+for+key+in+init_argumentnames_without_self+if+key+in+kws)
++++attribute_values+=+positional_values+%2B+keyword_values_in_correct_order

++++for+attribute_name,attribute_value+in+zip(init_argumentnames_without_self,attribute_values):
++++++++setattr(self,attribute_name,attribute_value)

++++#+call+the+original+__init__
++++func(self,+*args,+**kws)


class+Test():
++++@simple_init
++++def+__init__(self,a,b,c,d=4):
++++++++print(self.a,self.b,self.c,self.d)

#prints+1+3+2+4
t+=+Test(1,c=2,b=3)
#keeps+signature
#prints+['self',+'a',+'b',+'c',+'d']
if+sys.version_info.major+==+2:
++++print(inspect.getargspec(Test.__init__).args)
else:
++++print(inspect.signature(Test.__init__))|code-block|syntax|javascript|4436555|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/dataclasses.html^0|N|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Edit:
If you have python 3.7+ just use <a href="https://docs.python.org/3/library/dataclasses.html" rel="nofollow noreferrer">dataclasses</a>

A decorator solution that keeps the signature:

<pre><code>import decorator
import inspect
import sys


@decorator.decorator
def simple_init(func, self, *args, **kws):
 """
 @simple_init
 def __init__(self,a,b,...,z)
 dosomething()

 behaves like

 def __init__(self,a,b,...,z)
 self.a = a
 self.b = b
 ...
 self.z = z
 dosomething()
 """

 #init_argumentnames_without_self = ['a','b',...,'z']
 if sys.version_info.major == 2:
 init_argumentnames_without_self = inspect.getargspec(func).args[1:]
 else:
 init_argumentnames_without_self = tuple(inspect.signature(func).parameters.keys())[1:]

 positional_values = args
 keyword_values_in_correct_order = tuple(kws[key] for key in init_argumentnames_without_self if key in kws)
 attribute_values = positional_values + keyword_values_in_correct_order

 for attribute_name,attribute_value in zip(init_argumentnames_without_self,attribute_values):
 setattr(self,attribute_name,attribute_value)

 # call the original __init__
 func(self, *args, **kws)


class Test():
 @simple_init
 def __init__(self,a,b,c,d=4):
 print(self.a,self.b,self.c,self.d)

#prints 1 3 2 4
t = Test(1,c=2,b=3)
#keeps signature
#prints ['self', 'a', 'b', 'c', 'd']
if sys.version_info.major == 2:
 print(inspect.getargspec(Test.__init__).args)
else:
 print(inspect.signature(Test.__init__))
</code></pre>

blocks|key|4436639|text|这是一个不需要任何额外导入的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4436640|Helper函数|4436641|一个小的helper函数让它更方便和可重用：|4436642|def+auto_init(local_name_space):
++++"""Set+instance+attributes+from+arguments.
++++"""
++++self+=+local_name_space.pop('self')
++++for+name,+value+in+local_name_space.items():
++++++++setattr(self,+name,+value)|code-block|syntax|javascript|4436643|应用程序|4436644|你需要用locals()来调用它|offset|length|style|CODE|4436645|class+A:
++++def+__init__(self,+x,+y,+z):
++++++++auto_init(locals())|4436646|测试|4436647|a+=+A(1,+2,+3)
print(a.__dict__)|4436648|输出：|4436649|{'y':+2,+'z':+3,+'x':+1}|4436650|不更改locals()|4436651|如果您不喜欢更改locals()，请使用此版本：|4436652|def+auto_init(local_name_space):
++++"""Set+instance+attributes+from+arguments.
++++"""
++++for+name,+value+in+local_name_space.items():
++++++++if+name+!=+'self':+
++++++++++++setattr(local_name_space['self'],+name,+value)|4436653|entityMap^0|0|0|0|0|0|4|8|0|0|0|0|0|0|3|8|0|8|8|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1C|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1D|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1E|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1F|8|@$O|1G|P|1H|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|H|7|1I|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|1J|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|1K|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1L|8|@]|9|@]|A|$]]|$1|10|3|11|5|H|7|1M|8|@]|9|@]|A|$I|J]]|$1|12|3|13|5|6|7|1N|8|@$O|1O|P|1P|Q|R]]|9|@]|A|$]]|$1|14|3|15|5|6|7|1Q|8|@$O|1R|P|1S|Q|R]]|9|@]|A|$]]|$1|16|3|17|5|H|7|1T|8|@]|9|@]|A|$I|J]]|$1|18|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|19|$]]

This is a solution without any additional imports.

<h2>Helper function</h2>

A small helper function makes it more convenient and re-usable:

<pre><code>def auto_init(local_name_space):
 """Set instance attributes from arguments.
 """
 self = local_name_space.pop('self')
 for name, value in local_name_space.items():
 setattr(self, name, value)
</code></pre>

<h2>Application</h2>

You need to call it with <code>locals()</code>:

<pre><code>class A:
 def __init__(self, x, y, z):
 auto_init(locals())
</code></pre>

<h2>Test</h2>

<pre><code>a = A(1, 2, 3)
print(a.__dict__)
</code></pre>

Output:

<pre><code>{'y': 2, 'z': 3, 'x': 1}
</code></pre>

<h2>Without changing <code>locals()</code></h2>

If you don't like to change <code>locals()</code> use this version:

<pre><code>def auto_init(local_name_space):
 """Set instance attributes from arguments.
 """
 for name, value in local_name_space.items():
 if name != 'self': 
 setattr(local_name_space['self'], name, value)
</code></pre>

blocks|key|4436692|text|我的0.02美元。它非常接近Joran+Beasley的答案，但更优雅：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4436693|def+__init__(self,+a,+b,+c,+d,+e,+f):
++++vars(self).update((k,+v)+for+k,+v+in+locals().items()+if+v+is+not+self)|code-block|syntax|javascript|4436694|此外，Mike+Müller的答案(对我来说是最好的)可以用这个技巧来简化：|4436695|def+auto_init(ns):
++++self+=+ns.pop('self')
++++vars(self).update(ns)|4436696|从你的__init__调用auto_init(locals())|offset|length|style|CODE|4436697|entityMap^0|0|0|0|0|3|8|D|J|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]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

My 0.02$. It is very close to Joran Beasley answer, but more elegant:

<pre><code>def __init__(self, a, b, c, d, e, f):
 vars(self).update((k, v) for k, v in locals().items() if v is not self)
</code></pre>

Additionally, Mike Müller's answer (the best one to my taste) can be reduced with this technique:

<pre><code>def auto_init(ns):
 self = ns.pop('self')
 vars(self).update(ns)
</code></pre>

And the just call <code>auto_init(locals())</code> from your <code>__init__</code>

blocks|key|4436847|text|这是在Python中做事情的一种自然方式。不要试图发明更聪明的东西，这会导致团队中没有人能理解的过于聪明的代码。如果你想成为团队中的一员，然后继续这样写下去。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4436848|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|$]]

It's a natural way to do things in Python. Don't try to invent something more clever, it will lead to overly clever code that no one on your team will understand. If you want to be a team player and then keep writing it this way.

blocks|key|4436777|text|处理这个问题的一个有趣的库是attrs+(并且避免了许多其他的样板文件)。例如，您的示例可以简化为(假设类名为MyClass)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4436778|import+attr

@attr.s
class+MyClass:
++++x+=+attr.ib()
++++y+=+attr.ib()
++++z+=+attr.ib()|code-block|syntax|javascript|4436779|您甚至不再需要__init__方法，除非它还做其他事情。这是a+nice+introduction+by+Glyph+Lefkowitz。|4436780|entityMap|0|LINK|mutability|MUTABLE|url|https://attrs.readthedocs.io/en/stable/|1|https://glyph.twistedmatrix.com/2016/08/attrs.html^0|1J|7|E|5|0|0|0|7|8|U|12|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@$9|16|A|17|1|18]]|E|$]]|$1|M|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

An interesting library that handles this (and avoids a lot of other boilerplate) is <a href="https://attrs.readthedocs.io/en/stable/" rel="noreferrer">attrs</a>. Your example, for instance, could be reduced to this (assume the class is called <code>MyClass</code>):

<pre><code>import attr

@attr.s
class MyClass:
 x = attr.ib()
 y = attr.ib()
 z = attr.ib()
</code></pre>

You don't even need an <code>__init__</code> method anymore, unless it does other stuff as well. Here's <a href="https://glyph.twistedmatrix.com/2016/08/attrs.html" rel="noreferrer">a nice introduction by Glyph Lefkowitz</a>.

I see patterns like

<pre><code>def __init__(self, x, y, z):
 ...
 self.x = x
 self.y = y
 self.z = z
 ...
</code></pre>

quite frequently, often with a lot more parameters. Is there a good way to avoid this type of tedious repetitiveness? Should the class inherit from <code>namedtuple</code> instead?

How do I avoid the "self.x = x; self.y = y; self.z = z" pattern in __init__?

Python

我看到了这样的模式def __init__(self, x, y, z):    ...    self.x = x    self.y = y    self.z = z    ...非常频繁，通常有更多的参数。有没有好的方法来避免这种乏味的重复？这个类应该从namedtuple继承吗？

问如何在init中避免"self.x = x；self.y = y；self.z = z“模式？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在__init__中避免"self.x = x；self.y = y；self.z = z“模式？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在init中避免"self.x = x；self.y = y；self.z = z“模式？
EN