这和OP想要的有点不同，但我绞尽脑汁，直到我得到了一个可行的解决方案，所以我把它放在这里给下一个男人/女孩

我需要一种方法来指定动态setter和getter。

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)

我知道我的字段提前，所以我要创建我的属性。注意:你不能在每个实例中这样做，这些属性将存在于类中!!

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

现在让我们来测试一下。

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

会让人困惑吗?是的，很抱歉我无法举出任何有意义的现实例子。另外，这也不适合轻松的人。

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

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

>>> 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来表达，这非常酷。：）

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

如何动态地将属性添加到python类?

假设您有一个希望向其添加属性的对象。通常，当我需要开始管理对具有下游用途的代码中的属性的访问时，我希望使用属性，以便能够维护一致的API。现在，我通常会将它们添加到定义对象的源代码中，但让我们假设您没有这种访问权限，或者您需要真正地以编程方式动态地选择函数。

创建类

使用一个基于属性文档的例子，让我们创建一个具有“hidden”属性的对象类，并创建它的一个实例:

class C(object):
    '''basic class'''
    _x = None

o = C()

在Python中，我们期望有一种明显的做事方式。但是，在本例中，我将展示两种方法:使用装饰符符号和不使用装饰符符号。首先，没有装饰符号。对于getter、setter或delete的动态赋值，这可能更有用。

动态(又名猴子修补)

让我们为我们的类创建一些:

def getx(self):
    return self._x

def setx(self, value):
    self._x = value

def delx(self):
    del self._x

现在我们把这些赋值给性质。注意，我们可以在这里以编程方式选择函数，回答动态问题:

C.x = property(getx, setx, delx, "I'm the 'x' property.")

和用法:

>>> o.x = 'foo'
>>> o.x
'foo'
>>> del o.x
>>> print(o.x)
None
>>> help(C.x)
Help on property:

    I'm the 'x' property.

修饰符

我们可以用上面的装饰符符号做同样的事情，但在这种情况下，我们必须将所有方法命名为相同的名称(我建议与属性保持相同)，因此编程赋值并不像使用上述方法那样简单:

@property
def x(self):
    '''I'm the 'x' property.'''
    return self._x

@x.setter
def x(self, value):
    self._x = value

@x.deleter
def x(self):
    del self._x

并将属性对象及其配置的setter和deleters赋值给类:

C.x = x

和用法:

>>> help(C.x)
Help on property:

    I'm the 'x' property.

>>> o.x
>>> o.x = 'foo'
>>> o.x
'foo'
>>> del o.x
>>> print(o.x)
None

似乎您可以更简单地使用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()在实例上不起作用。

虽然给出了很多答案，但我没有找到一个让我满意的。我找到了自己的解决方案，使属性适用于动态情况。来源回答原来的问题:

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

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)

输出为:

>> 1