Wie man den Aufrufer der Methode name der aufgerufenen Methode?

Python: How to get the caller ' s name der Methode in der aufgerufenen Methode?

Angenommen ich habe 2 Methoden:

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

def method2(self):
    ...

Wenn ich nicht will, zu tun, die Veränderung für methode1, wie man den Namen des Anrufers (in diesem Beispiel, der name ist methode1) in methode2?

InformationsquelleAutor zs2020 | 2010-04-16
  1. 191

    inspizieren.getframeinfo und andere Verwandte Funktionen in inspect helfen können:

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

    diese Selbstbeobachtung soll dazu beitragen, debugging und Entwicklung; es ist nicht ratsam, sich auf das für die Produktion-Funktionalität Zwecke.

    • "es ist nicht ratsam, sich auf das für die Produktion-Funktionalität Zwecke." Warum nicht?
    • es ist abhängig von der CPython-Implementierung, also code mit diesem zu brechen, wenn Sie jemals versuchen, PyPy oder Jython oder andere Laufzeitumgebungen. das ist in Ordnung, wenn Sie nur die Entwicklung und das debugging lokal, aber nicht wirklich etwas, was Sie wollen in Ihrer Produktion.
    • Hi Jungs! Nachdem alle. Ist es immer noch nicht für die Produktion geeignet?
    • Nein, bitte Lesen Robru ' s Kommentar.
    • Über die Reine python-version, ich lief in ein Problem mit ihm, wo es macht den code, der ausgeführt wird, unter einer zweiten Ausführung in mehreren Minuten einmal eingeführt. es höchst ineffizient
    • Warum ist das nicht erwähnt in der Python ist3 Dokumentation? docs.python.org/3/library/inspect.html, Sie würden zumindest eine Warnung, wenn es schlecht ist richtig?
    • Seine eine Schande, dass dies so ein Treffer auf die Leistung. Die Protokollierung könnte so viel schöner mit so etwas (oder CallerMemberName).

    InformationsquelleAutor Alex Martelli
  2. 79

    Kürzere version:

    import inspect

def f1(): f2()

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

f1()

    (mit Dank an @Alex und Stefaan Lippen)

    • Hallo, ich erhalte folgende Fehlermeldung, wenn ich dies ausführen: Datei "/usr/lib/python2.7/inspect.py", line 528, in findsource wenn nicht Quellcode-Dateien und die Datei[0] + Datei[-1] != '<>': IndexError: string index out of range Kann u bitte geben Sie Vorschlag. Danke im Voraus.
    • Dieser Ansatz gab mir eine Fehlermeldung: KeyError: 'main'
    InformationsquelleAutor Todd Owen
  3. 48

    Diese scheint zu funktionieren:

    import sys
print sys._getframe().f_back.f_code.co_name
    • Dies scheint zu sein, viel schneller als inspect.stack
    InformationsquelleAutor Augiwan
  4. 25

    Habe ich mit einer etwas längeren version, die versucht zu bauen, die eine volle name der Methode einschließlich Modul und Klasse.

    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)
    • Genial, das funktionierte gut für mich in meinen logging-code, wo ich kann aufgerufen werden aus einer Menge von verschiedenen Orten. Dank sehr viel.
    • Es sei denn, Sie löschen auch stack es immer noch leckt frames aufgrund rundem refs wie in der inspect-docs
    • Sie haben einige test-code um zu beweisen, dass?
    • Schwer zu zeigen, in einem Kommentar... Copy-paste in einem editor, dieser treibende code (Eingabe aus dem Speicher), und versuchen beide Versionen des Codes: `` import weakref-Klasse C: pass def kill(): print ("Getötet") def undicht(): caller_name() local_var = C() weakref.finalize(local_var, töten) undicht() print("Local_var muss getötet worden") `` Sie bekommen sollte: `` Getötet Local_var muss getötet worden ` " und nicht: `` Local_var muss getötet worden Getötet ``
    • Genial! Das funktionierte bei anderen Lösungen fehlgeschlagen! Ich bin mit Klassen-Methoden und lambda-Ausdrücke, so ist es schwierig.
    InformationsquelleAutor anatoly techtonik
  5. 10

    Bit ein Zusammenschluss von dem Zeug oben. Aber hier ist mein knacken an.

    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

    Verwenden:

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

def bar():
    return foo()

def baz():
    return bar()

def fizz():
    return baz()

fizz()

    Ausgabe 

    level :             module             : name
--------------------------------------------------
    3 :              None              : fizz
    2 :              None              : baz
    1 :              None              : bar
    0 :            __main__            : foo
    • Dieser löst einen IndexError, wenn die requeted stack-Tiefe größer ist als die tatsächliche. Verwenden modules = [(index, inspect.getmodule(stack[index][0])) for index in reversed(range(1, min(stack_size, len(inspect.stack()))))] um die Module.
    InformationsquelleAutor migpok35
  6. 1

    Fand ich einen Weg, wenn man über Klassen und die Klasse die Methode gehört, UND die Methode. Es dauert ein bisschen Extraktion Arbeit, aber es macht seinen Punkt. Dies funktioniert 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()
    InformationsquelleAutor Michael Swartz
  7. 0

    drucken können Sie eine Liste der Funktion wie hier beantwortet https://stackoverflow.com/a/56897183/4039061

    import inspect;print(*['\n\x1b[0;36;1m| \x1b[0;32;1m{:25}\x1b[0;36;1m| \x1b[0;35;1m{}'.format(str(x.function), x.filename+'\x1b[0;31;1m:'+str(x.lineno)+'\x1b[0m') for x in inspect.stack()])
    InformationsquelleAutor MohitGhodasara
  8. -1
    #!/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$
    InformationsquelleAutor Mohammad Shahid Siddiqui
Schreibe einen Kommentar