[python] Прокси класс.

class A(object):
a=1
def foo(self):
print self.b

class B(A):
b=2
def foo(self):
A.foo(self)

A ты можешь указать не явно а точно так же получить из self.__class__.__mro__, self.__class__.__bases__ и т.п.

То есть фокус здесь в том, чтобы явно отправлять методу свой self в качестве первого параметра?

Опишите задачу подробно, вы хотите сделать что-то странное, наверняка есть прямой способ.

да, как-то непонятно что хочется получить

Я строю аппликуху на активном использовании системы ивентов, взятых отсюда: http://www.valuedlessons.com/2008/04/events-in-python.html

В проге будут использоваться классы довольно большого уровня наследования, но при этом при создании экземпляра класса верхнего уровня, к нему должны подцепиться все обработчики, объявленные во всех родительских классах.

Просто добавлять метод класса к списку обработчиков недостаточно, поскольку для корректной работы метод должен быть явно связан с экземпляром чтобы не пришлось явно передавать self в метод. Потому то мне и нужен способ явно связать метод произвольного класса с экземпляром и в список обработчиков добавлять уже связанный метод.

Хм, кажется нашел.

http://stackoverflow.com/questions/1015307/python-bind-an-unbound-method

import types

def f(self): print self

class C(object): pass

meth = types.MethodType(f, C(), C) # Bind f to an instance of C print meth # prints <bound method C.f of <__main__.C object at 0x01255E90>>

По идее именно то, что мне нужно. Приду домой - проверю.

Я не понимаю зачем вам нужно усложнять и привлекать магию.

Чем это не устраивает?

event = Event()

class A(object):
    def __init__(self):
        event.handle(self.handler_a)

    def handler_a(self):
        print 'a'

class B(A):
    def __init__(self):
        super(B, self).__init__()
        event.handle(self.handler_b)

    def handler_b(self):
        print 'b'

b = B()
event.fire()

$ python events.py
a
b

>Я не понимаю зачем вам нужно усложнять и привлекать магию.

Усложню тут - облегчю себе работу в будущем. Ивентов будет очень много. И я считаю, что лучше просто объявить в классе метод обработчика с именем, оформленным в определенной нотации, и пусть его конструктор цепляет автоматом.

> метод должен быть явно связан с экземпляром чтобы не пришлось явно передавать self в метод.

ну так свяжи, например self.foo=lambda: somefunc(self)
или
from functools import partial
self.foo=partial(somefunc,self)

я считаю, что лучше просто объявить в классе метод обработчика с именем, оформленным в определенной нотации, и пусть его конструктор цепляет автоматом.

Я все равно не понимаю зачем вы ищете себе сложности с прокси-классом. Чем это не устраивает?

import inspect

event = Event()

class A(object):
    def __init__(self):
        for name, value in inspect.getmembers(self):
            if name.startswith('handler_'):
                event.handle(value)

    def handler_a(self):
        print 'a'

class B(A):
    def handler_b(self):
        print 'b'

b = B()
event.fire()

>Чем это не устраивает?

Постоянными замороками с вопросом "А какой у меня там в данный момент уровень вложенности, чтобы знать, каким именем мне называть нужный мне обработчик на данном уровне".

На всех уровнях у метода обработчика одно и то же имя. Фактически все что мне требуется для объявления события на этапе собственно разработки приложения, это сперва в конструкторе объявить переменную self.OnLoadEvent = Event() и в теле класса просто объявить метод def OnLoad(self): и все, все корректно подцепиться само собой и мне будет совершенно неважно, что где-то там парой уровней выше уже был объявлен обработчик OnLoad(self), прозрачным для меня образом подцепятся они оба и оба будут вызываться по очереди.

И, да. Фокус с types.MethodType() оказался более чем успешным, вчера дома потестил, все работает ровно так, как мне надо. Всем спасибо, вопрос решен. =)