blocks|key|1827890|text|我不确定我是否完全理解了这个问题，但您可以在运行时使用类的内置__dict__修改实例属性：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1827891|class+C(object):
++++def+__init__(self,+ks,+vs):
++++++++self.__dict__+=+dict(zip(ks,+vs))


if+__name__+==+"__main__":
++++ks+=+['ab',+'cd']
++++vs+=+[12,+34]
++++c+=+C(ks,+vs)
++++print(c.ab)+#+12|code-block|syntax|javascript|1827892|entityMap^0|V|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|$]]

Not sure if I completely understand the question, but you can modify instance properties at runtime with the built-in <code>__dict__</code> of your class:

<pre><code>class C(object):
 def __init__(self, ks, vs):
 self.__dict__ = dict(zip(ks, vs))


if __name__ == "__main__":
 ks = ['ab', 'cd']
 vs = [12, 34]
 c = C(ks, vs)
 print(c.ab) # 12
</code></pre>

blocks|key|1828022|text|不能在运行时向实例添加新的property()，因为属性是数据描述符。相反，您必须动态创建一个新类，或者重载__getattribute__，以便处理实例上的数据描述符。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1828023|entityMap^0|D|A|1I|G|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

You cannot add a new <code>property()</code> to an instance at runtime, because properties are data descriptors. Instead you must dynamically create a new class, or overload <code>__getattribute__</code> in order to process data descriptors on instances.

blocks|key|1828057|text|看起来使用namedtuple可以更简单地解决这个问题，因为您提前知道了整个字段列表。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1828058|from+collections+import+namedtuple

Foo+=+namedtuple('Foo',+['bar',+'quux'])

foo+=+Foo(bar=13,+quux=74)
print+foo.bar,+foo.quux

foo2+=+Foo()++#+error|code-block|syntax|javascript|1828059|如果您确实需要编写自己的setter，则必须在类级别进行元编程；property()不能在实例上工作。|1828060|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/collections.html#collections.namedtuple^0|5|A|5|A|0|0|0|W|A|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

It seems you could solve this problem much more simply with a <a href="http://docs.python.org/library/collections.html#collections.namedtuple" rel="noreferrer"><code>namedtuple</code></a>, since you know the entire list of fields ahead of time.

<pre><code>from collections import namedtuple

Foo = namedtuple('Foo', ['bar', 'quux'])

foo = Foo(bar=13, quux=74)
print foo.bar, foo.quux

foo2 = Foo() # error
</code></pre>

If you absolutely need to write your own setter, you'll have to do the metaprogramming at the class level; <code>property()</code> doesn't work on instances.

blocks|key|2041977|text|动态附加属性的唯一方法是使用新属性创建一个新类及其实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2041978|class+Holder:+p+=+property(lambda+x:+vs[i],+self.fn_readonly)
setattr(self,+k,+Holder().p)|code-block|syntax|javascript|2041979|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|$]]

Only way to dynamically attach a property is to create a new class and its instance with your new property. 

<pre><code>class Holder: p = property(lambda x: vs[i], self.fn_readonly)
setattr(self, k, Holder().p)
</code></pre>

blocks|key|2042124|text|为此，您不需要使用属性。只需覆盖__setattr__，使其成为只读。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2042125|class+C(object):
++++def+__init__(self,+keys,+values):
++++++++for+(key,+value)+in+zip(keys,+values):
++++++++++++self.__dict__[key]+=+value

++++def+__setattr__(self,+name,+value):
++++++++raise+Exception("It+is+read+only!")|code-block|syntax|javascript|2042126|塔达。|2042127|>>>+c+=+C('abc',+[1,2,3])
>>>+c.a
1
>>>+c.b
2
>>>+c.c
3
>>>+c.d
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+<module>
AttributeError:+'C'+object+has+no+attribute+'d'
>>>+c.d+=+42
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+<module>
++File+"<stdin>",+line+6,+in+__setattr__
Exception:+It+is+read+only!
>>>+c.a+=+'blah'
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+<module>
++File+"<stdin>",+line+6,+in+__setattr__
Exception:+It+is+read+only!|2042128|entityMap^0|G|B|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 don't need to use a property for that. Just override <code>__setattr__</code> to make them read only.

<pre><code>class C(object):
 def __init__(self, keys, values):
 for (key, value) in zip(keys, values):
 self.__dict__[key] = value

 def __setattr__(self, name, value):
 raise Exception("It is read only!")
</code></pre>

Tada.

<pre><code>&gt;&gt;&gt; c = C('abc', [1,2,3])
&gt;&gt;&gt; c.a
1
&gt;&gt;&gt; c.b
2
&gt;&gt;&gt; c.c
3
&gt;&gt;&gt; c.d
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
AttributeError: 'C' object has no attribute 'd'
&gt;&gt;&gt; c.d = 42
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
 File "&lt;stdin&gt;", line 6, in __setattr__
Exception: It is read only!
&gt;&gt;&gt; c.a = 'blah'
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
 File "&lt;stdin&gt;", line 6, in __setattr__
Exception: It is read only!
</code></pre>

blocks|key|2042362|text|最好的实现方式是定义__slots__。这样你的实例就不能有新的属性了。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2042363|ks+=+['ab',+'cd']
vs+=+[12,+34]

class+C(dict):
++++__slots__+=+[]
++++def+__init__(self,+ks,+vs):+self.update(zip(ks,+vs))
++++def+__getattr__(self,+key):+return+self[key]

if+__name__+==+"__main__":
++++c+=+C(ks,+vs)
++++print+c.ab|code-block|syntax|javascript|2042364|打印12的代码|2042365|++++c.ab+=+33|2042366|这就是：AttributeError:+'C'+object+has+no+attribute+'ab'|2042367|entityMap^0|A|9|0|0|2|2|0|0|4|1C|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

The best way to achieve is by defining <code>__slots__</code>. That way your instances can't have new attributes.

<pre><code>ks = ['ab', 'cd']
vs = [12, 34]

class C(dict):
 __slots__ = []
 def __init__(self, ks, vs): self.update(zip(ks, vs))
 def __getattr__(self, key): return self[key]

