blocks|key|1775905|text|字典怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1775906|如下所示：|1775907|myStruct+=+{'field1':+'some+val',+'field2':+'some+val'}|code-block|syntax|javascript|1775908|然后，您可以使用此命令来操作值：|1775909|print+myStruct['field1']
myStruct['field2']+=+'some+other+values'|1775910|并且这些值不一定是字符串。它们可以是几乎任何其他对象。|1775911|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

How about a dictionary?

Something like this:

<pre><code>myStruct = {'field1': 'some val', 'field2': 'some val'}
</code></pre>

Then you can use this to manipulate values:

<pre><code>print myStruct['field1']
myStruct['field2'] = 'some other values'
</code></pre>

And the values don't have to be strings. They can be pretty much any other object.

blocks|key|1560789|text|你可以在很多事情上使用元组，其中你可以在C中使用结构(例如x，y坐标或RGB颜色)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1560790|对于其他任何东西，您都可以使用字典或this+one之类的实用程序类|offset|length|1560791|>>>+class+Bunch:
...+++++def+__init__(self,+**kwds):
...+++++++++self.__dict__.update(kwds)
...
>>>+mystruct+=+Bunch(field1=value1,+field2=value2)|code-block|syntax|javascript|1560792|我认为在Python+Cookbook的发行版中，“权威”的讨论是here。|1560793|entityMap|0|LINK|mutability|MUTABLE|url|http://code.activestate.com/recipes/52308/|1|http://books.google.com/books?id=Q0s6Vgb98CQC&lpg=PT212&dq=Python%2520Cookbook%2520%2522Collecting%2520a%2520Bunch%2520of%2520Named%2520Items%2522&hl=en&pg=PT213#v=onepage&q&f=false^0|0|I|8|0|0|0|X|4|1|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|H|7|11|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]]]

You can use a tuple for a lot of things where you would use a struct in C (something like x,y coordinates or RGB colors for example).

For everything else you can use dictionary, or a utility class like <a href="http://code.activestate.com/recipes/52308/" rel="noreferrer">this one</a>:

<pre><code>&gt;&gt;&gt; class Bunch:
... def __init__(self, **kwds):
... self.__dict__.update(kwds)
...
&gt;&gt;&gt; mystruct = Bunch(field1=value1, field2=value2)
</code></pre>

I think the "definitive" discussion is <a href="http://books.google.com/books?id=Q0s6Vgb98CQC&amp;lpg=PT212&amp;dq=Python%20Cookbook%20%22Collecting%20a%20Bunch%20of%20Named%20Items%22&amp;hl=en&amp;pg=PT213#v=onepage&amp;q&amp;f=false" rel="noreferrer">here</a>, in the published version of the Python Cookbook.

blocks|key|1776020|text|使用在Python2.6的标准库中添加到collections+module中的named+tuple。如果您需要支持Python2.4，也可以使用Raymond+Hettinger的named+tuple配方。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1776021|对于您的基本示例来说，这很好，但也涵盖了您稍后可能会遇到的一些边缘情况。上面的代码片段将被写成：|1776022|from+collections+import+namedtuple
MyStruct+=+namedtuple("MyStruct",+"field1+field2+field3")|code-block|syntax|javascript|1776023|新创建的类型可以像这样使用：|1776024|m+=+MyStruct("foo",+"bar",+"baz")|1776025|您还可以使用命名参数：|1776026|m+=+MyStruct(field1="foo",+field2="bar",+field3="baz")|1776027|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/collections.html|1|https://docs.python.org/2/library/collections.html#collections.namedtuple|2|http://code.activestate.com/recipes/500261/^0|K|I|0|14|B|1|2K|B|2|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]|$A|18|B|19|1|1A]|$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1F|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1G|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|1H|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|1I|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|1J|8|@]|9|@]|C|$I|J]]|$1|S|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]|12|$5|V|W|X|C|$Y|13]]]]

Use a <a href="https://docs.python.org/2/library/collections.html#collections.namedtuple" rel="noreferrer">named tuple</a>, which was added to the <a href="http://docs.python.org/library/collections.html" rel="noreferrer">collections module</a> in the standard library in Python 2.6. It's also possible to use Raymond Hettinger's <a href="http://code.activestate.com/recipes/500261/" rel="noreferrer">named tuple</a> recipe if you need to support Python 2.4.

