Comment obtenir un nom de fonction sous forme de chaîne?

En Python, comment puis-je obtenir un nom de fonction sous forme de chaîne, sans appeler la fonction?

def my_function():
    pass

print get_function_name_as_string(my_function) # my_function is not in quotes

devrait sortir "my_function".

Une telle fonction est-elle disponible en Python? Sinon, des idées sur la façon de mettre en œuvre get_function_name_as_string, en Python?

my_function.__name__

L'utilisation __name__est la méthode préférée car elle s'applique uniformément. Contrairement à func_namecela, il fonctionne également sur les fonctions intégrées:

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

Les doubles soulignements indiquent également au lecteur qu'il s'agit d'un attribut spécial. En prime, les classes et les modules ont aussi un __name__attribut, donc vous n'avez qu'un seul nom spécial à retenir.

Pour obtenir le nom de la fonction ou de la méthode actuelle de l'intérieur, considérez:

import inspect

this_function_name = inspect.currentframe().f_code.co_name

sys._getframefonctionne également au lieu de inspect.currentframebien que ce dernier évite d'accéder à une fonction privée.

Pour obtenir le nom de la fonction appelante à la place, considérez f_backcomme dans inspect.currentframe().f_back.f_code.co_name.

S'il utilise également mypy, il peut se plaindre que:

erreur: l'élément "Aucun" de "Facultatif [FrameType]" n'a pas d'attribut "f_code"

Pour supprimer l'erreur ci-dessus, envisagez:

import inspect
import types
from typing import cast

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

my_function.func_name

Il existe également d'autres propriétés amusantes des fonctions. Tapez dir(func_name)pour les répertorier. func_name.func_code.co_codeest la fonction compilée, stockée sous forme de chaîne.

import dis
dis.dis(my_function)

affichera le code dans un format lisible par presque l'homme. :)

Cette fonction renverra le nom de la fonction de l'appelant.

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

C'est comme la réponse d'Albert Vonpupp avec un emballage convivial.

Si vous êtes intéressé par les méthodes de classe aussi, Python 3.3+ a __qualname__en plus __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"

J'aime utiliser un décorateur de fonction. J'ai ajouté une classe, qui multiplie également le temps de la fonction. Supposons que gLog est un enregistreur Python standard:

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

maintenant tout ce que vous avez à faire avec votre fonction est de le décorer et le tour est joué

@func_timer_decorator
def my_func():

import inspect

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

où

• stack () [0] l'appelant

• stack () [3] le nom de chaîne de la méthode

Dans le prolongement de la réponse de @ Demyn , j'ai créé des fonctions utilitaires qui affichent le nom de la fonction actuelle et les arguments de la fonction actuelle:

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

sys._getframe()n'est pas garanti d'être disponible dans toutes les implémentations de Python ( voir ref ), vous pouvez utiliser le tracebackmodule pour faire la même chose, par exemple.

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

   return funcName

Un appel à stack[-1]renverra les détails du processus en cours.

Vous voulez juste obtenir le nom de la fonction, voici un code simple pour cela. disons que vous avez défini ces fonctions

def function1():
    print "function1"

def function2():
    print "function2"

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

la sortie sera function1

Maintenant, disons que vous avez ces fonctions dans une liste

a = [function1 , function2 , funciton3]

pour obtenir le nom des fonctions

for i in a:
    print i.__name__

la sortie sera

fonction1
fonction2
fonction3

J'ai vu quelques réponses qui utilisaient des décorateurs, même si je trouvais que certaines étaient un peu bavardes. Voici quelque chose que j'utilise pour enregistrer les noms de fonction ainsi que leurs valeurs d'entrée et de sortie respectives. Je l'ai adapté ici pour simplement imprimer les informations plutôt que de créer un fichier journal et je l'ai adapté pour l'appliquer à l'exemple spécifique OP.

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

Production:

{'function_name': 'my_function'}