if __name__ == "__main__":
 c = C(ks, vs)
 print c.ab
</code></pre>

That prints <code>12</code>

<pre><code> c.ab = 33
</code></pre>

That gives: <code>AttributeError: 'C' object has no attribute 'ab'</code>

blocks|key|1828467|text|这似乎是有效的(但见下文)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1828468|class+data(dict,object):
++++def+__init__(self,*args,**argd):
++++++++dict.__init__(self,*args,**argd)
++++++++self.__dict__.update(self)
++++def+__setattr__(self,name,value):
++++++++raise+AttributeError,"Attribute+'%25s'+of+'%25s'+object+cannot+be+set"%25(name,self.__class__.__name__)
++++def+__delattr__(self,name):
++++++++raise+AttributeError,"Attribute+'%25s'+of+'%25s'+object+cannot+be+deleted"%25(name,self.__class__.__name__)|code-block|syntax|javascript|1828469|如果您需要更复杂的行为，请随时编辑您的答案。|1828470|编辑|1828471|对于大型数据集，以下方法可能更节省内存：|1828472|class+data(dict,object):
++++def+__init__(self,*args,**argd):
++++++++dict.__init__(self,*args,**argd)
++++def+__getattr__(self,name):
++++++++return+self[name]
++++def+__setattr__(self,name,value):
++++++++raise+AttributeError,"Attribute+'%25s'+of+'%25s'+object+cannot+be+set"%25(name,self.__class__.__name__)
++++def+__delattr__(self,name):
++++++++raise+AttributeError,"Attribute+'%25s'+of+'%25s'+object+cannot+be+deleted"%25(name,self.__class__.__name__)|1828473|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|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|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This seems to work(but see below):

<pre><code>class data(dict,object):
 def __init__(self,*args,**argd):
 dict.__init__(self,*args,**argd)
 self.__dict__.update(self)
 def __setattr__(self,name,value):
 raise AttributeError,"Attribute '%s' of '%s' object cannot be set"%(name,self.__class__.__name__)
 def __delattr__(self,name):
 raise AttributeError,"Attribute '%s' of '%s' object cannot be deleted"%(name,self.__class__.__name__)
</code></pre>

If you need more complex behavior, feel free to edit your answer.

<h2>edit</h2>

The following would probably be more memory-efficient for large datasets:

<pre><code>class data(dict,object):
 def __init__(self,*args,**argd):
 dict.__init__(self,*args,**argd)
 def __getattr__(self,name):
 return self[name]
 def __setattr__(self,name,value):
 raise AttributeError,"Attribute '%s' of '%s' object cannot be set"%(name,self.__class__.__name__)
 def __delattr__(self,name):
 raise AttributeError,"Attribute '%s' of '%s' object cannot be deleted"%(name,self.__class__.__name__)
</code></pre>

blocks|key|2042471|text|我问了一个类似的问题on+this+Stack+Overflow+post来创建一个创建简单类型的类工厂。结果是this+answer，它有一个类工厂的工作版本。以下是答案的一小段：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2042472|def+Struct(*args,+**kwargs):
++++def+init(self,+*iargs,+**ikwargs):
++++++++for+k,v+in+kwargs.items():
++++++++++++setattr(self,+k,+v)
++++++++for+i+in+range(len(iargs)):
++++++++++++setattr(self,+args[i],+iargs[i])
++++++++for+k,v+in+ikwargs.items():
++++++++++++setattr(self,+k,+v)

++++name+=+kwargs.pop("name",+"MyStruct")
++++kwargs.update(dict((k,+None)+for+k+in+args))
++++return+type(name,+(object,),+{'__init__':+init,+'__slots__':+kwargs.keys()})

>>>+Person+=+Struct('fname',+'age')
>>>+person1+=+Person('Kevin',+25)
>>>+person2+=+Person(age=42,+fname='Terry')
>>>+person1.age+%2B=+10
>>>+person2.age+-=+10
>>>+person1.fname,+person1.age,+person2.fname,+person2.age
('Kevin',+35,+'Terry',+32)
>>>|code-block|syntax|javascript|2042473|您可以使用它的一些变体来创建默认值，这是您的目标(该问题中也有一个与此相关的答案)。|2042474|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1264833/python-class-factory-to-produce-simple-struct-like-classes|1|https://stackoverflow.com/questions/1264833/python-class-factory-to-produce-simple-struct-like-classes/1275088#1275088^0|A|R|0|1K|B|1|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]|$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|12|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

I asked a similary question <a href="https://stackoverflow.com/questions/1264833/python-class-factory-to-produce-simple-struct-like-classes">on this Stack Overflow post</a> to create a class factory which created simple types. The outcome was <a href="https://stackoverflow.com/questions/1264833/python-class-factory-to-produce-simple-struct-like-classes/1275088#1275088">this answer</a> which had a working version of the class factory.
Here is a snippet of the answer:

<pre><code>def Struct(*args, **kwargs):
 def init(self, *iargs, **ikwargs):
 for k,v in kwargs.items():
 setattr(self, k, v)
 for i in range(len(iargs)):
 setattr(self, args[i], iargs[i])
 for k,v in ikwargs.items():
 setattr(self, k, v)

 name = kwargs.pop("name", "MyStruct")
 kwargs.update(dict((k, None) for k in args))
 return type(name, (object,), {'__init__': init, '__slots__': kwargs.keys()})

&gt;&gt;&gt; Person = Struct('fname', 'age')
&gt;&gt;&gt; person1 = Person('Kevin', 25)
&gt;&gt;&gt; person2 = Person(age=42, fname='Terry')
&gt;&gt;&gt; person1.age += 10
&gt;&gt;&gt; person2.age -= 10
&gt;&gt;&gt; person1.fname, person1.age, person2.fname, person2.age
('Kevin', 35, 'Terry', 32)
&gt;&gt;&gt;
</code></pre>

You could use some variation of this to create default values which is your goal (there is also an answer in that question which deals with this).