It's nice for your basic example, but also covers a bunch of edge cases you might run into later as well. Your fragment above would be written as:

<pre><code>from collections import namedtuple
MyStruct = namedtuple("MyStruct", "field1 field2 field3")
</code></pre>

The newly created type can be used like this:

<pre><code>m = MyStruct("foo", "bar", "baz")
</code></pre>

You can also use named arguments:

<pre><code>m = MyStruct(field1="foo", field2="bar", field3="baz")
</code></pre>

blocks|key|1560908|text|您还可以按位置将初始化参数传递给实例变量|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1560909|#+Abstract+struct+class+++++++
class+Struct:
++++def+__init__+(self,+*argv,+**argd):
++++++++if+len(argd):
++++++++++++#+Update+by+dictionary
++++++++++++self.__dict__.update+(argd)
++++++++else:
++++++++++++#+Update+by+position
++++++++++++attrs+=+filter+(lambda+x:+x[0:2]+!=+"__",+dir(self))
++++++++++++for+n+in+range(len(argv)):
++++++++++++++++setattr(self,+attrs[n],+argv[n])

#+Specific+class
class+Point3dStruct+(Struct):
++++x+=+0
++++y+=+0
++++z+=+0

pt1+=+Point3dStruct()
pt1.x+=+10

print+pt1.x
print+"-"*10

pt2+=+Point3dStruct(5,+6)

print+pt2.x,+pt2.y
print+"-"*10

pt3+=+Point3dStruct+(x=1,+y=2,+z=3)
print+pt3.x,+pt3.y,+pt3.z
print+"-"*10|code-block|syntax|javascript|1560910|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 can also pass the init parameters to the instance variables by position

<pre><code># Abstract struct class 
class Struct:
 def __init__ (self, *argv, **argd):
 if len(argd):
 # Update by dictionary
 self.__dict__.update (argd)
 else:
 # Update by position
 attrs = filter (lambda x: x[0:2] != "__", dir(self))
 for n in range(len(argv)):
 setattr(self, attrs[n], argv[n])

# Specific class
class Point3dStruct (Struct):
 x = 0
 y = 0
 z = 0

pt1 = Point3dStruct()
pt1.x = 10

print pt1.x
print "-"*10

pt2 = Point3dStruct(5, 6)

print pt2.x, pt2.y
print "-"*10

pt3 = Point3dStruct (x=1, y=2, z=3)
print pt3.x, pt3.y, pt3.z
print "-"*10
</code></pre>

blocks|key|1776113|text|也许你正在寻找没有构造函数的Structs：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1776114|class+Sample:
++name+=+''
++average+=+0.0
++values+=+None+#+list+cannot+be+initialized+here!


s1+=+Sample()
s1.name+=+"sample+1"
s1.values+=+[]
s1.values.append(1)
s1.values.append(2)
s1.values.append(3)

s2+=+Sample()
s2.name+=+"sample+2"
s2.values+=+[]
s2.values.append(4)

for+v+in+s1.values:+++#+prints+1,2,3+-->+OK.
++print+v
print+"***"
for+v+in+s2.values:+++#+prints+4+-->+OK.
++print+v|code-block|syntax|javascript|1776115|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|$]]

Perhaps you are looking for Structs without constructors:

<pre><code>class Sample:
 name = ''
 average = 0.0
 values = None # list cannot be initialized here!


s1 = Sample()
s1.name = "sample 1"
s1.values = []
s1.values.append(1)
s1.values.append(2)
s1.values.append(3)

s2 = Sample()
s2.name = "sample 2"
s2.values = []
s2.values.append(4)

for v in s1.values: # prints 1,2,3 --&gt; OK.
 print v
print "***"
for v in s2.values: # prints 4 --&gt; OK.
 print v
</code></pre>

blocks|key|1561039|text|您可以通过以下方式访问python中的C样式结构。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1561040|class+cstruct:
++++var_i+=+0
++++var_f+=+0.0
++++var_str+=+""|code-block|syntax|javascript|1561041|如果您只想使用cstruct对象|1561042|obj+=+cstruct()
obj.var_i+=+50
obj.var_f+=+50.00
obj.var_str+=+"fifty"
print+"cstruct:+obj+i=%25d+f=%25f+s=%25s"+%25(obj.var_i,+obj.var_f,+obj.var_str)|1561043|如果要创建cstruct的对象数组|1561044|obj_array+=+[cstruct()+for+i+in+range(10)]
obj_array[0].var_i+=+10
obj_array[0].var_f+=+10.00
obj_array[0].var_str+=+"ten"

