Bagaimana cara mendapatkan nama metode pemanggil dalam metode yang dipanggil?

Python: Bagaimana cara mendapatkan nama metode pemanggil dalam metode yang dipanggil?

Asumsikan saya memiliki 2 metode:

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

def method2(self):
    ...

Jika saya tidak ingin melakukan perubahan apa pun untuk method1, bagaimana cara mendapatkan nama pemanggil (dalam contoh ini, namanya adalah method1) di method2?

inspect.getframeinfo dan fungsi terkait lainnya di inspectdapat membantu:

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

introspeksi ini dimaksudkan untuk membantu debugging dan pengembangan; tidak disarankan untuk mengandalkannya untuk tujuan fungsionalitas produksi.

Versi lebih pendek:

import inspect

def f1(): f2()

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

f1()

(dengan terima kasih kepada @Alex, dan Stefaan Lippen )

Ini sepertinya bekerja dengan baik:

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

Saya datang dengan versi yang sedikit lebih panjang yang mencoba membangun nama metode lengkap termasuk modul dan kelas.

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)

Saya akan menggunakan inspect.currentframe().f_back.f_code.co_name. Penggunaannya belum tercakup dalam salah satu jawaban sebelumnya yang sebagian besar dari salah satu dari tiga jenis:

• Beberapa jawaban sebelumnya digunakan inspect.stacktetapi diketahui terlalu lambat .
• Beberapa jawaban sebelumnya menggunakan sys._getframefungsi pribadi internal yang diberi garis bawah utama, dan penggunaannya secara implisit tidak disarankan.
• Satu jawaban sebelumnya digunakan inspect.getouterframes(inspect.currentframe(), 2)[1][3]tetapi sama sekali tidak jelas apa [1][3]yang diakses.

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

Catatan yang cast(FrameType, frame)digunakan untuk memuaskan mypy.

Ucapan terima kasih: komentar sebelumnya oleh 1313e untuk jawaban .

Sedikit penggabungan dari hal-hal di atas. Tapi ini celah saya.

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

Menggunakan:

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

def bar():
    return foo()

def baz():
    return bar()

def fizz():
    return baz()

fizz()

output adalah

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

Saya menemukan cara jika Anda akan melintasi kelas dan ingin kelas metode milik DAN metode. Dibutuhkan sedikit pekerjaan ekstraksi tetapi itu membuat titik. Ini berfungsi dalam 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$