blocks|key|1828607|text|我想我应该扩展这个答案，现在我更老了，更聪明了，并且知道发生了什么。晚做总比不做强。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1828608|可以将属性动态添加到类中。但这是个问题:您必须将其添加到类中。|1828609|>>>+class+Foo(object):
...+++++pass
...+
>>>+foo+=+Foo()
>>>+foo.a+=+3
>>>+Foo.b+=+property(lambda+self:+self.a+%2B+1)
>>>+foo.b
4|code-block|syntax|javascript|1828610|property实际上是一个叫做descriptor的东西的简单实现。它是一个对象，在给定的类上为给定的属性提供自定义处理。有点像从__getattribute__中分解出一棵巨大的if树的方法。|offset|length|style|CODE|1828611|当我在上面的示例中请求foo.b时，Python看到定义在类上的b实现了描述符协议-这仅仅意味着它是一个具有__get__、__set__或__delete__方法的对象。描述符声明负责处理该属性，因此Python调用Foo.b.__get__(foo,+Foo)，返回值作为该属性的值返回给您。对于property，这些方法中的每一个都只是调用您传递给property构造函数的fget、fset或fdel。|1828612|描述符实际上是Python公开其整个OO实现的管道的方式。事实上，还有一种比property更常见的描述符。|1828613|>>>+class+Foo(object):
...+++++def+bar(self):
...+++++++++pass
...+
>>>+Foo().bar
<bound+method+Foo.bar+of+<__main__.Foo+object+at+0x7f2a439d5dd0>>
>>>+Foo().bar.__get__
<method-wrapper+'__get__'+of+instancemethod+object+at+0x7f2a43a8a5a0>|1828614|谦虚的方法只是另一种描述符。它的__get__将调用实例作为第一个参数；实际上，它是这样做的：|1828615|def+__get__(self,+instance,+owner):
++++return+functools.partial(self.function,+instance)|1828616|无论如何，我怀疑这就是为什么描述符只能作用于类的原因:它们是最初为类提供动力的东西的形式化。它们甚至是规则的例外:显然，您可以将描述符分配给类，而类本身就是type的实例！实际上，尝试读取Foo.bar仍然会调用property.__get__；当作为类属性访问时，描述符会返回自身，这是惯用的做法。|1828617|我认为几乎所有的Python面向对象系统都可以用Python表达，这是非常酷的。:)|1828618|哦，如果你感兴趣的话，我前段时间写了一个wordy+blog+post+about+descriptors。|1828619|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/2/reference/datamodel.html#implementing-descriptors|1|http://me.veekun.com/blog/2012/05/23/python-faq-descriptors/^0|0|0|0|0|8|1U|G|2J|2|G|A|0|0|B|5|W|1|1I|7|1Q|7|1Y|A|31|N|46|8|4X|8|5A|4|5F|4|5K|4|0|12|8|0|0|G|7|0|0|26|4|2M|7|2Y|G|0|0|K|X|1|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1F|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1G|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1H|8|@$K|1I|L|1J|M|N]|$K|1K|L|1L|M|N]|$K|1M|L|1N|M|N]]|9|@$K|1O|L|1P|1|1Q]]|A|$]]|$1|O|3|P|5|6|7|1R|8|@$K|1S|L|1T|M|N]|$K|1U|L|1V|M|N]|$K|1W|L|1X|M|N]|$K|1Y|L|1Z|M|N]|$K|20|L|21|M|N]|$K|22|L|23|M|N]|$K|24|L|25|M|N]|$K|26|L|27|M|N]|$K|28|L|29|M|N]|$K|2A|L|2B|M|N]|$K|2C|L|2D|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|2E|8|@$K|2F|L|2G|M|N]]|9|@]|A|$]]|$1|S|3|T|5|F|7|2H|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|2I|8|@$K|2J|L|2K|M|N]]|9|@]|A|$]]|$1|W|3|X|5|F|7|2L|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|2M|8|@$K|2N|L|2O|M|N]|$K|2P|L|2Q|M|N]|$K|2R|L|2S|M|N]]|9|@]|A|$]]|$1|10|3|11|5|6|7|2T|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2U|8|@]|9|@$K|2V|L|2W|1|2X]]|A|$]]|$1|14|3|-4|5|6|7|2Y|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|1B]]|1C|$5|17|18|19|A|$1A|1D]]]]

I suppose I should expand this answer, now that I'm older and wiser and know what's going on. Better late than never.
You can add a property to a class dynamically. But that's the catch: you have to add it to the class.
<pre><code>&gt;&gt;&gt; class Foo(object):
... pass
... 
&gt;&gt;&gt; foo = Foo()
&gt;&gt;&gt; foo.a = 3
&gt;&gt;&gt; Foo.b = property(lambda self: self.a + 1)
&gt;&gt;&gt; foo.b
4
</code></pre>
A <code>property</code> is actually a simple implementation of a thing called a <a href="http://docs.python.org/2/reference/datamodel.html#implementing-descriptors" rel="noreferrer">descriptor</a>. It's an object that provides custom handling for a given attribute, on a given class. Kinda like a way to factor a huge <code>if</code> tree out of <code>__getattribute__</code>.
When I ask for <code>foo.b</code> in the example above, Python sees that the <code>b</code> defined on the class implements the descriptor protocol—which just means it's an object with a <code>__get__</code>, <code>__set__</code>, or <code>__delete__</code> method. The descriptor claims responsibility for handling that attribute, so Python calls <code>Foo.b.__get__(foo, Foo)</code>, and the return value is passed back to you as the value of the attribute. In the case of <code>property</code>, each of these methods just calls the <code>fget</code>, <code>fset</code>, or <code>fdel</code> you passed to the <code>property</code> constructor.
Descriptors are really Python's way of exposing the plumbing of its entire OO implementation. In fact, there's another type of descriptor even more common than <code>property</code>.
<pre><code>&gt;&gt;&gt; class Foo(object):
... def bar(self):
... pass
... 
&gt;&gt;&gt; Foo().bar
&lt;bound method Foo.bar of &lt;__main__.Foo object at 0x7f2a439d5dd0&gt;&gt;
&gt;&gt;&gt; Foo().bar.__get__
&lt;method-wrapper '__get__' of instancemethod object at 0x7f2a43a8a5a0&gt;
</code></pre>
The humble method is just another kind of descriptor. Its <code>__get__</code> tacks on the calling instance as the first argument; in effect, it does this:
<pre><code>def __get__(self, instance, owner):
 return functools.partial(self.function, instance)