#go+ahead+and+fill+rest+of+array+instaces+of+struct

#print+all+the+value
for+i+in+range(10):
++++print+"cstruct:+obj_array+i=%25d+f=%25f+s=%25s"+%25(obj_array[i].var_i,+obj_array[i].var_f,+obj_array[i].var_str)|1561045|注意:请使用您的结构名称代替'cstruct‘名称，而不是var_i，var_f，var_str，请定义您的结构的成员变量。|1561046|entityMap^0|0|0|0|0|0|0|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|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You access C-Style struct in python in following way.

<pre><code>class cstruct:
 var_i = 0
 var_f = 0.0
 var_str = ""
</code></pre>

<h1>if you just want use object of cstruct</h1>

<pre><code>obj = cstruct()
obj.var_i = 50
obj.var_f = 50.00
obj.var_str = "fifty"
print "cstruct: obj i=%d f=%f s=%s" %(obj.var_i, obj.var_f, obj.var_str)
</code></pre>

<h1>if you want to create an array of objects of cstruct</h1>

<pre><code>obj_array = [cstruct() for i in range(10)]
obj_array[0].var_i = 10
obj_array[0].var_f = 10.00
obj_array[0].var_str = "ten"

#go ahead and fill rest of array instaces of struct

#print all the value
for i in range(10):
 print "cstruct: obj_array i=%d f=%f s=%s" %(obj_array[i].var_i, obj_array[i].var_f, obj_array[i].var_str)
</code></pre>

Note:
instead of 'cstruct' name, please use your struct name
instead of var_i, var_f, var_str, please define your structure's member variable.

blocks|key|1776256|text|这可能有点晚了，但我使用Python+Meta-Classes+(也是下面的装饰器版本)做了一个解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1776257|在运行时调用__init__时，它会获取每个参数及其值，并将它们作为实例变量分配给您的类。这样，您就可以创建一个类似于结构的类，而不必手动分配每个值。|offset|length|style|CODE|1776258|我的示例没有错误检查，因此更容易遵循。|1776259|class+MyStruct(type):
++++def+__call__(cls,+*args,+**kwargs):
++++++++names+=+cls.__init__.func_code.co_varnames[1:]

++++++++self+=+type.__call__(cls,+*args,+**kwargs)

++++++++for+name,+value+in+zip(names,+args):
++++++++++++setattr(self+,+name,+value)

++++++++for+name,+value+in+kwargs.iteritems():
++++++++++++setattr(self+,+name,+value)
++++++++return+self+|code-block|syntax|javascript|1776260|这就是它的实际作用。|1776261|>>>+class+MyClass(object):
++++__metaclass__+=+MyStruct
++++def+__init__(self,+a,+b,+c):
++++++++pass


>>>+my_instance+=+MyClass(1,+2,+3)
>>>+my_instance.a
1
>>>+|1776262|我和posted+it+on+reddit和/u/matchu发布了一个更干净的装饰器版本。我鼓励您使用它，除非您想扩展元类版本。|1776263|>>>+def+init_all_args(fn):
++++@wraps(fn)
++++def+wrapped_init(self,+*args,+**kwargs):
++++++++names+=+fn.func_code.co_varnames[1:]

++++++++for+name,+value+in+zip(names,+args):
++++++++++++setattr(self,+name,+value)

++++++++for+name,+value+in+kwargs.iteritems():
++++++++++++setattr(self,+name,+value)

++++return+wrapped_init

>>>+class+Test(object):
++++@init_all_args
++++def+__init__(self,+a,+b):
++++++++pass


>>>+a+=+Test(1,+2)
>>>+a.a
1
>>>+|1776264|entityMap|0|LINK|mutability|MUTABLE|url|http://www.reddit.com/r/Python/comments/300psq/i_made_a_cstyle_struct_using_a_metaclass_to_save/|1|http://www.reddit.com/user/matchu^0|0|6|8|0|0|0|0|0|2|J|0|M|9|1|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@$D|18|E|19|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1A|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1B|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1D|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1E|8|@]|9|@$D|1F|E|1G|1|1H]|$D|1I|E|1J|1|1K]]|A|$]]|$1|U|3|V|5|L|7|1L|8|@]|9|@]|A|$M|N]]|$1|W|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]]]

