Bestimmen Sie den Funktionsnamen innerhalb dieser Funktion (ohne Traceback zu verwenden).

Gibt es in Python ohne Verwendung des tracebackModuls eine Möglichkeit, den Namen einer Funktion innerhalb dieser Funktion zu bestimmen?

Angenommen, ich habe ein Modul foo mit einer Funktionsleiste. Gibt es bei der Ausführung foo.bar()eine Möglichkeit für Bar, den Namen der Bar zu kennen? Oder noch besser, foo.barder Name?

#foo.py  
def bar():
    print "my name is", __myname__ # <== how do I calculate this at runtime?

Python hat keine Funktion, um auf die Funktion oder ihren Namen innerhalb der Funktion selbst zuzugreifen. Es wurde vorgeschlagen, aber abgelehnt. Wenn Sie nicht selbst mit dem Stack spielen möchten, sollten Sie entweder "bar"oder bar.__name__je nach Kontext verwenden.

Die angegebene Ablehnungserklärung lautet:

Dieser PEP wird abgelehnt. Es ist nicht klar, wie es implementiert werden soll oder wie die genaue Semantik in Randfällen aussehen soll, und es werden nicht genügend wichtige Anwendungsfälle angegeben. Die Reaktion war bestenfalls lauwarm.

import inspect

def foo():
   print(inspect.stack()[0][3])
   print(inspect.stack()[1][3]) #will give the caller of foos name, if something called foo

Es gibt verschiedene Möglichkeiten, um das gleiche Ergebnis zu erzielen:

from __future__ import print_function
import sys
import inspect

def what_is_my_name():
    print(inspect.stack()[0][0].f_code.co_name)
    print(inspect.stack()[0][3])
    print(inspect.currentframe().f_code.co_name)
    print(sys._getframe().f_code.co_name)

Beachten Sie, dass die inspect.stackAnrufe tausendmal langsamer sind als die Alternativen:

$ python -m timeit -s 'import inspect, sys' 'inspect.stack()[0][0].f_code.co_name'
1000 loops, best of 3: 499 usec per loop
$ python -m timeit -s 'import inspect, sys' 'inspect.stack()[0][3]'
1000 loops, best of 3: 497 usec per loop
$ python -m timeit -s 'import inspect, sys' 'inspect.currentframe().f_code.co_name'
10000000 loops, best of 3: 0.1 usec per loop
$ python -m timeit -s 'import inspect, sys' 'sys._getframe().f_code.co_name'
10000000 loops, best of 3: 0.135 usec per loop

Sie können den Namen, mit dem es definiert wurde, mit dem von @Andreas Jung gezeigten Ansatz erhalten , aber dies ist möglicherweise nicht der Name, mit dem die Funktion aufgerufen wurde:

import inspect

def Foo():
   print inspect.stack()[0][3]

Foo2 = Foo

>>> Foo()
Foo

>>> Foo2()
Foo

Ob diese Unterscheidung für Sie wichtig ist oder nicht, kann ich nicht sagen.

functionNameAsString = sys._getframe().f_code.co_name

Ich wollte eine sehr ähnliche Sache, weil ich den Funktionsnamen in eine Protokollzeichenfolge einfügen wollte, die an mehreren Stellen in meinem Code stand. Wahrscheinlich nicht der beste Weg, dies zu tun, aber hier ist ein Weg, um den Namen der aktuellen Funktion zu erhalten.

Ich habe dieses praktische Dienstprogramm in der Nähe:

import inspect
myself = lambda: inspect.stack()[1][3]

Verwendungszweck:

myself()

Ich denke, das inspectist der beste Weg, dies zu tun. Zum Beispiel:

import inspect
def bar():
    print("My name is", inspect.stack()[0][3])

Ich habe einen Wrapper gefunden, der den Funktionsnamen schreibt

from functools import wraps

def tmp_wrap(func):
    @wraps(func)
    def tmp(*args, **kwargs):
        print func.__name__
        return func(*args, **kwargs)
    return tmp

@tmp_wrap
def my_funky_name():
    print "STUB"

my_funky_name()

Dies wird gedruckt

my_funky_name

STUB

Dies ergibt sich tatsächlich aus den anderen Antworten auf die Frage.

Hier ist meine Einstellung:

import sys

# for current func name, specify 0 or no argument.
# for name of caller of current func, specify 1.
# for name of caller of caller of current func, specify 2. etc.
currentFuncName = lambda n=0: sys._getframe(n + 1).f_code.co_name


def testFunction():
    print "You are in function:", currentFuncName()
    print "This function's caller was:", currentFuncName(1)    


def invokeTest():
    testFunction()


invokeTest()

# end of file

Der wahrscheinliche Vorteil dieser Version gegenüber der Verwendung von inspect.stack () besteht darin, dass sie tausendfach schneller sein sollte [siehe Alex Melihoffs Beitrag und Zeitangaben zur Verwendung von sys._getframe () im Vergleich zur Verwendung von inspect.stack ()].

print(inspect.stack()[0].function) scheint auch zu funktionieren (Python 3.5).