</code></pre>
Anyway, I suspect this is why descriptors only work on classes: they're a formalization of the stuff that powers classes in the first place. They're even the exception to the rule: you can obviously assign descriptors to a class, and classes are themselves instances of <code>type</code>! In fact, trying to read <code>Foo.bar</code> still calls <code>property.__get__</code>; it's just idiomatic for descriptors to return themselves when accessed as class attributes.
I think it's pretty cool that virtually all of Python's OO system can be expressed in Python. :)
Oh, and I wrote a <a href="http://me.veekun.com/blog/2012/05/23/python-faq-descriptors/" rel="noreferrer">wordy blog post about descriptors</a> a while back if you're interested.

blocks|key|2042611|text|我最近遇到了一个类似的问题，我想出的解决方案使用__getattr__和__setattr__来处理我想要它处理的属性，其他的都传递给原始的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2042612|class+C(object):
++++def+__init__(self,+properties):
++++++++self.existing+=+"Still+Here"
++++++++self.properties+=+properties

++++def+__getattr__(self,+name):
++++++++if+"properties"+in+self.__dict__+and+name+in+self.properties:
++++++++++++return+self.properties[name]+#+Or+call+a+function,+etc
++++++++return+self.__dict__[name]

++++def+__setattr__(self,+name,+value):
++++++++if+"properties"+in+self.__dict__+and+name+in+self.properties:
++++++++++++self.properties[name]+=+value
++++++++else:
++++++++++++self.__dict__[name]+=+value

if+__name__+==+"__main__":
++++my_properties+=+{'a':1,+'b':2,+'c':3}
++++c+=+C(my_properties)
++++assert+c.a+==+1
++++assert+c.existing+==+"Still+Here"
++++c.b+=+10
++++assert+c.properties['b']+==+10|code-block|syntax|javascript|2042613|entityMap^0|O|B|10|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

I recently ran into a similar problem, the solution that I came up with uses <code>__getattr__</code> and <code>__setattr__</code> for the properties that I want it to handle, everything else gets passed on to the originals.

<pre><code>class C(object):
 def __init__(self, properties):
 self.existing = "Still Here"
 self.properties = properties

 def __getattr__(self, name):
 if "properties" in self.__dict__ and name in self.properties:
 return self.properties[name] # Or call a function, etc
 return self.__dict__[name]

 def __setattr__(self, name, value):
 if "properties" in self.__dict__ and name in self.properties:
 self.properties[name] = value
 else:
 self.__dict__[name] = value

if __name__ == "__main__":
 my_properties = {'a':1, 'b':2, 'c':3}
 c = C(my_properties)
 assert c.a == 1
 assert c.existing == "Still Here"
 c.b = 10
 assert c.properties['b'] == 10
</code></pre>

blocks|key|1828744|text|只是如何达到预期效果的另一个例子|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1828745|class+Foo(object):

++++_bar+=+None

++++@property
++++def+bar(self):
++++++++return+self._bar

++++@bar.setter
++++def+bar(self,+value):
++++++++self._bar+=+value

++++def+__init__(self,+dyn_property_name):
++++++++setattr(Foo,+dyn_property_name,+Foo.bar)|code-block|syntax|javascript|1828746|所以现在我们可以做这样的事情：|1828747|>>>+foo+=+Foo('baz')
>>>+foo.baz+=+5
>>>+foo.bar
5
>>>+foo.baz
5|1828748|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|$]]

Just another example how to achieve desired effect

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

 _bar = None

 @property
 def bar(self):
 return self._bar

 @bar.setter
 def bar(self, value):
 self._bar = value

 def __init__(self, dyn_property_name):
 setattr(Foo, dyn_property_name, Foo.bar)
</code></pre>

So now we can do stuff like:

<pre><code>&gt;&gt;&gt; foo = Foo('baz')
&gt;&gt;&gt; foo.baz = 5
&gt;&gt;&gt; foo.bar
5
&gt;&gt;&gt; foo.baz
5
</code></pre>

blocks|key|2042772|text|对于那些来自搜索引擎的人，这里是我在谈论动态属性时寻找的两件事：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2042773|class+Foo:
++++def+__init__(self):
++++++++#+we+can+dynamically+have+access+to+the+properties+dict+using+__dict__
++++++++self.__dict__['foo']+=+'bar'

assert+Foo().foo+==+'bar'


#+or+we+can+use+__getattr__+and+__setattr__+to+execute+code+on+set/get
class+Bar:
++++def+__init__(self):
++++++++self._data+=+{}
++++def+__getattr__(self,+key):
++++++++return+self._data[key]
++++def+__setattr__(self,+key,+value):
++++++++self._data[key]+=+value

bar+=+Bar()
bar.foo+=+'bar'
assert+bar.foo+==+'bar'|code-block|syntax|javascript|2042774|如果你想放置动态创建的属性，__dict__是很好的选择。__getattr__最好只在需要值的时候执行一些操作，比如查询数据库。set/get组合很好地简化了对存储在类中的数据的访问(如上面的示例所示)。|offset|length|style|CODE|2042775|如果您只想要一个动态属性，请看一下property()内置函数。|2042776|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/functions.html#property^0|0|0|E|8|T|B|0|H|A|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@$I|14|J|15|1|16]]|A|$]]|$1|O|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

For those coming from search engines, here are the two things I was looking for when talking about dynamic properties:

<pre><code>class Foo:
 def __init__(self):
 # we can dynamically have access to the properties dict using __dict__
 self.__dict__['foo'] = 'bar'

assert Foo().foo == 'bar'


# or we can use __getattr__ and __setattr__ to execute code on set/get
class Bar:
 def __init__(self):
 self._data = {}
 def __getattr__(self, key):
 return self._data[key]
 def __setattr__(self, key, value):
 self._data[key] = value