This might be a bit late but I made a solution using Python Meta-Classes (decorator version below too).

When <code>__init__</code> is called during run time, it grabs each of the arguments and their value and assigns them as instance variables to your class. This way you can make a struct-like class without having to assign every value manually.

My example has no error checking so it is easier to follow.

<pre><code>class MyStruct(type):
 def __call__(cls, *args, **kwargs):
 names = cls.__init__.func_code.co_varnames[1:]

 self = type.__call__(cls, *args, **kwargs)

 for name, value in zip(names, args):
 setattr(self , name, value)

 for name, value in kwargs.iteritems():
 setattr(self , name, value)
 return self 
</code></pre>

Here it is in action.

<pre><code>&gt;&gt;&gt; class MyClass(object):
 __metaclass__ = MyStruct
 def __init__(self, a, b, c):
 pass


&gt;&gt;&gt; my_instance = MyClass(1, 2, 3)
&gt;&gt;&gt; my_instance.a
1
&gt;&gt;&gt; 
</code></pre>

I <a href="http://www.reddit.com/r/Python/comments/300psq/i_made_a_cstyle_struct_using_a_metaclass_to_save/" rel="noreferrer">posted it on reddit</a> and <a href="http://www.reddit.com/user/matchu" rel="noreferrer">/u/matchu</a> posted a decorator version which is cleaner. I'd encourage you to use it unless you want to expand the metaclass version.

<pre><code>&gt;&gt;&gt; def init_all_args(fn):
 @wraps(fn)
 def wrapped_init(self, *args, **kwargs):
 names = fn.func_code.co_varnames[1:]

 for name, value in zip(names, args):
 setattr(self, name, value)

 for name, value in kwargs.iteritems():
 setattr(self, name, value)

 return wrapped_init

&gt;&gt;&gt; class Test(object):
 @init_all_args
 def __init__(self, a, b):
 pass


&gt;&gt;&gt; a = Test(1, 2)
&gt;&gt;&gt; a.a
1
&gt;&gt;&gt; 
</code></pre>

blocks|key|1776354|text|您可以对标准库中提供的C结构进行子类化。ctypes模块提供了一个Structure+class。文档中的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1776355|>>>+from+ctypes+import+*
>>>+class+POINT(Structure):
...+++++_fields_+=+[("x",+c_int),
...+++++++++++++++++("y",+c_int)]
...
>>>+point+=+POINT(10,+20)
>>>+print+point.x,+point.y
10+20
>>>+point+=+POINT(y=5)
>>>+print+point.x,+point.y
0+5
>>>+POINT(1,+2,+3)
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+?
ValueError:+too+many+initializers
>>>
>>>+class+RECT(Structure):
...+++++_fields_+=+[("upperleft",+POINT),
...+++++++++++++++++("lowerright",+POINT)]
...
>>>+rc+=+RECT(point)
>>>+print+rc.upperleft.x,+rc.upperleft.y
0+5
>>>+print+rc.lowerright.x,+rc.lowerright.y
0+0
>>>|code-block|syntax|javascript|1776356|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/ctypes.html|1|https://docs.python.org/2/library/ctypes.html#structures-and-unions^0|K|6|0|X|F|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

You can subclass the C structure that is available in the standard library. The <a href="https://docs.python.org/2/library/ctypes.html">ctypes</a> module provides a <a href="https://docs.python.org/2/library/ctypes.html#structures-and-unions">Structure class</a>. The example from the docs:

<pre><code>&gt;&gt;&gt; from ctypes import *
&gt;&gt;&gt; class POINT(Structure):
... _fields_ = [("x", c_int),
... ("y", c_int)]
...
&gt;&gt;&gt; point = POINT(10, 20)
&gt;&gt;&gt; print point.x, point.y
10 20
&gt;&gt;&gt; point = POINT(y=5)
&gt;&gt;&gt; print point.x, point.y
0 5
&gt;&gt;&gt; POINT(1, 2, 3)
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in ?
ValueError: too many initializers
&gt;&gt;&gt;
&gt;&gt;&gt; class RECT(Structure):
... _fields_ = [("upperleft", POINT),
... ("lowerright", POINT)]
...
&gt;&gt;&gt; rc = RECT(point)
&gt;&gt;&gt; print rc.upperleft.x, rc.upperleft.y
0 5
&gt;&gt;&gt; print rc.lowerright.x, rc.lowerright.y
0 0
&gt;&gt;&gt;
</code></pre>

