python: super () - подобный прокси-объект, который запускает поиск MRO в указанном классе

Отдельный вопрос, документация для super () (в Python 3.2) только говорит о своем методе делегирования, и не уточняет, что поиск атрибутов для прокси-сервера также выполняется таким же образом. Это случайное упущение?

Нет, это не случайно. super() ничего не делает для поиска атрибутов. Причина в том, что атрибуты экземпляра не связаны с определенным классом, они просто существуют. Рассмотрим следующее:

class A:
    def __init__(self):
        self.foo = 'foo set from A'

class B(A):
    def __init__(self):
        super().__init__()
        self.bar = 'bar set from B'

class C(B):
    def method(self):
        self.baz = 'baz set from C'

class D(C):
    def __init__(self):
        super().__init__()
        self.foo = 'foo set from D'
        self.baz = 'baz set from D'

instance = D()
instance.method()
instance.bar = 'not set from a class at all'

Какому классу "принадлежит" foo, bar, и baz?

Если я хочу просмотреть instance как экземпляр C, должен ли он иметь атрибут baz перед вызовом method? А что будет потом?

Если я рассматриваю instance как экземпляр A, какое значение должно иметь foo? Должен ли bar быть невидимым, потому что был добавлен только в B, или видимым, потому что он был установлен в значение вне класса?

Все эти вопросы являются нонсенсом в Python. Нет никакой возможности способ проектирования системы с семантикой Python, которая могла бы дать разумные ответы на них. __init__ даже не является специальным с точки зрения добавления атрибутов к экземплярам класса; это просто совершенно обычный метод, который случайно вызывается как часть протокола создания экземпляра. Любой метод (или даже код из другого класса вообще, или не из любого класса вообще) может создавать атрибуты в любом экземпляре, на который он ссылается.

На самом деле, все атрибуты instance хранятся там же:

>>> instance.__dict__
{'baz': 'baz set from C', 'foo': 'foo set from D', 'bar': 'not set from a class at all'}

Невозможно сказать, какие из них были первоначально установлены каким классом, или были последними установлены каким классом, или какой бы мерой собственности вы ни хотели обладать. Конечно, нет никакого способа добраться до" A.foo, затененного D.foo", как можно было бы ожидать от C++; они являются одним и тем же атрибутом, и любая запись в него одним классом (или из другого места) ударит по значению, оставленному в нем другим классом.

Следствием этого является то, что super() не выполняет поиск атрибутов точно так же, как и поиск методов; он не может, и ни один код, который вы пишете, не может.

---

На самом деле, от запуска некоторых экспериментов, ни super, ни Свен Delegate фактически не поддерживают прямой поиск атрибутов вообще!

class A:
    def __init__(self):
        self.spoon = 1
        self.fork = 2

    def foo(self):
        print('A.foo')

class B(A):
    def foo(self):
        print('B.foo')

b = B()

d = Delegate(A, b)
s = super(B, b)

Тогда оба работают, как и ожидалось для методов:

>>> d.foo()
A.foo
>>> s.foo()
A.foo

Но:

>>> d.fork
Traceback (most recent call last):
  File "<pyshell#43>", line 1, in <module>
    d.fork
  File "/tmp/foo.py", line 6, in __getattr__
    x = getattr(self._delegate_cls, name)
AttributeError: type object 'A' has no attribute 'fork'
>>> s.spoon
Traceback (most recent call last):
  File "<pyshell#45>", line 1, in <module>
    s.spoon
AttributeError: 'super' object has no attribute 'spoon'

Таким образом, они оба действительно работают только для вызова некоторых методов, а не для передачи произвольному стороннему коду, чтобы притвориться экземпляром класса вы хотите делегировать кому-то. К сожалению, они не ведут себя одинаково при наличии множественного наследования. Дано:

class Delegate:
    def __init__(self, cls, obj):
        self._delegate_cls = cls
        self._delegate_obj = obj
    def __getattr__(self, name):
        x = getattr(self._delegate_cls, name)
        if hasattr(x, "__get__"):
            return x.__get__(self._delegate_obj)
        return x


class A:
    def foo(self):
        print('A.foo')

class B:
    pass

class C(B, A):
    def foo(self):
        print('C.foo')

c = C()

d = Delegate(B, c)
s = super(C, c)

Затем:

>>> d.foo()
Traceback (most recent call last):
  File "<pyshell#50>", line 1, in <module>
    d.foo()
  File "/tmp/foo.py", line 6, in __getattr__
    x = getattr(self._delegate_cls, name)
AttributeError: type object 'B' has no attribute 'foo'
>>> s.foo()
A.foo

Потому что Delegate игнорирует полный MRO любого класса _delegate_obj, являющегося экземпляром, ТОЛЬКО используя MRO _delegate_cls. В то время как super делает то, что вы спросили в вопросе, но поведение кажется довольно странным: это не обертывание экземпляра C, чтобы притвориться, что это экземпляр B, потому что прямые экземпляры B не имеют foo определенный.

Вот моя попытка:

class MROSkipper:
    def __init__(self, cls, obj):
        self.__cls = cls
        self.__obj = obj

    def __getattr__(self, name):
        mro = self.__obj.__class__.__mro__
        i = mro.index(self.__cls)
        if i == 0:
            # It's at the front anyway, just behave as getattr
            return getattr(self.__obj, name)
        else:
            # Check __dict__ not getattr, otherwise we'd find methods
            # on classes we're trying to skip
            try:
                return self.__obj.__dict__[name]
            except KeyError:
                return getattr(super(mro[i - 1], self.__obj), name)

Я полагаюсь на атрибут __mro__ классов, чтобы правильно понять, с чего начать, а затем я просто использую super. Вы могли бы сами пройти цепочку MRO от этой точки, проверяя класс __dict__ s на наличие методов, если странность возврата на один шаг назад для использования super слишком велика.

Я не делал попыток обрабатывать необычные атрибуты; те, которые реализованы с помощью дескрипторов (включая свойства), или те магические методы, которые были найдены позади сцены на Python, которые часто начинаются с класса, а не непосредственно с экземпляра. Но это ведет себя так, как вы просили умеренно хорошо (с оговоркой, изложенной на ad nauseum в первой части моего поста; поиск атрибутов таким образом не даст вам никаких других результатов, чем поиск их непосредственно в данном случае).