bar = Bar()
bar.foo = 'bar'
assert bar.foo == 'bar'
</code></pre>

<code>__dict__</code> is good if you want to put dynamically created properties. <code>__getattr__</code> is good to only do something when the value is needed, like query a database. The set/get combo is good to simplify the access to data stored in the class (like in the example above).

If you only want one dynamic property, have a look at the <a href="https://docs.python.org/3/library/functions.html#property" rel="noreferrer">property()</a> built-in function.

blocks|key|1828832|text|class+atdict(dict):
++def+__init__(self,+value,+**kwargs):
++++super().__init__(**kwargs)
++++self.__dict+=+value

++def+__getattr__(self,+name):
++++for+key+in+self.__dict:
++++++if+type(self.__dict[key])+is+list:
++++++++for+idx,+item+in+enumerate(self.__dict[key]):
++++++++++if+type(item)+is+dict:
++++++++++++self.__dict[key][idx]+=+atdict(item)
++++++if+type(self.__dict[key])+is+dict:
++++++++self.__dict[key]+=+atdict(self.__dict[key])
++++return+self.__dict[name]



d1+=+atdict({'a'+:+{'b':+[{'c':+1},+2]}})

print(d1.a.b[0].c)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1828833|输出结果为：|unstyled|1828834|>>+1|1828835|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>class atdict(dict):
 def __init__(self, value, **kwargs):
 super().__init__(**kwargs)
 self.__dict = value

 def __getattr__(self, name):
 for key in self.__dict:
 if type(self.__dict[key]) is list:
 for idx, item in enumerate(self.__dict[key]):
 if type(item) is dict:
 self.__dict[key][idx] = atdict(item)
 if type(self.__dict[key]) is dict:
 self.__dict[key] = atdict(self.__dict[key])
 return self.__dict[name]



d1 = atdict({'a' : {'b': [{'c': 1}, 2]}})

print(d1.a.b[0].c)
</code></pre>

And the output is:

<pre><code>&gt;&gt; 1
</code></pre>

blocks|key|2042987|text|可以使用以下代码通过字典对象更新类属性：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2042988|class+ExampleClass():
++++def+__init__(self,+argv):
++++++++for+key,+val+in+argv.items():
++++++++++++self.__dict__[key]+=+val

if+__name__+==+'__main__':
++++argv+=+{'intro':+'Hello+World!'}
++++instance+=+ExampleClass(argv)
++++print+instance.intro|code-block|syntax|javascript|2042989|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 use the following code to update class attributes using a dictionary object:

<pre><code>class ExampleClass():
 def __init__(self, argv):
 for key, val in argv.items():
 self.__dict__[key] = val

if __name__ == '__main__':
 argv = {'intro': 'Hello World!'}
 instance = ExampleClass(argv)
 print instance.intro
</code></pre>

blocks|key|2043083|text|扩展来自kjfletch的想法|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2043084|#+This+is+my+humble+contribution,+extending+the+idea+to+serialize
#+data+from+and+to+tuples,+comparison+operations+and+allowing+functions
#+as+default+values.

def+Struct(*args,+**kwargs):
++++FUNCTIONS+=+(types.BuiltinFunctionType,+types.BuiltinMethodType,+\
+++++++++++++++++types.FunctionType,+types.MethodType)
++++def+init(self,+*iargs,+**ikwargs):
++++++++"""Asume+that+unamed+args+are+placed+in+the+same+order+than
++++++++astuple()+yields+(currently+alphabetic+order)
++++++++"""
++++++++kw+=+list(self.__slots__)

++++++++#+set+the+unnamed+args
++++++++for+i+in+range(len(iargs)):
++++++++++++k+=+kw.pop(0)
++++++++++++setattr(self,+k,+iargs[i])

++++++++#+set+the+named+args
++++++++for+k,+v+in+ikwargs.items():
++++++++++++setattr(self,+k,+v)
++++++++++++kw.remove(k)

++++++++#+set+default+values
++++++++for+k+in+kw:
++++++++++++v+=+kwargs[k]
++++++++++++if+isinstance(v,+FUNCTIONS):
++++++++++++++++v+=+v()
++++++++++++setattr(self,+k,+v)

++++def+astuple(self):
++++++++return+tuple([getattr(self,+k)+for+k+in+self.__slots__])

++++def+__str__(self):
++++++++data+=+['{}={}'.format(k,+getattr(self,+k))+for+k+in+self.__slots__]
++++++++return+'<{}:+{}>'.format(self.__class__.__name__,+',+'.join(data))

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

++++def+__eq__(self,+other):
++++++++return+self.astuple()+==+other.astuple()

++++name+=+kwargs.pop("__name__",+"MyStruct")
++++slots+=+list(args)
++++slots.extend(kwargs.keys())
++++#+set+non-specific+default+values+to+None
++++kwargs.update(dict((k,+None)+for+k+in+args))

++++return+type(name,+(object,),+{
++++++++'__init__':+init,
++++++++'__slots__':+tuple(slots),
++++++++'astuple':+astuple,
++++++++'__str__':+__str__,
++++++++'__repr__':+__repr__,
++++++++'__eq__':+__eq__,
++++})


Event+=+Struct('user',+'cmd',+\
+++++++++++++++'arg1',+'arg2',++\
+++++++++++++++date=time.time,+\
+++++++++++++++__name__='Event')

aa+=+Event('pepe',+77)
print(aa)
raw+=+aa.astuple()

bb+=+Event(*raw)
print(bb)

if+aa+==+bb:
++++print('Are+equals')

cc+=+Event(cmd='foo')
print(cc)|code-block|syntax|javascript|2043085|输出：|2043086|<Event:+user=pepe,+cmd=77,+arg1=None,+arg2=None,+date=1550051398.3651814>
<Event:+user=pepe,+cmd=77,+arg1=None,+arg2=None,+date=1550051398.3651814>
Are+equals
<Event:+user=None,+cmd=foo,+arg1=None,+arg2=None,+date=1550051403.7938335>|2043087|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/134107/kjfletch^0|4|8|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Extending the idea from <a href="https://stackoverflow.com/users/134107/kjfletch">kjfletch</a>

