name of the class that contains the method code

In Python 3.x, you can simply use __class__.__name__. The __class__ name is mildly magic, and not the same thing as the __class__ attribute of self.

In Python 2.x, there is no good way to get at that information. You can use stack inspection to get the code object, then walk the class hierarchy looking for the right method, but it's slow and tedious and will probably break when you don't want it to. You can also use a metaclass or a class decorator to post-process the class in some way, but both of those are rather intrusive approaches. And you can do something really ugly, like accessing self.__nonexistant_attribute, catching the AttributeError and extracting the class name from the mangled name. None of those approaches are really worth it if you just want to avoid typing the name twice; at least forgetting to update the name can be made a little more obvious by doing something like:

class C:
 ...
 def report_name(self):
 print C.__name__

inspect.getmro gives you a tuple of the classes where the method might come from, in order. As soon as you find one of them that has the method's name in its dict, you're done:

for c in inspect.getmro(self.__class__):
 if 'test' in vars(c): break
return c.__name__

Use __dict__ of class object itself:

class A(object):
 def foo(self):
 pass
class B(A):
 pass
def find_decl_class(cls, method):
 if method in cls.__dict__:
 return cls
 for b in cls.__bases__:
 decl = find_decl_class(b, method)
 if decl:
 return decl
print 'foo' in A.__dict__
print 'foo' in B.__dict__
print find_decl_class(B, 'foo').__name__

Will print True, False, A

You can use (abuse?) private name mangling to accomplish this effect. If you look up an attribute on self that starts with __ from inside a method, python changes the name from __attribute to _classThisMethodWasDefinedIn__attribute.

Just somehow stash the classname you want in mangled-form where the method can see it. As an example, we can define a __new__ method on the base class that does it:

def mangle(cls, attrname):
 if not attrname.startswith('__'):
 raise ValueError('attrname must start with __')
 return '_%s%s' % (cls.__name__, attrname)
class A(object):
 def __new__(cls, *args, **kwargs):
 obj = object.__new__(cls)
 for c in cls.mro():
 setattr(obj, mangle(c, '__defn_classname'), c.__name__)
 return obj
 def __init__(self):
 pass
 def test(self):
 print self.__defn_classname
class B(A):
 def __init__(self):
 A.__init__(self)
a = A()
b = B()
a.test()
b.test()

which prints:

A
A

You can do

>>> class A(object):
... def __init__(self):
... pass
... def test(self):
... for b in self.__class__.__bases__:
... if hasattr(b, 'test'):
... return b.__name__
... return self.__class__.__name__
... 
>>> class B(A):
... def __init__(self):
... A.__init__(self)
...
>>> B().test()
'A'
>>> A().test()
'A'
>>> 

Keep in mind that you could simplify it by using __class__.__base__, but if you use multiple inheritance, this version will work better.

It simply checks first on its baseclasses for test. It's not the prettiest, but it works.

• python
• introspection