Python: come ottenere il nome del metodo del chiamante nel metodo chiamato?

Question

Python: come ottenere il nome del metodo del chiamante nel metodo chiamato?

Si supponga che ho 2 metodi:

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

def method2(self): 
    ... 

Se io non voglio fare alcun cambiamento per method1, come ottenere il nome del chiamante (in questo esempio, il nome è Method1) in method2 ?

Answer 1

inspect.getframeinfo e altre funzioni correlate a inspect possono aiutare:

>>> 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 
>>> 

questa introspezione è destinato per aiutare il debug e lo sviluppo; non è consigliabile fare affidamento su di esso per scopi di funzionalità di produzione. Versione

Answer 2

Shorter:

import inspect 

def f1(): f2() 

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

f1() 

(con grazie a @alex, e Stefaan Lippen)

Answer 3

mi è venuta in mente una versione leggermente più lunga che cerca di costruire un nome di metodo completo, compreso il modulo e la classe .

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

# Public Domain, i.e. 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 != '<module>': # 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) 

Answer 4

Questo sembra funzionare bene:

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

Answer 5

Bit di un amalgama di roba sopra. Ma ecco il mio crack.

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 

Usa:

@print_caller_name(4) 
def foo(): 
    return 'foobar' 

def bar(): 
    return foo() 

def baz(): 
    return bar() 

def fizz(): 
    return baz() 

fizz() 

uscita è

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

Answer 6

ho trovato un modo, se si sta andando tra classi e voglio la classe il metodo appartiene e il metodo. Ci vuole un po 'di lavoro di estrazione, ma fa il suo punto. Funziona in 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()