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.
Ответы
Ответ 1
Я подозреваю, что это связано с оптимизацией поиска. Из исходного кода:
/* 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)
Я нашел работу как ожидалось.
Ответ 2
Это известная (и, может быть, не очень хорошо) документальная разница. PyPy не проводит различия между функциями и встроенными функциями. В CPython функции становятся привязанными как несвязанные методы, когда они хранятся в классе (имеют __get__), тогда как встроенные функции не являются (они разные).
Однако в PyPy встроенные функции точно такие же, как функции python, поэтому интерпретатор не может отличить их друг от друга и рассматривает их как функции уровня на уровне python. Я думаю, что это было определено как детали реализации, хотя было некоторое обсуждение на python-dev об устранении этой конкретной разницы.
Cheers,
fijal
Ответ 3
Обратите внимание на следующее:
>>> dict.__getitem__ # it a 'method'
<method '__getitem__' of 'dict' objects>
>>> dict.__setitem__ # it 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)
Механизм, лежащий в основе рассматриваемого поведения (возможно, я не эксперт) за пределами "чистого" подмножества Python (как это описано в обширных книгах, таких как "Learning Python" или "Python в двух словах" и несколько слабо указано на python.org) и относится к той части языка, которая задокументирована как "как есть" (и подвержена (а) частым изменениям).