Python:定义函数__setAttr__的方式不一致?
题
考虑此代码:
class Foo1(dict):
def __getattr__(self, key): return self[key]
def __setattr__(self, key, value): self[key] = value
class Foo2(dict):
__getattr__ = dict.__getitem__
__setattr__ = dict.__setitem__
o1 = Foo1()
o1.x = 42
print(o1, o1.x)
o2 = Foo2()
o2.x = 42
print(o2, o2.x)
我期望相同的输出。但是,有了Cpython 2.5,2.6(同样在3.2中),我得到了:
({'x': 42}, 42)
({}, 42)
使用PYPY 1.5.0,我得到了预期的输出:
({'x': 42}, 42)
({'x': 42}, 42)
哪个“正确”输出? (或根据Python文档的输出是什么?)
这里 是Cpython的错误报告。
解决方案
我怀疑这与查找优化有关。从源代码:
/* speed hack: we could use lookup_maybe, but that would resolve the
method fully for each attribute lookup for classes with
__getattr__, even when the attribute is present. So we use
_PyType_Lookup and create the method only when needed, with
call_attribute. */
getattr = _PyType_Lookup(tp, getattr_str);
if (getattr == NULL) {
/* No __getattr__ hook: use a simpler dispatcher */
tp->tp_getattro = slot_tp_getattro;
return slot_tp_getattro(self, name);
}
快速路径不会在类词典上查找它。
因此,获得所需功能的最佳方法是将覆盖方法放在同类中。
class AttrDict(dict):
"""A dictionary with attribute-style access. It maps attribute access to
the real dictionary. """
def __init__(self, *args, **kwargs):
dict.__init__(self, *args, **kwargs)
def __repr__(self):
return "%s(%s)" % (self.__class__.__name__, dict.__repr__(self))
def __setitem__(self, key, value):
return super(AttrDict, self).__setitem__(key, value)
def __getitem__(self, name):
return super(AttrDict, self).__getitem__(name)
def __delitem__(self, name):
return super(AttrDict, self).__delitem__(name)
__getattr__ = __getitem__
__setattr__ = __setitem__
def copy(self):
return AttrDict(self)
我发现这是按预期的工作。
其他提示
这是已知的(也许不是很好)的差异。 PYPY没有区分函数和内置功能。在CPYTHON函数中,当存储在类上时(__Get__)时,函数将被束缚为未结合的方法,而内置函数则没有(它们不同)。
但是,在PYPY下,内置函数与Python函数完全相同,因此解释器无法分辨它们并将其视为Python级函数。我认为这被定义为实施细节,尽管关于python-dev的讨论有一些关于消除这种特殊差异的讨论。
干杯,
斐济
注意以下内容:
>>> dict.__getitem__ # it's a 'method'
<method '__getitem__' of 'dict' objects>
>>> dict.__setitem__ # it's a 'slot wrapper'
<slot wrapper '__setitem__' of 'dict' objects>
>>> id(dict.__dict__['__getitem__']) == id(dict.__getitem__) # no bounding here
True
>>> id(dict.__dict__['__setitem__']) == id(dict.__setitem__) # or here either
True
>>> d = {}
>>> dict.__setitem__(d, 1, 2) # can be called directly (since not bound)
>>> dict.__getitem__(d, 1) # same with this
2
现在我们可以将它们包裹起来(并且 __getattr__
即使没有此功能也会工作):
class Foo1(dict):
def __getattr__(self, key): return self[key]
def __setattr__(self, key, value): self[key] = value
class Foo2(dict):
"""
It seems, 'slot wrappers' are not bound when present in the __dict__
of a class and retrieved from it via instance (or class either).
But 'methods' are, hence simple assignment works with __setitem__
in your original example.
"""
__setattr__ = lambda *args: dict.__setitem__(*args)
__getattr__ = lambda *args: dict.__getitem__(*args) # for uniformity, or
#__getattr__ = dict.__getitem__ # this way, i.e. directly
o1 = Foo1()
o1.x = 42
print(o1, o1.x)
o2 = Foo2()
o2.x = 42
print(o2, o2.x)
这使:
>>>
({'x': 42}, 42)
({'x': 42}, 42)
The mechanism behind the behavior in question is (probably, I'm no expert) outside the 'clean' subset of Python (as documented in thorough books like 'Learning Python' or 'Python in a nutshell' and somewhat loosely specified at python. org)和与实现的“按原样”记录的语言部分有关(并且受(而不是(而不是)频繁更改)。
不隶属于 StackOverflow