Comment obtenir le nom de la méthode de l'appelant dans la méthode appelée ?

Question

Python : Comment obtenir le nom de la méthode de l'appelant dans la méthode appelée ?

Supposons que j'ai 2 méthodes :

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

def method2(self):
    ...

Si je ne veux pas faire de changement pour la méthode1, comment obtenir le nom de l'appelant (dans cet exemple, le nom est méthode1) dans la méthode2 ?

Answer 1

inspect.getframeinfo et d'autres fonctions connexes dans inspect peut vous aider :

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

cette introspection est destinée à faciliter le débogage et le développement ; il n'est pas conseillé de s'en servir à des fins de fonctionnalité de production.

Answer 2

Version courte :

import inspect

def f1(): f2()

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

f1()

(avec des remerciements à @Alex, et Stefaan Lippen )

Answer 3

Cela semble fonctionner parfaitement :

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

Answer 4

J'utiliserais inspect.currentframe().f_back.f_code.co_name . Son utilisation n'a pas été abordée dans les réponses précédentes qui sont principalement de l'un des trois types suivants :

• Certaines réponses antérieures utilisent inspect.stack mais il est connu pour être trop lent .
• Certaines réponses antérieures utilisent sys._getframe qui est une fonction privée interne étant donné son trait de soulignement principal, et donc son utilisation est implicitement découragée.

• Une réponse antérieure utilise inspect.getouterframes(inspect.currentframe(), 2)[1][3] mais il n'est pas clair du tout ce que [1][3] est en train d'accéder.

  import inspect from types import FrameType from typing import cast

  def caller_name() -> str: """Return the calling function's name."""

  Ref: https://stackoverflow.com/a/57712700/

  return cast(FrameType, cast(FrameType, inspect.currentframe()).f_back).f_code.co_name

  if name == 'main': def _test_caller_name() -> None: assert caller_name() == '_test_caller_name' _test_caller_name()

Notez que cast(FrameType, frame) est utilisé pour satisfaire mypy .

---

Accusé de réception : commentaire de 1313e pour une responder .

Answer 5

J'ai trouvé une version un peu plus longue qui essaie de construire un nom de méthode complet incluant module et 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)