blocks|key|1561259|text|我写了一个装饰器，你可以在任何方法上使用它，这样所有传入的参数或任何默认值都会被赋值给实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1561260|def+argumentsToAttributes(method):
++++argumentNames+=+method.func_code.co_varnames[1:]

++++#+Generate+a+dictionary+of+default+values:
++++defaultsDict+=+{}
++++defaults+=+method.func_defaults+if+method.func_defaults+else+()
++++for+i,+default+in+enumerate(defaults,+start+=+len(argumentNames)+-+len(defaults)):
++++++++defaultsDict[argumentNames[i]]+=+default

++++def+newMethod(self,+*args,+**kwargs):
++++++++#+Use+the+positional+arguments.
++++++++for+name,+value+in+zip(argumentNames,+args):
++++++++++++setattr(self,+name,+value)

++++++++#+Add+the+key+word+arguments.+If+anything+is+missing,+use+the+default.
++++++++for+name+in+argumentNames[len(args):]:
++++++++++++setattr(self,+name,+kwargs.get(name,+defaultsDict[name]))

++++++++#+Run+whatever+else+the+method+needs+to+do.
++++++++method(self,+*args,+**kwargs)

++++return+newMethod|code-block|syntax|javascript|1561261|一个快速演示。请注意，我使用了位置参数a、b的默认值和命名参数c。然后，我打印所有3个引用self的代码，以显示它们在进入方法之前已被正确分配。|offset|length|style|CODE|1561262|class+A(object):
++++@argumentsToAttributes
++++def+__init__(self,+a,+b+=+'Invisible',+c+=+'Hello'):
++++++++print(self.a)
++++++++print(self.b)
++++++++print(self.c)

A('Why',+c+=+'Nothing')|1561263|请注意，我的装饰器应该使用任何方法，而不仅仅是__init__。|1561264|entityMap^0|0|0|J|1|L|1|V|1|19|4|0|0|N|8|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|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@$I|15|J|16|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$]]

I wrote a decorator which you can use on any method to make it so that all of the arguments passed in, or any defaults, are assigned to the instance.

<pre><code>def argumentsToAttributes(method):
 argumentNames = method.func_code.co_varnames[1:]

 # Generate a dictionary of default values:
 defaultsDict = {}
 defaults = method.func_defaults if method.func_defaults else ()
 for i, default in enumerate(defaults, start = len(argumentNames) - len(defaults)):
 defaultsDict[argumentNames[i]] = default

 def newMethod(self, *args, **kwargs):
 # Use the positional arguments.
 for name, value in zip(argumentNames, args):
 setattr(self, name, value)

 # Add the key word arguments. If anything is missing, use the default.
 for name in argumentNames[len(args):]:
 setattr(self, name, kwargs.get(name, defaultsDict[name]))

 # Run whatever else the method needs to do.
 method(self, *args, **kwargs)

 return newMethod
</code></pre>

A quick demonstration. Note that I use a positional argument <code>a</code>, use the default value for <code>b</code>, and a named argument <code>c</code>. I then print all 3 referencing <code>self</code>, to show that they've been properly assigned before the method is entered.

<pre><code>class A(object):
 @argumentsToAttributes
 def __init__(self, a, b = 'Invisible', c = 'Hello'):
 print(self.a)
 print(self.b)
 print(self.c)

A('Why', c = 'Nothing')
</code></pre>

Note that my decorator should work with any method, not just <code>__init__</code>.

blocks|key|1561339|text|我在这里看不到这个答案，所以我想我会添加它，因为我现在正在学习Python，并且刚刚发现了它。Python+tutorial+(在本例中为Python2)提供了以下简单而有效的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1561340|class+Employee:
++++pass

john+=+Employee()++#+Create+an+empty+employee+record