<pre><code># This is my humble contribution, extending the idea to serialize
# data from and to tuples, comparison operations and allowing functions
# as default values.

def Struct(*args, **kwargs):
 FUNCTIONS = (types.BuiltinFunctionType, types.BuiltinMethodType, \
 types.FunctionType, types.MethodType)
 def init(self, *iargs, **ikwargs):
 """Asume that unamed args are placed in the same order than
 astuple() yields (currently alphabetic order)
 """
 kw = list(self.__slots__)

 # set the unnamed args
 for i in range(len(iargs)):
 k = kw.pop(0)
 setattr(self, k, iargs[i])

 # set the named args
 for k, v in ikwargs.items():
 setattr(self, k, v)
 kw.remove(k)

 # set default values
 for k in kw:
 v = kwargs[k]
 if isinstance(v, FUNCTIONS):
 v = v()
 setattr(self, k, v)

 def astuple(self):
 return tuple([getattr(self, k) for k in self.__slots__])

 def __str__(self):
 data = ['{}={}'.format(k, getattr(self, k)) for k in self.__slots__]
 return '&lt;{}: {}&gt;'.format(self.__class__.__name__, ', '.join(data))

 def __repr__(self):
 return str(self)

 def __eq__(self, other):
 return self.astuple() == other.astuple()

 name = kwargs.pop("__name__", "MyStruct")
 slots = list(args)
 slots.extend(kwargs.keys())
 # set non-specific default values to None
 kwargs.update(dict((k, None) for k in args))

 return type(name, (object,), {
 '__init__': init,
 '__slots__': tuple(slots),
 'astuple': astuple,
 '__str__': __str__,
 '__repr__': __repr__,
 '__eq__': __eq__,
 })


Event = Struct('user', 'cmd', \
 'arg1', 'arg2', \
 date=time.time, \
 __name__='Event')

aa = Event('pepe', 77)
print(aa)
raw = aa.astuple()

bb = Event(*raw)
print(bb)

if aa == bb:
 print('Are equals')

cc = Event(cmd='foo')
print(cc)
</code></pre>

Output:

<pre><code>&lt;Event: user=pepe, cmd=77, arg1=None, arg2=None, date=1550051398.3651814&gt;
&lt;Event: user=pepe, cmd=77, arg1=None, arg2=None, date=1550051398.3651814&gt;
Are equals
&lt;Event: user=None, cmd=foo, arg1=None, arg2=None, date=1550051403.7938335&gt;
</code></pre>

blocks|key|2043371|text|虽然给出了很多答案，但我找不到一个我满意的答案。我想出了我自己的解决方案，让property在动态情况下工作。回答原始问题的来源：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2043372|#!/usr/local/bin/python3

INITS+=+{+'ab':+100,+'cd':+200+}

class+DP(dict):
++def+__init__(self):
++++super().__init__()
++++for+k,v+in+INITS.items():
++++++++self[k]+=+v+

def+_dict_set(dp,+key,+value):
++dp[key]+=+value

for+item+in+INITS.keys():
++setattr(
++++DP,
++++item,
++++lambda+key:+property(
++++++lambda+self:+self[key],+lambda+self,+value:+_dict_set(self,+key,+value)
++++)(item)
++)

a+=+DP()
print(a)++#+{'ab':+100,+'cd':+200}
a.ab+=+'ab100'
a.cd+=+False
print(a.ab,+a.cd)+#+ab100+False|code-block|syntax|javascript|2043373|entityMap^0|12|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|$]]

Although many answers are given, I couldn't find one I am happy with. I figured out my own solution which makes <code>property</code> work for the dynamic case. The source to answer the original question:

<pre><code>#!/usr/local/bin/python3

INITS = { 'ab': 100, 'cd': 200 }

class DP(dict):
 def __init__(self):
 super().__init__()
 for k,v in INITS.items():
 self[k] = v 

def _dict_set(dp, key, value):
 dp[key] = value

for item in INITS.keys():
 setattr(
 DP,
 item,
 lambda key: property(
 lambda self: self[key], lambda self, value: _dict_set(self, key, value)
 )(item)
 )

a = DP()
print(a) # {'ab': 100, 'cd': 200}
a.ab = 'ab100'
a.cd = False
print(a.ab, a.cd) # ab100 False
</code></pre>

blocks|key|1829453|text|对我有效的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1829454|class+C:
++++def+__init__(self):
++++++++self._x=None

++++def+g(self):
++++++++return+self._x

++++def+s(self,+x):
++++++++self._x+=+x

++++def+d(self):
++++++++del+self._x

++++def+s2(self,x):
++++++++self._x=x%2Bx

++++x=property(g,s,d)


c+=+C()
c.x="a"
print(c.x)

C.x=property(C.g,+C.s2)
C.x=C.x.deleter(C.d)
c2+=+C()
c2.x="a"
print(c2.x)|code-block|syntax|javascript|1829455|1829456|输出|1829457|a
aa|1829458|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|O|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Q|8|@]|9|@]|A|$]]|$1|J|3|K|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

Something that works for me is this:

<pre><code>class C:
 def __init__(self):
 self._x=None

 def g(self):
 return self._x

 def s(self, x):
 self._x = x

 def d(self):
 del self._x

 def s2(self,x):
 self._x=x+x

 x=property(g,s,d)


c = C()
c.x="a"
print(c.x)

C.x=property(C.g, C.s2)
C.x=C.x.deleter(C.d)
c2 = C()
c2.x="a"
print(c2.x)
</code></pre>

<hr>

Output

<pre><code>a
aa
</code></pre>

blocks|key|1829659|text|这与OP想要的有点不同，但我绞尽脑汁，直到得到一个可行的解决方案，所以我在这里为下一个人/女孩|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1829660|我需要一种指定动态setter和getter的方法。|1829661|class+X:
++++def+__init__(self,+a=0,+b=0,+c=0):
++++++++self.a+=+a
++++++++self.b+=+b
++++++++self.c+=+c

