我想我应该扩展这个答案，现在我长大了，更聪明了，知道发生了什么。迟到总比不到好。

可以动态地向类添加属性。但这就是问题所在:你必须把它添加到类中。

>>> class Foo(object):
...     pass
... 
>>> foo = Foo()
>>> foo.a = 3
>>> Foo.b = property(lambda self: self.a + 1)
>>> foo.b
4

属性实际上是描述符的简单实现。它是一个对象，为给定类的给定属性提供自定义处理。有点像从__getattribute__中分解出一个巨大的if树。

When I ask for foo.b in the example above, Python sees that the b defined on the class implements the descriptor protocol—which just means it's an object with a __get__, __set__, or __delete__ method. The descriptor claims responsibility for handling that attribute, so Python calls Foo.b.__get__(foo, Foo), and the return value is passed back to you as the value of the attribute. In the case of property, each of these methods just calls the fget, fset, or fdel you passed to the property constructor.

描述符实际上是Python暴露其整个OO实现管道的方式。事实上，还有一种比属性更常见的描述符。

>>> 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>

简单的方法只是另一种描述符。它的__get__将调用实例作为第一个参数;实际上，它是这样做的:

def __get__(self, instance, owner):
    return functools.partial(self.function, instance)

不管怎样，我怀疑这就是为什么描述符只在类上起作用:它们是首先为类提供动力的东西的形式化。它们甚至是规则的例外:您可以明显地为类分配描述符，而类本身就是类型的实例!事实上，我试着读Foo。Bar仍然调用property.__get__;描述符在作为类属性访问时返回自己，这只是一种习惯。

我认为几乎所有Python的OO系统都可以用Python来表达，这非常酷。：）

哦，如果你感兴趣的话，我之前写过一篇关于描述符的冗长博文。

对于那些来自搜索引擎的人，这里是我在谈论动态属性时寻找的两件事:

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'

如果你想放置动态创建的属性，__dict__是很好的。__getattr__只适合在需要该值时执行某些操作，例如查询数据库。set/get组合有助于简化对存储在类中的数据的访问(如上面的示例)。

如果您只想要一个动态属性，请查看property()内置函数。

似乎您可以更简单地使用namedtuple来解决这个问题，因为您提前知道整个字段列表。

from collections import namedtuple

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

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

foo2 = Foo()  # error

如果你绝对需要编写自己的setter，你将不得不在类级别上进行元编程;Property()在实例上不起作用。

不能在运行时向实例添加新的属性()，因为属性是数据描述符。相反，你必须动态地创建一个新类，或者重载__getattribute__以处理实例上的数据描述符。

你不需要使用属性。只需重写__setattr__，使其为只读。

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!")

Tada。

>>> 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!

我在Stack Overflow的这篇文章中问了一个类似的问题，以创建一个创建简单类型的类工厂。结果就是这个答案，它有一个类工厂的工作版本。 以下是答案的一小段:

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 += 10
>>> person2.age -= 10
>>> person1.fname, person1.age, person2.fname, person2.age
('Kevin', 35, 'Terry', 32)
>>>

你可以使用这个的一些变化来创建默认值，这是你的目标(在这个问题中也有一个答案)。