#+Fill+the+fields+of+the+record
john.name+=+'John+Doe'
john.dept+=+'computer+lab'
john.salary+=+1000|code-block|syntax|javascript|1561341|也就是说，创建一个空类对象，然后实例化，并动态添加字段。|1561342|这样做的好处是它非常简单。缺点是它不是特别自文档化的(目标成员没有列在类“定义”中的任何地方)，并且未设置的字段在被访问时可能会导致问题。这两个问题可以通过以下方式解决：|1561343|class+Employee:
++++def+__init__+(self):
++++++++self.name+=+None+#+or+whatever
++++++++self.dept+=+None
++++++++self.salary+=+None|1561344|现在，您至少可以一目了然地看到程序需要哪些字段。|1561345|两者都容易出现打字错误，john.slarly+=+1000会成功。尽管如此，它还是有效的。|style|CODE|1561346|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/tutorial/classes.html^0|1B|F|0|0|0|0|0|0|0|C|I|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|C|$]]|$1|M|3|N|5|F|7|19|8|@]|9|@]|C|$G|H]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1B|8|@$A|1C|B|1D|S|T]]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1E|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

I don't see this answer here, so I figure I'll add it since I'm leaning Python right now and just discovered it. The <a href="https://docs.python.org/2/tutorial/classes.html" rel="noreferrer">Python tutorial</a> (Python 2 in this case) gives the following simple and effective example:

<pre><code>class Employee:
 pass

john = Employee() # Create an empty employee record

# Fill the fields of the record
john.name = 'John Doe'
john.dept = 'computer lab'
john.salary = 1000
</code></pre>

That is, an empty class object is created, then instantiated, and the fields are added dynamically.

The up-side to this is its really simple. The downside is it isn't particularly self-documenting (the intended members aren't listed anywhere in the class "definition"), and unset fields can cause problems when accessed. Those two problems can be solved by:

<pre><code>class Employee:
 def __init__ (self):
 self.name = None # or whatever
 self.dept = None
 self.salary = None
</code></pre>

Now at a glance you can at least see what fields the program will be expecting.

Both are prone to typos, <code>john.slarly = 1000</code> will succeed. Still, it works.

blocks|key|1561409|text|我认为Python结构字典很适合这个要求。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1561410|d+=+dict{}
d[field1]+=+field1
d[field2]+=+field2
d[field2]+=+field3|code-block|syntax|javascript|1561411|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|$]]

I think Python structure dictionary is suitable for this requirement.

<pre class="lang-py prettyprint-override"><code>d = dict{}
d[field1] = field1
d[field2] = field2
d[field2] = field3
</code></pre>

blocks|key|1776577|text|https://stackoverflow.com/a/32448434/159695在Python3中不起作用。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1776578|https://stackoverflow.com/a/35993/159695在Python3中工作。|1776579|我对它进行了扩展，添加了默认值。|1776580|class+myStruct:
++++def+__init__(self,+**kwds):
++++++++self.x=0
++++++++self.__dict__.update(kwds)+#+Must+be+last+to+accept+assigned+member+variable.
++++def+__repr__(self):
++++++++args+=+['%25s=%25s'+%25+(k,+repr(v))+for+(k,v)+in+vars(self).items()]
++++++++return+'%25s(%25s)'+%25+(+self.__class__.__qualname__,+',+'.join(args)+)

a=myStruct()
b=myStruct(x=3,y='test')
c=myStruct(x='str')

>>>+a
myStruct(x=0)
>>>+b
myStruct(x=3,+y='test')
>>>+c
myStruct(x='str')|code-block|syntax|javascript|1776581|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/32448434/159695|1|https://stackoverflow.com/a/35993/159695^0|0|17|0|0|0|14|1|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

<a href="https://stackoverflow.com/a/32448434/159695">https://stackoverflow.com/a/32448434/159695</a> does not work in Python3.

<a href="https://stackoverflow.com/a/35993/159695">https://stackoverflow.com/a/35993/159695</a> works in Python3.

And I extends it to add default values.

<pre><code>class myStruct:
 def __init__(self, **kwds):
 self.x=0
 self.__dict__.update(kwds) # Must be last to accept assigned member variable.
 def __repr__(self):
 args = ['%s=%s' % (k, repr(v)) for (k,v) in vars(self).items()]
 return '%s(%s)' % ( self.__class__.__qualname__, ', '.join(args) )

a=myStruct()
b=myStruct(x=3,y='test')
c=myStruct(x='str')

&gt;&gt;&gt; a
myStruct(x=0)
&gt;&gt;&gt; b
myStruct(x=3, y='test')
&gt;&gt;&gt; c
myStruct(x='str')
</code></pre>

