Wie erhalte ich einen Funktionsnamen als Zeichenfolge?

Wie erhalte ich in Python einen Funktionsnamen als Zeichenfolge, ohne die Funktion aufzurufen?

def my_function():
    pass

print get_function_name_as_string(my_function) # my_function is not in quotes

sollte ausgeben "my_function".

Ist eine solche Funktion in Python verfügbar? Wenn nicht, irgendwelche Ideen zur Implementierung get_function_name_as_stringin Python?

my_function.__name__

Die Verwendung __name__ist die bevorzugte Methode, da sie einheitlich angewendet wird. Im Gegensatz func_namedazu funktioniert es auch mit integrierten Funktionen:

>>> import time
>>> time.time.func_name
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
AttributeError: 'builtin_function_or_method' object has no attribute 'func_name'
>>> time.time.__name__ 
'time'

Auch die doppelten Unterstriche zeigen dem Leser an, dass dies ein besonderes Attribut ist. Als Bonus haben Klassen und Module auch ein __name__Attribut, sodass Sie sich nur einen speziellen Namen merken müssen.

Beachten Sie Folgendes, um den Namen der aktuellen Funktion oder Methode darin abzurufen:

import inspect

this_function_name = inspect.currentframe().f_code.co_name

sys._getframefunktioniert auch anstatt inspect.currentframeobwohl letzterer den Zugriff auf eine private Funktion vermeidet.

Um stattdessen den Namen der aufrufenden Funktion zu erhalten, betrachten Sie f_backwie in inspect.currentframe().f_back.f_code.co_name.

Wenn auch verwendet mypy, kann es sich beschweren, dass:

Fehler: Element "Keine" von "Optional [FrameType]" hat kein Attribut "f_code"

Beachten Sie Folgendes, um den obigen Fehler zu unterdrücken:

import inspect
import types
from typing import cast

this_function_name = cast(types.FrameType, inspect.currentframe()).f_code.co_name

my_function.func_name

Es gibt auch andere lustige Eigenschaften von Funktionen. Geben Sie ein, dir(func_name)um sie aufzulisten. func_name.func_code.co_codeist die kompilierte Funktion, die als Zeichenfolge gespeichert wird.

import dis
dis.dis(my_function)

zeigt den Code in einem fast für Menschen lesbaren Format an. :) :)

Diese Funktion gibt den Funktionsnamen des Anrufers zurück.

def func_name():
    import traceback
    return traceback.extract_stack(None, 2)[0][2]

Es ist wie die Antwort von Albert Vonpupp mit einem freundlichen Umschlag.

Wenn Sie sich auch für Klassenmethoden interessieren, bietet Python 3.3+ __qualname__zusätzlich zu __name__.

def my_function():
    pass

class MyClass(object):
    def method(self):
        pass

print(my_function.__name__)         # gives "my_function"
print(MyClass.method.__name__)      # gives "method"

print(my_function.__qualname__)     # gives "my_function"
print(MyClass.method.__qualname__)  # gives "MyClass.method"

Ich benutze gerne einen Funktionsdekorateur. Ich habe eine Klasse hinzugefügt, die auch die Funktionszeit mal. Angenommen, gLog ist ein Standard-Python-Logger:

class EnterExitLog():
    def __init__(self, funcName):
        self.funcName = funcName

    def __enter__(self):
        gLog.debug('Started: %s' % self.funcName)
        self.init_time = datetime.datetime.now()
        return self

    def __exit__(self, type, value, tb):
        gLog.debug('Finished: %s in: %s seconds' % (self.funcName, datetime.datetime.now() - self.init_time))

def func_timer_decorator(func):
    def func_wrapper(*args, **kwargs):
        with EnterExitLog(func.__name__):
            return func(*args, **kwargs)

    return func_wrapper

Jetzt müssen Sie nur noch mit Ihrer Funktion dekorieren und voila

@func_timer_decorator
def my_func():

sys._getframe()Es ist nicht garantiert, dass es in allen Implementierungen von Python verfügbar ist ( siehe Ref. ). Sie können das tracebackModul verwenden, um dasselbe zu tun, z.

import traceback
def who_am_i():
   stack = traceback.extract_stack()
   filename, codeline, funcName, text = stack[-2]

   return funcName

Ein Aufruf von stack[-1]gibt die aktuellen Prozessdetails zurück.

import inspect

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

wo

• stack () [0] der Aufrufer

• stack () [3] der Stringname der Methode

Als Erweiterung der Antwort von @ Demyn habe ich einige Dienstprogrammfunktionen erstellt, die den Namen der aktuellen Funktion und die Argumente der aktuellen Funktion drucken:

import inspect
import logging
import traceback

def get_function_name():
    return traceback.extract_stack(None, 2)[0][2]

def get_function_parameters_and_values():
    frame = inspect.currentframe().f_back
    args, _, _, values = inspect.getargvalues(frame)
    return ([(i, values[i]) for i in args])

def my_func(a, b, c=None):
    logging.info('Running ' + get_function_name() + '(' + str(get_function_parameters_and_values()) +')')
    pass

logger = logging.getLogger()
handler = logging.StreamHandler()
formatter = logging.Formatter(
    '%(asctime)s [%(levelname)s] -> %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.INFO)

my_func(1, 3) # 2016-03-25 17:16:06,927 [INFO] -> Running my_func([('a', 1), ('b', 3), ('c', None)])

Sie möchten nur den Namen der Funktion erhalten, hier ist ein einfacher Code dafür. Angenommen, Sie haben diese Funktionen definiert

def function1():
    print "function1"

def function2():
    print "function2"

def function3():
    print "function3"
print function1.__name__

Die Ausgabe ist function1

Angenommen, Sie haben diese Funktionen in einer Liste

a = [function1 , function2 , funciton3]

um den Namen der Funktionen zu erhalten

for i in a:
    print i.__name__

die Ausgabe wird sein

Funktion1
Funktion2
Funktion3

Ich habe ein paar Antworten gesehen, bei denen Dekorateure zum Einsatz kamen, obwohl ich der Meinung war, dass einige etwas ausführlich waren. Hier ist etwas, das ich zum Protokollieren von Funktionsnamen sowie ihrer jeweiligen Eingabe- und Ausgabewerte verwende. Ich habe es hier angepasst, um nur die Informationen zu drucken, anstatt eine Protokolldatei zu erstellen, und es angepasst, um es auf das OP-spezifische Beispiel anzuwenden.

def debug(func=None):
    def wrapper(*args, **kwargs):
        try:
            function_name = func.__func__.__qualname__
        except:
            function_name = func.__qualname__
        return func(*args, **kwargs, function_name=function_name)
    return wrapper

@debug
def my_function(**kwargs):
    print(kwargs)

my_function()

Ausgabe:

{'function_name': 'my_function'}