Hier ist ein zukunftssicherer Ansatz.

Die Kombination der Vorschläge von @ CamHart und @ Yuval mit der akzeptierten Antwort von @ RoshOxymoron hat den Vorteil, dass Folgendes vermieden wird:

• _hidden und möglicherweise veraltete Methoden
• Indizierung in den Stack (der in zukünftigen Pythons neu angeordnet werden könnte)

Ich denke, das spielt sich gut mit zukünftigen Python-Versionen (getestet auf 2.7.3 und 3.3.2):

from __future__ import print_function
import inspect

def bar():
    print("my name is '{}'".format(inspect.currentframe().f_code.co_name))

import sys

def func_name():
    """
    :return: name of caller
    """
    return sys._getframe(1).f_code.co_name

class A(object):
    def __init__(self):
        pass
    def test_class_func_name(self):
        print(func_name())

def test_func_name():
    print(func_name())

Prüfung:

a = A()
a.test_class_func_name()
test_func_name()

Ausgabe:

test_class_func_name
test_func_name

Ich bin mir nicht sicher, warum die Leute es kompliziert machen:

import sys 
print("%s/%s" %(sys._getframe().f_code.co_filename, sys._getframe().f_code.co_name))

import inspect

def whoami():
    return inspect.stack()[1][3]

def whosdaddy():
    return inspect.stack()[2][3]

def foo():
    print "hello, I'm %s, daddy is %s" % (whoami(), whosdaddy())
    bar()

def bar():
    print "hello, I'm %s, daddy is %s" % (whoami(), whosdaddy())

foo()
bar()

In der IDE wird der Code ausgegeben

Hallo, ich bin foo, Papa ist

Hallo, ich bin Bar, Papa ist foo

Hallo, ich bin Bar, Papa ist

Sie können einen Dekorateur verwenden:

def my_function(name=None):
    return name

def get_function_name(function):
    return function(name=function.__name__)

>>> get_function_name(my_function)
'my_function'

Ich mache meinen eigenen Ansatz, um Super mit Sicherheit innerhalb eines Mehrfachvererbungsszenarios aufzurufen (ich habe den gesamten Code eingefügt).

def safe_super(_class, _inst):
    """safe super call"""
    try:
        return getattr(super(_class, _inst), _inst.__fname__)
    except:
        return (lambda *x,**kx: None)


def with_name(function):
    def wrap(self, *args, **kwargs):
        self.__fname__ = function.__name__
        return function(self, *args, **kwargs)
return wrap

Beispielnutzung:

class A(object):

    def __init__():
        super(A, self).__init__()

    @with_name
    def test(self):
        print 'called from A\n'
        safe_super(A, self)()

class B(object):

    def __init__():
        super(B, self).__init__()

    @with_name
    def test(self):
        print 'called from B\n'
        safe_super(B, self)()

class C(A, B):

    def __init__():
        super(C, self).__init__()

    @with_name
    def test(self):
        print 'called from C\n'
        safe_super(C, self)()

Testen:

a = C()
a.test()

Ausgabe:

called from C
called from A
called from B

Innerhalb jeder mit @with_name dekorierten Methode haben Sie Zugriff auf self .__ fname__ als aktuellen Funktionsnamen.

Ich habe kürzlich versucht, die obigen Antworten zu verwenden, um aus dem Kontext dieser Funktion auf die Dokumentzeichenfolge einer Funktion zuzugreifen, aber da die obigen Fragen nur die Namenszeichenfolge zurückgaben, funktionierte dies nicht.

Zum Glück habe ich eine einfache Lösung gefunden. Wenn Sie wie ich auf die Funktion verweisen möchten, anstatt einfach die Zeichenfolge abzurufen, die den Namen darstellt, können Sie eval () auf die Zeichenfolge des Funktionsnamens anwenden.

import sys
def foo():
    """foo docstring"""
    print(eval(sys._getframe().f_code.co_name).__doc__)

Ich schlage vor, sich nicht auf Stapelelemente zu verlassen. Wenn jemand Ihren Code in verschiedenen Kontexten verwendet (z. B. Python-Interpreter), ändert sich Ihr Stapel und bricht Ihren Index ([0] [3]).

Ich schlage Ihnen so etwas vor:

class MyClass:

    def __init__(self):
        self.function_name = None

    def _Handler(self, **kwargs):
        print('Calling function {} with parameters {}'.format(self.function_name, kwargs))
        self.function_name = None

    def __getattr__(self, attr):
        self.function_name = attr
        return self._Handler


mc = MyClass()
mc.test(FirstParam='my', SecondParam='test')
mc.foobar(OtherParam='foobar')

Dies ist mit einem Dekorateur ziemlich einfach zu erreichen.

>>> from functools import wraps

>>> def named(func):
...     @wraps(func)
...     def _(*args, **kwargs):
...         return func(func.__name__, *args, **kwargs)
...     return _
... 

>>> @named
... def my_func(name, something_else):
...     return name, something_else
... 

>>> my_func('hello, world')
('my_func', 'hello, world')