++++@classmethod
++++def+_make_properties(cls,+field_name,+inc):
++++++++_inc+=+inc

++++++++def+_get_properties(self):
++++++++++++if+not+hasattr(self,+'_%25s_inc'+%25+field_name):
++++++++++++++++setattr(self,+'_%25s_inc'+%25+field_name,+_inc)
++++++++++++++++inc+=+_inc
++++++++++++else:
++++++++++++++++inc+=+getattr(self,+'_%25s_inc'+%25+field_name)

++++++++++++return+getattr(self,+field_name)+%2B+inc

++++++++def+_set_properties(self,+value):
++++++++++++setattr(self,+'_%25s_inc'+%25+field_name,+value)

++++++++return+property(_get_properties,+_set_properties)|code-block|syntax|javascript|1829662|我提前知道了我的字段，所以我要创建我的属性。注意:您不能针对每个实例执行此操作，这些属性将存在于类中！|1829663|for+inc,+field+in+enumerate(['a',+'b',+'c']):
++++setattr(X,+'%25s_summed'+%25+field,+X._make_properties(field,+inc))|1829664|现在让我们全部测试一下..|1829665|x+=+X()
assert+x.a+==+0
assert+x.b+==+0
assert+x.c+==+0

assert+x.a_summed+==+0++#+enumerate()+set+inc+to+0+%2B+0+=+0
assert+x.b_summed+==+1++#+enumerate()+set+inc+to+1+%2B+0+=+1
assert+x.c_summed+==+2++#+enumerate()+set+inc+to+2+%2B+0+=+2

#+we+set+the+variables+to+something
x.a+=+1
x.b+=+2
x.c+=+3

assert+x.a_summed+==+1++#+enumerate()+set+inc+to+0+%2B+1+=+1
assert+x.b_summed+==+3++#+enumerate()+set+inc+to+1+%2B+2+=+3
assert+x.c_summed+==+5++#+enumerate()+set+inc+to+2+%2B+3+=+5

#+we're+changing+the+inc+now
x.a_summed+=+1+
x.b_summed+=+3+
x.c_summed+=+5

assert+x.a_summed+==+2++#+we+set+inc+to+1+%2B+the+property+was+1+=+2
assert+x.b_summed+==+5++#+we+set+inc+to+3+%2B+the+property+was+2+=+5
assert+x.c_summed+==+8++#+we+set+inc+to+5+%2B+the+property+was+3+=+8|1829666|这让人困惑吗？是的，很抱歉我想不出任何有意义的现实世界的例子。另外，这不是给心情轻松的人看的。|1829667|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|F|7|10|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

This is a little different than what OP wanted, but I rattled my brain until I got a working solution, so I'm putting here for the next guy/gal

I needed a way to specify dynamic setters and getters.

<pre><code>class X:
 def __init__(self, a=0, b=0, c=0):
 self.a = a
 self.b = b
 self.c = c

 @classmethod
 def _make_properties(cls, field_name, inc):
 _inc = inc

 def _get_properties(self):
 if not hasattr(self, '_%s_inc' % field_name):
 setattr(self, '_%s_inc' % field_name, _inc)
 inc = _inc
 else:
 inc = getattr(self, '_%s_inc' % field_name)

 return getattr(self, field_name) + inc

 def _set_properties(self, value):
 setattr(self, '_%s_inc' % field_name, value)

 return property(_get_properties, _set_properties)
</code></pre>

I know my fields ahead of time so im going to create my properties. NOTE: you cannot do this PER instance, these properties will exist on the class!!!

<pre><code>for inc, field in enumerate(['a', 'b', 'c']):
 setattr(X, '%s_summed' % field, X._make_properties(field, inc))
</code></pre>

Let's test it all now..

<pre><code>x = X()
assert x.a == 0
assert x.b == 0
assert x.c == 0

assert x.a_summed == 0 # enumerate() set inc to 0 + 0 = 0
assert x.b_summed == 1 # enumerate() set inc to 1 + 0 = 1
assert x.c_summed == 2 # enumerate() set inc to 2 + 0 = 2

# we set the variables to something
x.a = 1
x.b = 2
x.c = 3

assert x.a_summed == 1 # enumerate() set inc to 0 + 1 = 1
assert x.b_summed == 3 # enumerate() set inc to 1 + 2 = 3
assert x.c_summed == 5 # enumerate() set inc to 2 + 3 = 5

# we're changing the inc now
x.a_summed = 1 
x.b_summed = 3 
x.c_summed = 5

assert x.a_summed == 2 # we set inc to 1 + the property was 1 = 2
assert x.b_summed == 5 # we set inc to 3 + the property was 2 = 5
assert x.c_summed == 8 # we set inc to 5 + the property was 3 = 8
</code></pre>

Is it confusing? Yes, sorry I couldn't come up with any meaningful real world examples. Also, this is not for the light hearted.

blocks|key|1829722|text|下面是以编程方式创建属性对象的简单示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1829723|#!/usr/bin/python3

class+Counter:
++++def+__init__(self):
++++++++cls+=+self.__class__
++++++++self._count+=+0
++++++++cls.count+=+self.count_ref()

++++def+count_get(self):
++++++++print(f'count_get:+{self._count}')
++++++++return+self._count

++++def+count_set(self,+value):
++++++++self._count+=+value
++++++++print(f'count_set:+{self._count}')

++++def+count_del(self):
++++++++print(f'count_del:+{self._count}')

++++def+count_ref(self):
++++++++cls+=+self.__class__
++++++++return+property(fget=cls.count_get,+fset=cls.count_set,+fdel=cls.count_del)

counter+=+Counter()

counter.count
for+i+in+range(5):
++++counter.count+=+i
del+counter.count

'''
output
======
count_get:+0
count_set:+0
count_set:+1
count_set:+2
count_set:+3
count_set:+4
count_del:+4
'''|code-block|syntax|javascript|1829724|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 is the simple example to create property object programmatically.

<pre><code>#!/usr/bin/python3