blocks|key|1776637|text|就我个人而言，我也喜欢这个变体。它扩展了@dF's+answer。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1776638|class+struct:
++++def+__init__(self,+*sequential,+**named):
++++++++fields+=+dict(zip(sequential,+[None]*len(sequential)),+**named)
++++++++self.__dict__.update(fields)
++++def+__repr__(self):
++++++++return+str(self.__dict__)|code-block|syntax|javascript|1776639|它支持两种初始化模式(可以混合)：|1776640|#+Struct+with+field1,+field2,+field3+that+are+initialized+to+None.
mystruct1+=+struct("field1",+"field2",+"field3")+
#+Struct+with+field1,+field2,+field3+that+are+initialized+according+to+arguments.
mystruct2+=+struct(field1=1,+field2=2,+field3=3)|1776641|而且，它的打印效果更好：|1776642|print(mystruct2)
#+Prints:+{'field3':+3,+'field1':+1,+'field2':+2}|1776643|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/35993/3388962^0|K|C|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Personally, I like this variant too. It extends <a href="https://stackoverflow.com/a/35993/3388962">@dF's answer</a>.

<pre><code>class struct:
 def __init__(self, *sequential, **named):
 fields = dict(zip(sequential, [None]*len(sequential)), **named)
 self.__dict__.update(fields)
 def __repr__(self):
 return str(self.__dict__)
</code></pre>

It supports two modes of initialization (that can be blended):

<pre><code># Struct with field1, field2, field3 that are initialized to None.
mystruct1 = struct("field1", "field2", "field3") 
# Struct with field1, field2, field3 that are initialized according to arguments.
mystruct2 = struct(field1=1, field2=2, field3=3)
</code></pre>

Also, it prints nicer: 

<pre><code>print(mystruct2)
# Prints: {'field3': 3, 'field1': 1, 'field2': 2}
</code></pre>

blocks|key|1776710|text|下面的结构解决方案的灵感来自于namedtuple实现和前面的一些答案。然而，与namedtuple不同的是，它的值是可变的，但就像c风格的结构在名称/属性中是不可变的，而普通类或dict不是这样的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1776711|_class_template+=+"""\
class+{typename}:
def+__init__(self,+*args,+**kwargs):
++++fields+=+{field_names!r}

++++for+x+in+fields:
++++++++setattr(self,+x,+None)++++++++++++

++++for+name,+value+in+zip(fields,+args):
++++++++setattr(self,+name,+value)

++++for+name,+value+in+kwargs.items():
++++++++setattr(self,+name,+value)++++++++++++

def+__repr__(self):
++++return+str(vars(self))

def+__setattr__(self,+name,+value):
++++if+name+not+in+{field_names!r}:
++++++++raise+KeyError("invalid+name:+%25s"+%25+name)
++++object.__setattr__(self,+name,+value)++++++++++++
"""

def+struct(typename,+field_names):

++++class_definition+=+_class_template.format(
++++++++typename+=+typename,
++++++++field_names+=+field_names)

++++namespace+=+dict(__name__='struct_%25s'+%25+typename)
++++exec(class_definition,+namespace)
++++result+=+namespace[typename]
++++result._source+=+class_definition

++++return+result|code-block|syntax|javascript|1776712|用法：|1776713|Person+=+struct('Person',+['firstname','lastname'])
generic+=+Person()
michael+=+Person('Michael')
jones+=+Person(lastname+=+'Jones')


In+[168]:+michael.middlename+=+'ben'
Traceback+(most+recent+call+last):

++File+"<ipython-input-168-b31c393c0d67>",+line+1,+in+<module>
michael.middlename+=+'ben'

++File+"<string>",+line+19,+in+__setattr__

KeyError:+'invalid+name:+middlename'|1776714|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|$]]

The following solution to a struct is inspired by the namedtuple implementation and some of the previous answers. However, unlike the namedtuple it is mutable, in it's values, but like the c-style struct immutable in the names/attributes, which a normal class or dict isn't.

<pre><code>_class_template = """\
class {typename}:
def __init__(self, *args, **kwargs):
 fields = {field_names!r}

 for x in fields:
 setattr(self, x, None) 

 for name, value in zip(fields, args):
 setattr(self, name, value)

 for name, value in kwargs.items():
 setattr(self, name, value) 

def __repr__(self):
 return str(vars(self))

def __setattr__(self, name, value):
 if name not in {field_names!r}:
 raise KeyError("invalid name: %s" % name)
 object.__setattr__(self, name, value) 
"""

