Python: несоответствие в том, как вы определяете функцию __setattr__? - PullRequest
Новая
       24

Python: несоответствие в том, как вы определяете функцию __setattr__?

15 голосов
/ 10 июня 2011

Рассмотрим этот код: 

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.

Ответы [ 3 ]

7 голосов
/ 10 июня 2011

Я подозреваю, что это связано с оптимизацией поиска. Из исходного кода: 

 /* 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)

То, что я нашел, работает как положено.

3 голосов
/ 10 июня 2011

Это известная (и, возможно, не очень) документированная разница.PyPy не делает различий между функциями и встроенными функциями.В CPython функции связываются как несвязанные методы при хранении в классе (они имеют __get__), в то время как встроенные функции этого не делают (они разные).

Однако в PyPy встроенные функции точно такие же, как и pythonфункции, поэтому интерпретатор не может отличить их друг от друга и рассматривает их как функции уровня Python.Я думаю, что это было определено как детали реализации, хотя на python-dev было несколько обсуждений об устранении этой конкретной разницы.

Cheers,fijal

1 голос
/ 18 июня 2011

Обратите внимание на следующее: 

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

Механизм, лежащий в основе рассматриваемого поведения, (возможно, я не эксперт) находится за пределами «чистого» подмножества Python (как описано в подробных книгах, таких как «Изучение Python» или «Python in the nuthell», и в некоторой степени).свободно указывается на python.org) и относится к той части языка, которая задокументирована «как есть» реализацией (и подвержена (довольно) частым изменениям).

...