class Counter:
 def __init__(self):
 cls = self.__class__
 self._count = 0
 cls.count = self.count_ref()

 def count_get(self):
 print(f'count_get: {self._count}')
 return self._count

 def count_set(self, value):
 self._count = value
 print(f'count_set: {self._count}')

 def count_del(self):
 print(f'count_del: {self._count}')

 def count_ref(self):
 cls = self.__class__
 return property(fget=cls.count_get, fset=cls.count_set, fdel=cls.count_del)

counter = Counter()

counter.count
for i in range(5):
 counter.count = i
del counter.count

'''
output
======
count_get: 0
count_set: 0
count_set: 1
count_set: 2
count_set: 3
count_set: 4
count_del: 4
'''
</code></pre>

blocks|key|2043757|text|如果需求是基于某个实例属性动态生成属性，则以下代码可能会很有用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2043758|import+random++

class+Foo:
++++def+__init__(self,+prop_names:+List[str],+should_property_be_zero:+bool+=+False)+->+None:
++++++++self.prop_names+=+prop_names
++++++++self.should_property_be_zero+=+should_property_be_zero
++++++++
++++def+create_properties(self):
++++++++for+name+in+self.prop_names:
++++++++++++setattr(self.__class__,+name,+property(fget=lambda+self:+0+if+self.should_property_be_zero+else+random.randint(1,+100)))|code-block|syntax|javascript|2043759|需要注意的重要一点是使用setattr(self.__class__,+name,+...)而不是setattr(self,+name,+...)|offset|length|style|CODE|2043760|使用示例：|2043761|In+[261]:+prop_names+=+['a',+'b']

In+[262]:+ff+=+Foo(prop_names=prop_names,+should_property_be_zero=False)

In+[263]:+ff.create_properties()

In+[264]:+ff.a
Out[264]:+10

In+[265]:+ff.b
Out[265]:+37

In+[266]:+ft+=+Foo(prop_names=prop_names,+should_property_be_zero=True)

In+[267]:+ft.create_properties()

In+[268]:+ft.a
Out[268]:+0

In+[269]:+ft.b
Out[269]:+0|2043762|设置该属性将引发预期的AttributeError:+can't+set+attribute：|2043763|In+[270]:+ff.a+=+5
---------------------------------------------------------------------------
AttributeError++++++++++++++++++++++++++++Traceback+(most+recent+call+last)
<ipython-input-270-5f9cad5b617d>+in+<module>
---->+1+ff.a+=+5

AttributeError:+can't+set+attribute

In+[271]:+ft.a+=+5
---------------------------------------------------------------------------
AttributeError++++++++++++++++++++++++++++Traceback+(most+recent+call+last)
<ipython-input-271-65e7b8e25b67>+in+<module>
---->+1+ft.a+=+5

AttributeError:+can't+set+attribute|2043764|entityMap^0|0|0|C|Y|1D|O|0|0|0|B|Z|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|15|8|@$I|16|J|17|K|L]]|9|@]|A|$]]|$1|S|3|T|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|V|$]]

If the requirement is to dynamically generate properties based on some instance attribute, then the below code can be useful:
<pre><code>import random 

class Foo:
 def __init__(self, prop_names: List[str], should_property_be_zero: bool = False) -&gt; None:
 self.prop_names = prop_names
 self.should_property_be_zero = should_property_be_zero
 
 def create_properties(self):
 for name in self.prop_names:
 setattr(self.__class__, name, property(fget=lambda self: 0 if self.should_property_be_zero else random.randint(1, 100)))
</code></pre>
The important point to note is to use <code>setattr(self.__class__, name, ...)</code> and not <code>setattr(self, name, ...)</code>
Usage Example:
<pre><code>In [261]: prop_names = ['a', 'b']

In [262]: ff = Foo(prop_names=prop_names, should_property_be_zero=False)

In [263]: ff.create_properties()

In [264]: ff.a
Out[264]: 10

In [265]: ff.b
Out[265]: 37

In [266]: ft = Foo(prop_names=prop_names, should_property_be_zero=True)

In [267]: ft.create_properties()

In [268]: ft.a
Out[268]: 0

In [269]: ft.b
Out[269]: 0
</code></pre>
Setting the property will raise <code>AttributeError: can't set attribute</code> as expected:
<pre><code>In [270]: ff.a = 5
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
&lt;ipython-input-270-5f9cad5b617d&gt; in &lt;module&gt;
----&gt; 1 ff.a = 5

AttributeError: can't set attribute

In [271]: ft.a = 5
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
&lt;ipython-input-271-65e7b8e25b67&gt; in &lt;module&gt;
----&gt; 1 ft.a = 5

AttributeError: can't set attribute
</code></pre>

The goal is to create a mock class which behaves like a db resultset.

So for example, if a database query returns, using a dict expression, <code>{'ab':100, 'cd':200}</code>, then I would like to see: 

<pre><code>&gt;&gt;&gt; dummy.ab
100
</code></pre>

At first I thought maybe I could do it this way:

<pre><code>ks = ['ab', 'cd']
vs = [12, 34]
class C(dict):
 def __init__(self, ks, vs):
 for i, k in enumerate(ks):
 self[k] = vs[i]
 setattr(self, k, property(lambda x: vs[i], self.fn_readyonly))

 def fn_readonly(self, v)
 raise "It is ready only"

if __name__ == "__main__":
 c = C(ks, vs)
 print c.ab
</code></pre>

but <code>c.ab</code> returns a property object instead.

Replacing the <code>setattr</code> line with <code>k = property(lambda x: vs[i])</code> is of no use at all.

So what is the right way to create an instance property at runtime?

P.S. I am aware of an alternative presented in <a href="https://stackoverflow.com/questions/371753/how-is-the-getattribute-method-used">How is the <code>__getattribute__</code> method used?</a>

How to add property to a class dynamically?

数据库

Python

目标是创建一个mock类，它的行为类似于db结果集。例如，如果数据库查询使用dict表达式{'ab':100, 'cd':200}返回，那么我希望看到：>>> dummy.ab100一开始我想也许我可以这样做：ks = ['ab', 'cd']vs = [12, 34]class C(dict):    def __i...

问如何为类动态添加属性？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何为类动态添加属性？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何为类动态添加属性？
EN