def struct(typename, field_names):

 class_definition = _class_template.format(
 typename = typename,
 field_names = field_names)

 namespace = dict(__name__='struct_%s' % typename)
 exec(class_definition, namespace)
 result = namespace[typename]
 result._source = class_definition

 return result
</code></pre>

Usage:

<pre><code>Person = struct('Person', ['firstname','lastname'])
generic = Person()
michael = Person('Michael')
jones = Person(lastname = 'Jones')


In [168]: michael.middlename = 'ben'
Traceback (most recent call last):

 File "&lt;ipython-input-168-b31c393c0d67&gt;", line 1, in &lt;module&gt;
michael.middlename = 'ben'

 File "&lt;string&gt;", line 19, in __setattr__

KeyError: 'invalid name: middlename'
</code></pre>

blocks|key|1776770|text|如果你没有@dataclass的3.7版本，并且需要可变性，下面的代码可能对你有用。它非常具有自文档化和IDE友好(自动完成)功能，可以避免重复编写代码，易于扩展，并且可以非常简单地测试所有实例变量是否都已完全初始化：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1776771|class+Params():
++++def+__init__(self):
++++++++self.var1+:+int+=+None
++++++++self.var2+:+str+=+None

++++def+are_all_defined(self):
++++++++for+key,+value+in+self.__dict__.items():
++++++++++++assert+(value+is+not+None),+"instance+variable+{}+is+still+None".format(key)
++++++++return+True


params+=+Params()
params.var1+=+2
params.var2+=+'hello'
assert(params.are_all_defined)|code-block|syntax|javascript|1776772|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|$]]

If you don't have a 3.7 for @dataclass and need mutability, the following code might work for you. It's quite self-documenting and IDE-friendly (auto-complete), prevents writing things twice, is easily extendable and it is very simple to test that all instance variables are completely initialized:

<pre><code>class Params():
 def __init__(self):
 self.var1 : int = None
 self.var2 : str = None

 def are_all_defined(self):
 for key, value in self.__dict__.items():
 assert (value is not None), "instance variable {} is still None".format(key)
 return True


params = Params()
params.var1 = 2
params.var2 = 'hello'
assert(params.are_all_defined)
</code></pre>

blocks|key|1776808|text|这里有一个快速而肮脏的技巧：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1776809|>>>+ms+=+Warning()
>>>+ms.foo+=+123
>>>+ms.bar+=+'akafrit'|code-block|syntax|javascript|1776810|它是如何工作的？它只是重用了内置类Warning+(从Exception派生)，并像使用您自己定义的类一样使用它。|offset|length|style|CODE|1776811|优点是，您不需要首先导入或定义任何东西，“警告”是一个缩写名称，并且它还清楚地表明您正在做一些不应该在除您的小脚本之外的其他地方使用的事情。|1776812|顺便说一句，我试图找到更简单的东西，比如ms+=+object()，但是找不到(最后一个例子不起作用)。如果你有的话，我很感兴趣。|1776813|entityMap^0|0|0|H|7|R|9|0|0|K|D|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|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

Here is a quick and dirty trick:

<pre><code>&gt;&gt;&gt; ms = Warning()
&gt;&gt;&gt; ms.foo = 123
&gt;&gt;&gt; ms.bar = 'akafrit'
</code></pre>

How does it works? It just re-use the builtin class <code>Warning</code> (derived from <code>Exception</code>) and use it as it was you own defined class.

The good points are that you do not need to import or define anything first, that "Warning" is a short name, and that it also makes clear you are doing something dirty which should not be used elsewhere than a small script of yours.

By the way, I tried to find something even simpler like <code>ms = object()</code> but could not (this last exemple is not working). If you have one, I am interested.

Is there a way to conveniently define a C-like structure in Python? I'm tired of writing stuff like:

<pre><code>class MyStruct():
 def __init__(self, field1, field2, field3):
 self.field1 = field1
 self.field2 = field2
 self.field3 = field3
</code></pre>

C-like structures in Python

Python

有没有一种方法可以方便地在Python中定义类似C的结构？我厌倦了写这样的东西：class MyStruct():    def __init__(self, field1, field2, field3):        self.field1 = field1        self.field2 = field2...

问Python中的类C结构
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的类C结构EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的类C结构
EN