目标是创建一个行为类似db结果集的模拟类。
例如，如果数据库查询使用dict表达式{'ab':100, 'cd':200}返回，那么我希望看到：
>>> dummy.ab
100
起初我想也许我可以这样做：
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
但是c.ab会返回一个属性对象。
用setattr替换k = property(lambda x: vs[i])行完全没用。
那么在运行时创建实例属性的正确方法是什么？
中提供的替代方案答案 0 :(得分：287)
我想我应该扩大这个答案，因为我已经老了，更聪明，知道发生了什么。迟到总比没有好。
您可以动态地向类中添加属性。但这就是问题所在：您必须将其添加到类。
>>> class Foo(object):
... pass
...
>>> foo = Foo()
>>> foo.a = 3
>>> Foo.b = property(lambda self: self.a + 1)
>>> foo.b
4
property实际上是一个名为descriptor的事物的简单实现。它是一个对象，它为给定属性在给定类上提供自定义处理。有点像从if中分析出巨大__getattribute__树的方法。
当我在上面的例子中询问foo.b时，Python看到类上定义的b实现了描述符协议 - 这意味着它是一个带有__get__，__set__或__delete__方法。描述符声称负责处理该属性，因此Python调用Foo.b.__get__(foo, Foo)，并将返回值作为属性的值传递给您。对于property，这些方法中的每一种都只调用您传递给fget构造函数的fset，fdel或property。
描述符实际上是Python公开其整个OO实现的管道的方式。实际上，还有另一种类型的描述符比property更常见。
>>> 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)
无论如何，我怀疑这就是为什么描述符只适用于类：它们是首先为类提供动力的东西的形式化。它们甚至是规则的例外：您显然可以将描述符分配给类，而类本身就是type的实例！实际上，尝试阅读Foo.b仍然会调用property.__get__;当作为类属性访问时，描述符返回自身只是惯用的。
我认为几乎所有Python的OO系统都可以用Python表达，这很酷。 ：）
哦，如果你有兴趣，我前一段时间写了wordy blog post about descriptors。
答案 1 :(得分：51)
目标是创建一个行为类似db结果集的模拟类。
那么你想要的是一个字典，你可以将['b']拼写为a.b？
这很简单：
class atdict(dict):
__getattr__= dict.__getitem__
__setattr__= dict.__setitem__
__delattr__= dict.__delitem__
答案 2 :(得分：33)
似乎你可以使用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()不适用于实例。
答案 3 :(得分：28)
您不需要使用属性。只需覆盖__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!")
多田。
>>> 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!
答案 4 :(得分：5)
您无法在运行时向实例添加新的property()，因为属性是数据描述符。相反，您必须动态创建一个新类，或重载__getattribute__以便处理实例上的数据描述符。
答案 5 :(得分：5)
如何动态地向python类添加属性？
假设您有一个要添加属性的对象。通常，我想在需要开始管理具有下游使用的代码中的属性的访问时使用属性，以便我可以维护一致的API。现在我通常会将它们添加到定义对象的源代码中，但我们假设您没有该访问权限，或者您需要以编程方式真正动态地选择函数。
使用基于documentation for property的示例，让我们创建一个具有“隐藏”属性的对象类并创建它的实例：
class C(object):
'''basic class'''
_x = None
o = C()
在Python中，我们期望有一种明显的做事方式。但是，在这种情况下，我将展示两种方式：使用装饰符号，而不使用。首先，没有装饰符号。这对于getter，setter或deleters的动态分配可能更有用。
让我们为班级创建一些：
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
答案 6 :(得分：5)
我问了一个类似的问题on this Stack Overflow post来创建一个创建简单类型的类工厂。结果是this answer，它有一个类工厂的工作版本。 以下是答案的片段：
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)
>>>
您可以使用其中的一些变体来创建默认值，这是您的目标（在该问题中也有答案可以解决此问题。）
答案 7 :(得分：3)
不确定我是否完全理解这个问题，但您可以使用类的内置__dict__在运行时修改实例属性：
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
答案 8 :(得分：3)
对于那些来自搜索引擎的人来说，以下是我在谈论动态属性时所寻找的两件事：
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()内置函数。
答案 9 :(得分：2)
实现的最佳方法是定义__slots__。这样，您的实例就无法拥有新属性。
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
打印12
c.ab = 33
这给出了：AttributeError: 'C' object has no attribute 'ab'
答案 10 :(得分：2)
以下是一种解决方案：
在定义了类之后，只需执行以下操作即可向其动态添加属性：
setattr(SomeClass, 'propertyName', property(getter, setter))
这是一个完整的示例，已在Python 3中进行了测试：
#!/usr/bin/env python3
class Foo():
pass
def get_x(self):
return 3
def set_x(self, value):
print("set x on %s to %d" % (self, value))
setattr(Foo, 'x', property(get_x, set_x))
foo1 = Foo()
foo1.x = 12
print(foo1.x)
答案 11 :(得分：2)
另一个如何达到预期效果的例子
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)
所以现在我们可以做类似的事情：
>>> foo = Foo('baz')
>>> foo.baz = 5
>>> foo.bar
5
>>> foo.baz
5
答案 12 :(得分：1)
您可以使用以下代码使用字典对象更新类属性：
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
答案 13 :(得分：0)
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
答案 14 :(得分：0)
这与OP想要的有所不同，但是我动了动脑筋，直到找到了可行的解决方案为止，所以我要在这里为下一个家伙/ gal
我需要一种方法来指定动态的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)
我提前知道我的字段，所以我要创建我的属性。注意：您不能执行此PER实例，这些属性将存在于类中！！！
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
这令人困惑吗？是的，很抱歉，我无法提供任何有意义的现实示例。另外，这也不是为了轻松。
答案 15 :(得分：0)
对我有用的是这样的：
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)
输出
a
aa
答案 16 :(得分：0)
尽管给出了许多答案，但我找不到我满意的答案。我想出了自己的解决方案，该解决方案使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
答案 17 :(得分：0)
# 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)
输出：
<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>
答案 18 :(得分：0)
这似乎有效（但见下文）：
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__)
如果您需要更复杂的行为，请随时编辑您的答案。
对于大型数据集，以下内容可能更具内存效率：
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__)
答案 19 :(得分：0)
要回答问题的主旨，您需要将dict中的只读属性作为不可变数据源：
目标是创建一个行为类似db结果集的模拟类。
例如，如果数据库查询使用dict表达式返回，
{'ab':100, 'cd':200}，然后我会看到>>> dummy.ab 100
我将演示如何使用namedtuple模块中的collections来实现此目的：
import collections
data = {'ab':100, 'cd':200}
def maketuple(d):
'''given a dict, return a namedtuple'''
Tup = collections.namedtuple('TupName', d.keys()) # iterkeys in Python2
return Tup(**d)
dummy = maketuple(data)
dummy.ab
返回100
答案 20 :(得分：-1)
我最近遇到了类似的问题，我提出的解决方案使用__getattr__和__setattr__作为我希望它处理的属性，其他所有内容都传递给原始文件。 / p>
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
答案 21 :(得分：-1)
动态附加属性的唯一方法是使用新属性创建新类及其实例。
class Holder: p = property(lambda x: vs[i], self.fn_readonly)
setattr(self, k, Holder().p)
答案 22 :(得分：-1)
这是通过编程创建属性对象的简单示例。
public StartWindow()
{
InitializeComponent();
Task.Run(() =>
{
// Some initialization code
Console.WriteLine(App.DEBUG);
Application.Current.Dispatcher.Invoke(() =>
{
MainWindow mainWindow = new MainWindow();
mainWindow.Show();
this.Close();
});
});
}
答案 23 :(得分：-3)
很多提供的答案每个属性需要这么多行，即/和/或-由于多个属性需要重复性，我认为这是丑陋或乏味的实现。我更喜欢保持简化/简化直到无法再对其进行简化，或者直到这样做没有太大目的为止。
简而言之：在完成的作品中，如果我重复两行代码，通常会将其转换为单行辅助函数，依此类推……简化了数学或奇数参数，例如（start_x，start_y，end_x， end_y）到（x，y，w，h）即x，y，x + w，y + h（有时需要min / max或w / h为负并且实现不喜欢它，我将减去来自x / y和abs w / h等。）
重写内部getters / setter方法是一个不错的方法，但是问题是您需要为每个类都这样做，或者将该类作为该基类的父类...这对我不起作用宁愿自由选择子女/父母进行继承，子女节点等。
我创建了一个解决方案，无需使用Dict数据类型来提供数据就可以回答问题，因为我发现输入数据等操作很繁琐，等等...
我的解决方案要求您在类上方添加2条额外的行，以为要向其添加属性的类创建基类，然后每条添加1行，并且您可以选择添加回调以控制数据，并通知您当数据更改时，限制可以基于值和/或数据类型等设置的数据。
您还可以选择使用_object.x，_object.x =值，_object.GetX（），_object.SetX（值），并且它们的处理方式相同。
此外，这些值是分配给类实例的唯一非静态数据，但是实际属性却分配给了类，这意味着您不需要重复的事情，不需要重复。 ..您可以分配一个默认值，以使getter每次都不需要它，尽管有一个选项可以覆盖默认默认值，还有另一个选项可以使getter通过覆盖默认返回值来返回原始存储值（注意：此方法表示仅在分配了值时才分配原始值，否则为None-当值重置时，它分配为None等。）
也有很多辅助函数-添加的第一个属性将向类中添加2个左右的辅助函数以引用实例值...它们是ResetAccessors（_key，..）varargs重复（可以使用首先命名为args）和SetAccessors（_key，_value），并在主类中添加更多选项以提高效率-计划的方法是：一种将访问器组合在一起的方式，因此如果您倾向于一次重置一些访问器，每次，您都可以将它们分配到一个组并重置该组，而不必每次都重复命名的密钥。
实例/原始存储的值存储在__class的 class。中。引用访问器类，该类保存该属性的静态vars / values / functions。 _类。是属性本身，它是在设置/获取等过程中通过实例类访问时调用的。
访问器_class .__指向该类，但是由于它是内部类，因此需要在该类中进行分配，这就是为什么我选择使用__Name = AccessorFunc（...）来对其进行分配，每个属性仅一行带有许多可选参数来使用（使用键控可变参数，因为它们更容易，更有效地标识和维护）...
我还创建了很多函数，如前所述，其中一些使用访问器函数信息，因此不需要调用它（因为目前有点不方便-现在您需要使用_class。 .FunctionName（_class_instance，args）-通过添加运行此位马拉松函数或将访问器添加到对象中，我可以使用堆栈/跟踪来获取实例引用以获取值并使用self（命名为，指出它们用于实例，并保留对self，AccessorFunc类引用以及函数定义中的其他信息的访问）。
这还没有完成，但这是一个了不起的立足点。注意：如果不使用__Name = AccessorFunc（...）创建属性，则即使我在init函数中定义了__键，也无法访问__键。如果这样做，那就没有问题。
也：请注意，名称和键是不同的...名称是“正式的”，在函数名称创建中使用，并且键用于数据存储和访问。即_class.x，其中小写的x是键，名称将是大写的X，因此GetX（）是函数，而不是看起来有些奇怪的Getx（）。这可以使self.x正常工作并看起来合适，但也可以使GetX（）看起来合适。
我有一个示例类，其键/名称相同，但显示不同。为了输出数据而创建了很多辅助函数（注意：并非所有这些都是完整的），因此您可以查看发生了什么。
使用键：x，名称：X的当前功能列表输出为：
这绝不是一个完整的列表-在发布时，有一些还没有做到这一点...
_instance.SetAccessors( _key, _value [ , _key, _value ] .. ) Instance Class Helper Function: Allows assigning many keys / values on a single line - useful for initial setup, or to minimize lines. In short: Calls this.Set<Name>( _value ) for each _key / _value pairing.
_instance.ResetAccessors( _key [ , _key ] .. ) Instance Class Helper Function: Allows resetting many key stored values to None on a single line. In short: Calls this.Reset<Name>() for each name provided.
Note: Functions below may list self.Get / Set / Name( _args ) - self is meant as the class instance reference in the cases below - coded as this in AccessorFuncBase Class.
this.GetX( _default_override = None, _ignore_defaults = False ) GET: Returns IF ISSET: STORED_VALUE .. IF IGNORE_DEFAULTS: None .. IF PROVIDED: DEFAULT_OVERRIDE ELSE: DEFAULT_VALUE 100
this.GetXRaw( ) RAW: Returns STORED_VALUE 100
this.IsXSet( ) ISSET: Returns ( STORED_VALUE != None ) True
this.GetXToString( ) GETSTR: Returns str( GET ) 100
this.GetXLen( _default_override = None, _ignore_defaults = False ) LEN: Returns len( GET ) 3
this.GetXLenToString( _default_override = None, _ignore_defaults = False ) LENSTR: Returns str( len( GET ) ) 3
this.GetXDefaultValue( ) DEFAULT: Returns DEFAULT_VALUE 1111
this.GetXAccessor( ) ACCESSOR: Returns ACCESSOR_REF ( self.__<key> ) [ AccessorFuncBase ] Key: x : Class ID: 2231452344344 : self ID: 2231448283848 Default: 1111 Allowed Types: {"<class 'int'>": "<class 'type'>", "<class 'float'>": "<class 'type'>"} Allowed Values: None
this.GetXAllowedTypes( ) ALLOWED_TYPES: Returns Allowed Data-Types {"<class 'int'>": "<class 'type'>", "<class 'float'>": "<class 'type'>"}
this.GetXAllowedValues( ) ALLOWED_VALUES: Returns Allowed Values None
this.GetXHelpers( ) HELPERS: Returns Helper Functions String List - ie what you're reading now... THESE ROWS OF TEXT
this.GetXKeyOutput( ) Returns information about this Name / Key ROWS OF TEXT
this.GetXGetterOutput( ) Returns information about this Name / Key ROWS OF TEXT
this.SetX( _value ) SET: STORED_VALUE Setter - ie Redirect to __<Key>.Set N / A
this.ResetX( ) RESET: Resets STORED_VALUE to None N / A
this.HasXGetterPrefix( ) Returns Whether or Not this key has a Getter Prefix... True
this.GetXGetterPrefix( ) Returns Getter Prefix... Get
this.GetXName( ) Returns Accessor Name - Typically Formal / Title-Case X
this.GetXKey( ) Returns Accessor Property Key - Typically Lower-Case x
this.GetXAccessorKey( ) Returns Accessor Key - This is to access internal functions, and static data... __x
this.GetXDataKey( ) Returns Accessor Data-Storage Key - This is the location where the class instance value is stored.. _x
一些正在输出的数据是：
这是一个使用Demo类创建的全新类，除了名称_foo（我使用的变量名）外，没有分配任何数据（因此可以输出）。
_foo --- MyClass: ---- id( this.__class__ ): 2231452349064 :::: id( this ): 2231448475016
Key Getter Value | Raw Key Raw / Stored Value | Get Default Value Default Value | Get Allowed Types Allowed Types | Get Allowed Values Allowed Values |
Name: _foo | _Name: _foo | __Name.DefaultValue( ): AccessorFuncDemoClass | __Name.GetAllowedTypes( ) <class 'str'> | __Name.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
x: 1111 | _x: None | __x.DefaultValue( ): 1111 | __x.GetAllowedTypes( ) (<class 'int'>, <class 'float'>) | __x.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
y: 2222 | _y: None | __y.DefaultValue( ): 2222 | __y.GetAllowedTypes( ) (<class 'int'>, <class 'float'>) | __y.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
z: 3333 | _z: None | __z.DefaultValue( ): 3333 | __z.GetAllowedTypes( ) (<class 'int'>, <class 'float'>) | __z.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
Blah: <class 'int'> | _Blah: None | __Blah.DefaultValue( ): <class 'int'> | __Blah.GetAllowedTypes( ) <class 'str'> | __Blah.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
Width: 1 | _Width: None | __Width.DefaultValue( ): 1 | __Width.GetAllowedTypes( ) (<class 'int'>, <class 'bool'>) | __Width.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
Height: 0 | _Height: None | __Height.DefaultValue( ): 0 | __Height.GetAllowedTypes( ) <class 'int'> | __Height.GetAllowedValues( ) (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) |
Depth: 2 | _Depth: None | __Depth.DefaultValue( ): 2 | __Depth.GetAllowedTypes( ) Saved Value Restricted to Authorized Values ONLY | __Depth.GetAllowedValues( ) (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) |
this.IsNameSet( ): True this.GetName( ): _foo this.GetNameRaw( ): _foo this.GetNameDefaultValue( ): AccessorFuncDemoClass this.GetNameLen( ): 4 this.HasNameGetterPrefix( ): <class 'str'> this.GetNameGetterPrefix( ): None
this.IsXSet( ): False this.GetX( ): 1111 this.GetXRaw( ): None this.GetXDefaultValue( ): 1111 this.GetXLen( ): 4 this.HasXGetterPrefix( ): (<class 'int'>, <class 'float'>) this.GetXGetterPrefix( ): None
this.IsYSet( ): False this.GetY( ): 2222 this.GetYRaw( ): None this.GetYDefaultValue( ): 2222 this.GetYLen( ): 4 this.HasYGetterPrefix( ): (<class 'int'>, <class 'float'>) this.GetYGetterPrefix( ): None
this.IsZSet( ): False this.GetZ( ): 3333 this.GetZRaw( ): None this.GetZDefaultValue( ): 3333 this.GetZLen( ): 4 this.HasZGetterPrefix( ): (<class 'int'>, <class 'float'>) this.GetZGetterPrefix( ): None
this.IsBlahSet( ): False this.GetBlah( ): <class 'int'> this.GetBlahRaw( ): None this.GetBlahDefaultValue( ): <class 'int'> this.GetBlahLen( ): 13 this.HasBlahGetterPrefix( ): <class 'str'> this.GetBlahGetterPrefix( ): None
this.IsWidthSet( ): False this.GetWidth( ): 1 this.GetWidthRaw( ): None this.GetWidthDefaultValue( ): 1 this.GetWidthLen( ): 1 this.HasWidthGetterPrefix( ): (<class 'int'>, <class 'bool'>) this.GetWidthGetterPrefix( ): None
this.IsDepthSet( ): False this.GetDepth( ): 2 this.GetDepthRaw( ): None this.GetDepthDefaultValue( ): 2 this.GetDepthLen( ): 1 this.HasDepthGetterPrefix( ): None this.GetDepthGetterPrefix( ): (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
this.IsHeightSet( ): False this.GetHeight( ): 0 this.GetHeightRaw( ): None this.GetHeightDefaultValue( ): 0 this.GetHeightLen( ): 1 this.HasHeightGetterPrefix( ): <class 'int'> this.GetHeightGetterPrefix( ): (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
这是在以相同顺序为所有_foo属性（名称除外）分配了以下值之后：'string'，1.0，True，9，10，False
this.IsNameSet( ): True this.GetName( ): _foo this.GetNameRaw( ): _foo this.GetNameDefaultValue( ): AccessorFuncDemoClass this.GetNameLen( ): 4 this.HasNameGetterPrefix( ): <class 'str'> this.GetNameGetterPrefix( ): None
this.IsXSet( ): True this.GetX( ): 10 this.GetXRaw( ): 10 this.GetXDefaultValue( ): 1111 this.GetXLen( ): 2 this.HasXGetterPrefix( ): (<class 'int'>, <class 'float'>) this.GetXGetterPrefix( ): None
this.IsYSet( ): True this.GetY( ): 10 this.GetYRaw( ): 10 this.GetYDefaultValue( ): 2222 this.GetYLen( ): 2 this.HasYGetterPrefix( ): (<class 'int'>, <class 'float'>) this.GetYGetterPrefix( ): None
this.IsZSet( ): True this.GetZ( ): 10 this.GetZRaw( ): 10 this.GetZDefaultValue( ): 3333 this.GetZLen( ): 2 this.HasZGetterPrefix( ): (<class 'int'>, <class 'float'>) this.GetZGetterPrefix( ): None
this.IsBlahSet( ): True this.GetBlah( ): string Blah this.GetBlahRaw( ): string Blah this.GetBlahDefaultValue( ): <class 'int'> this.GetBlahLen( ): 11 this.HasBlahGetterPrefix( ): <class 'str'> this.GetBlahGetterPrefix( ): None
this.IsWidthSet( ): True this.GetWidth( ): False this.GetWidthRaw( ): False this.GetWidthDefaultValue( ): 1 this.GetWidthLen( ): 5 this.HasWidthGetterPrefix( ): (<class 'int'>, <class 'bool'>) this.GetWidthGetterPrefix( ): None
this.IsDepthSet( ): True this.GetDepth( ): 9 this.GetDepthRaw( ): 9 this.GetDepthDefaultValue( ): 2 this.GetDepthLen( ): 1 this.HasDepthGetterPrefix( ): None this.GetDepthGetterPrefix( ): (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
this.IsHeightSet( ): True this.GetHeight( ): 9 this.GetHeightRaw( ): 9 this.GetHeightDefaultValue( ): 0 this.GetHeightLen( ): 1 this.HasHeightGetterPrefix( ): <class 'int'> this.GetHeightGetterPrefix( ): (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
_foo --- MyClass: ---- id( this.__class__ ): 2231452349064 :::: id( this ): 2231448475016
Key Getter Value | Raw Key Raw / Stored Value | Get Default Value Default Value | Get Allowed Types Allowed Types | Get Allowed Values Allowed Values |
Name: _foo | _Name: _foo | __Name.DefaultValue( ): AccessorFuncDemoClass | __Name.GetAllowedTypes( ) <class 'str'> | __Name.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
x: 10 | _x: 10 | __x.DefaultValue( ): 1111 | __x.GetAllowedTypes( ) (<class 'int'>, <class 'float'>) | __x.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
y: 10 | _y: 10 | __y.DefaultValue( ): 2222 | __y.GetAllowedTypes( ) (<class 'int'>, <class 'float'>) | __y.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
z: 10 | _z: 10 | __z.DefaultValue( ): 3333 | __z.GetAllowedTypes( ) (<class 'int'>, <class 'float'>) | __z.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
Blah: string Blah | _Blah: string Blah | __Blah.DefaultValue( ): <class 'int'> | __Blah.GetAllowedTypes( ) <class 'str'> | __Blah.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
Width: False | _Width: False | __Width.DefaultValue( ): 1 | __Width.GetAllowedTypes( ) (<class 'int'>, <class 'bool'>) | __Width.GetAllowedValues( ) Saved Value Restrictions Levied by Data-Type |
Height: 9 | _Height: 9 | __Height.DefaultValue( ): 0 | __Height.GetAllowedTypes( ) <class 'int'> | __Height.GetAllowedValues( ) (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) |
Depth: 9 | _Depth: 9 | __Depth.DefaultValue( ): 2 | __Depth.GetAllowedTypes( ) Saved Value Restricted to Authorized Values ONLY | __Depth.GetAllowedValues( ) (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) |
请注意，由于数据类型或值的限制，未分配某些数据-这是设计使然。设置器禁止分配错误的数据类型或值，甚至禁止将其分配为默认值（除非您覆盖默认值保护行为）
代码未发布在这里，因为在示例和说明之后我没有足够的空间...也是因为它将更改。
请注意：在此发布时，文件杂乱无章-这将改变。但是，如果您在Sublime Text中运行它并对其进行编译，或者从Python中运行它，它将编译并吐出大量信息-AccessorDB部分未完成（将用于更新Print Getters和GetKeyOutput帮助器）函数以及被更改为Instance函数，可能放在一个函数中并重命名-查找它。.）
下一步：运行它并不需要所有内容-底部的很多注释内容是用于调试的更多信息-下载时可能不存在。如果是这样，您应该可以取消注释并重新编译以获取更多信息。
我正在寻找一种解决方法，需要MyClassBase：通过，MyClass（MyClassBase）：...-如果您知道解决方案，请发布它。
该类中唯一需要的是__行- str 和 init 一样都是用于调试的-可以将它们从演示类中删除，但是您将需要注释掉或删除下面的一些行（_foo / 2/3）..
顶部的String，Dict和Util类是我的Python库的一部分-它们不完整。我从库中复制了一些我需要的东西，然后创建了一些新东西。完整的代码将链接到完整的库，并将包括完整的库以及提供更新的调用和删除代码（实际上，剩下的唯一代码将是演示类和打印语句-AccessorFunc系统将移至库中）。 ..
文件的一部分：
##
## MyClass Test AccessorFunc Implementation for Dynamic 1-line Parameters
##
class AccessorFuncDemoClassBase( ):
pass
class AccessorFuncDemoClass( AccessorFuncDemoClassBase ):
__Name = AccessorFuncBase( parent = AccessorFuncDemoClassBase, name = 'Name', default = 'AccessorFuncDemoClass', allowed_types = ( TYPE_STRING ), allowed_values = VALUE_ANY, documentation = 'Name Docs', getter_prefix = 'Get', key = 'Name', allow_erroneous_default = False, options = { } )
__x = AccessorFuncBase( parent = AccessorFuncDemoClassBase, name = 'X', default = 1111, allowed_types = ( TYPE_INTEGER, TYPE_FLOAT ), allowed_values = VALUE_ANY, documentation = 'X Docs', getter_prefix = 'Get', key = 'x', allow_erroneous_default = False, options = { } )
__Height = AccessorFuncBase( parent = AccessorFuncDemoClassBase, name = 'Height', default = 0, allowed_types = TYPE_INTEGER, allowed_values = VALUE_SINGLE_DIGITS, documentation = 'Height Docs', getter_prefix = 'Get', key = 'Height', allow_erroneous_default = False, options = { } )
这种美感使得通过AccessorFuncs /回调/数据类型/值强制执行等动态添加属性来创建新类变得异常容易。
现在，链接位于（此链接应反映对文档所做的更改。）：https://www.dropbox.com/s/6gzi44i7dh58v61/dynamic_properties_accessorfuncs_and_more.py?dl=0
也：如果您不使用Sublime Text，我建议在Notepad ++，Atom，Visual Code等上使用它，因为适当的线程实现使它使用起来快得多，快得多...我也在使用IDE类似的代码映射系统-看一下：https://bitbucket.org/Acecool/acecoolcodemappingsystem/src/master/（首先在程序包管理器中添加存储库，然后再安装插件-版本1.0.0准备就绪时，我将其添加到主插件列表中。 ）
我希望该解决方案能够帮助...并且像往常一样：
仅仅因为它有效，就不能使它正确-Josh'Acecool'Moser