Ottieni classe quel metodo definito

Come posso ottenere la classe che ha definito un metodo in Python?

Vorrei che il seguente esempio stampasse " __main__.FooClass":

class FooClass:
    def foo_method(self):
        print "foo"

class BarClass(FooClass):
    pass

bar = BarClass()
print get_class_that_defined_method(bar.foo_method)

import inspect

def get_class_that_defined_method(meth):
    for cls in inspect.getmro(meth.im_class):
        if meth.__name__ in cls.__dict__: 
            return cls
    return None

Grazie Sr2222 per aver sottolineato che mi mancava il punto ...

Ecco l'approccio corretto che è proprio come quello di Alex ma non richiede di importare nulla. Non penso che sia un miglioramento, a meno che non ci sia un'enorme gerarchia di classi ereditate poiché questo approccio si interrompe non appena viene trovata la classe di definizione, invece di restituire l'intera eredità come getmrofa. Come detto, questo è uno scenario molto improbabile.

def get_class_that_defined_method(method):
    method_name = method.__name__
    if method.__self__:    
        classes = [method.__self__.__class__]
    else:
        #unbound method
        classes = [method.im_class]
    while classes:
        c = classes.pop()
        if method_name in c.__dict__:
            return c
        else:
            classes = list(c.__bases__) + classes
    return None

E l'esempio:

>>> class A(object):
...     def test(self): pass
>>> class B(A): pass
>>> class C(B): pass
>>> class D(A):
...     def test(self): print 1
>>> class E(D,C): pass

>>> get_class_that_defined_method(A().test)
<class '__main__.A'>
>>> get_class_that_defined_method(A.test)
<class '__main__.A'>
>>> get_class_that_defined_method(B.test)
<class '__main__.A'>
>>> get_class_that_defined_method(C.test)
<class '__main__.A'>
>>> get_class_that_defined_method(D.test)
<class '__main__.D'>
>>> get_class_that_defined_method(E().test)
<class '__main__.D'>
>>> get_class_that_defined_method(E.test)
<class '__main__.D'>
>>> E().test()
1

La soluzione Alex restituisce gli stessi risultati. Finché l'approccio di Alex può essere utilizzato, lo userei al posto di questo.

Non so perché nessuno lo abbia mai sollevato o perché la risposta principale ha 50 voti positivi quando è lento come l'inferno, ma puoi anche fare quanto segue:

def get_class_that_defined_method(meth):
    return meth.im_class.__name__

Per Python 3 credo che questo sia cambiato e dovrai esaminare .__qualname__.

In Python 3, se hai bisogno dell'effettivo oggetto di classe puoi fare:

import sys
f = Foo.my_function
vars(sys.modules[f.__module__])[f.__qualname__.split('.')[0]]  # Gets Foo object

Se la funzione potesse appartenere a una classe annidata, sarebbe necessario iterare come segue:

f = Foo.Bar.my_function
vals = vars(sys.modules[f.__module__])
for attr in f.__qualname__.split('.')[:-1]:
    vals = vals[attr]
# vals is now the class Foo.Bar

Python 3

Risolto in un modo molto semplice:

str(bar.foo_method).split(" ", 3)[-2]

Questo da

'FooClass.foo_method'

Dividi in punto per ottenere separatamente la classe e il nome della funzione

Ho iniziato a fare qualcosa di simile, fondamentalmente l'idea era controllare ogni volta che un metodo in una classe base era stato implementato o meno in una sottoclasse. Nel modo in cui l'ho fatto originariamente, non sono riuscito a rilevare quando una classe intermedia stava effettivamente implementando il metodo.

La mia soluzione alternativa era abbastanza semplice in realtà; impostare un attributo di metodo e verificarne la presenza in seguito. Ecco una semplificazione dell'intera faccenda:

class A():
    def method(self):
        pass
    method._orig = None # This attribute will be gone once the method is implemented

    def run_method(self, *args, **kwargs):
        if hasattr(self.method, '_orig'):
            raise Exception('method not implemented')
        self.method(*args, **kwargs)

class B(A):
    pass

class C(B):
    def method(self):
        pass

class D(C):
    pass

B().run_method() # ==> Raises Exception: method not implemented
C().run_method() # OK
D().run_method() # OK

AGGIORNAMENTO: Effettivamente chiama method()darun_method() (non è quello lo spirito?) E fa passare tutti gli argomenti non modificati al metodo.

PS: questa risposta non risponde direttamente alla domanda. IMHO ci sono due ragioni per cui si vorrebbe sapere quale classe ha definito un metodo; il primo è puntare il dito su una classe nel codice di debug (come nella gestione delle eccezioni), e il secondo è determinare se il metodo è stato reimplementato (dove il metodo è uno stub pensato per essere implementato dal programmatore). Questa risposta risolve il secondo caso in modo diverso.