¿Cómo obtener el nombre del método de la persona que llama en el método llamado?

Python: ¿Cómo obtener el nombre del método de la persona que llama en el método llamado?

Supongamos que tengo 2 métodos:

def method1(self): ... a = A.method2() def method2(self): ... 

Si no quiero hacer ningún cambio para method1, ¿cómo obtener el nombre de la persona que llama (en este ejemplo, el nombre es method1) en method2?

inspect.getframeinfo y otras funciones relacionadas en inspect pueden ayudar a:

 >>> import inspect >>> def f1(): f2() ... >>> def f2(): ... curframe = inspect.currentframe() ... calframe = inspect.getouterframes(curframe, 2) ... print('caller name:', calframe[1][3]) ... >>> f1() caller name: f1 

esta introspección está destinada a ayudar a la depuración y el desarrollo; no es recomendable confiar en él para fines de funcionalidad de producción.

Versión más corta:

 import inspect def f1(): f2() def f2(): print 'caller name:', inspect.stack()[1][3] f1() 

(con agradecimiento a @Alex, y Stefaan Lippen )

Esto parece funcionar bien

 import sys print sys._getframe().f_back.f_code.co_name 

Se me ha ocurrido una versión ligeramente más larga que intenta crear un nombre de método completo que incluya módulo y clase.

https://gist.github.com/2151727 (rev 9cccbf)

 # Public Domain, ie feel free to copy/paste # Considered a hack in Python 2 import inspect def caller_name(skip=2): """Get a name of a caller in the format module.class.method `skip` specifies how many levels of stack to skip while getting caller name. skip=1 means "who calls me", skip=2 "who calls my caller" etc. An empty string is returned if skipped levels exceed stack height """ stack = inspect.stack() start = 0 + skip if len(stack) < start + 1: return '' parentframe = stack[start][0] name = [] module = inspect.getmodule(parentframe) # `modname` can be None when frame is executed directly in console # TODO(techtonik): consider using __main__ if module: name.append(module.__name__) # detect classname if 'self' in parentframe.f_locals: # I don't know any way to detect call from the object method # XXX: there seems to be no way to detect static method call - it will # be just a function call name.append(parentframe.f_locals['self'].__class__.__name__) codename = parentframe.f_code.co_name if codename != '': # top level usually name.append( codename ) # function or a method ## Avoid circular refs and frame leaks # https://docs.python.org/2.7/library/inspect.html#the-interpreter-stack del parentframe, stack return ".".join(name) 

Un poco de una amalgama de lo anterior. Pero aquí está mi grieta en eso.

 def print_caller_name(stack_size=3): def wrapper(fn): def inner(*args, **kwargs): import inspect stack = inspect.stack() modules = [(index, inspect.getmodule(stack[index][0])) for index in reversed(range(1, stack_size))] module_name_lengths = [len(module.__name__) for _, module in modules] s = '{index:>5} : {module:^%i} : {name}' % (max(module_name_lengths) + 4) callers = ['', s.format(index='level', module='module', name='name'), '-' * 50] for index, module in modules: callers.append(s.format(index=index, module=module.__name__, name=stack[index][3])) callers.append(s.format(index=0, module=fn.__module__, name=fn.__name__)) callers.append('') print('\n'.join(callers)) fn(*args, **kwargs) return inner return wrapper 

Utilizar:

 @print_caller_name(4) def foo(): return 'foobar' def bar(): return foo() def baz(): return bar() def fizz(): return baz() fizz() 

la salida es

 level : module : name -------------------------------------------------- 3 : None : fizz 2 : None : baz 1 : None : bar 0 : __main__ : foo 

Encontré una manera si vas a través de clases y quieres la clase a la que pertenece el método Y el método. Toma un poco de trabajo de extracción, pero hace su punto. Esto funciona en Python 2.7.13.

 import inspect, os class ClassOne: def method1(self): classtwoObj.method2() class ClassTwo: def method2(self): curframe = inspect.currentframe() calframe = inspect.getouterframes(curframe, 4) print '\nI was called from', calframe[1][3], \ 'in', calframe[1][4][0][6: -2] # create objects to access class methods classoneObj = ClassOne() classtwoObj = ClassTwo() # start the program os.system('cls') classoneObj.method1() 
 #!/usr/bin/env python import inspect called=lambda: inspect.stack()[1][3] def caller1(): print "inside: ",called() def caller2(): print "inside: ",called() if __name__=='__main__': caller1() caller2() shahid@shahid-VirtualBox:~/Documents$ python test_func.py inside: caller1 inside: caller2 shahid@shahid-VirtualBox:~/Documents$