Déterminer le nom de la fonction à partir de cette fonction (sans utiliser traceback)

En Python, sans utiliser le tracebackmodule, existe-t-il un moyen de déterminer le nom d'une fonction à partir de cette fonction?

Disons que j'ai un module foo avec une barre de fonctions. Lors de l'exécution foo.bar(), y a-t-il un moyen pour bar de connaître le nom de la barre? Ou mieux encore, son foo.barnom?

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

Python n'a pas de fonctionnalité pour accéder à la fonction ou à son nom dans la fonction elle-même. Il a été proposé mais rejeté. Si vous ne voulez pas jouer avec la pile vous-même, vous devez utiliser "bar"ou en bar.__name__fonction du contexte.

L'avis de rejet donné est:

Ce PEP est rejeté. Il n'est pas clair comment cela devrait être implémenté ou quelle devrait être la sémantique précise dans les cas limites, et il n'y a pas assez de cas d'utilisation importants donnés. la réponse a été au mieux tiède.

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

Il existe plusieurs façons d'obtenir le même résultat:

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)

Notez que les inspect.stackappels sont des milliers de fois plus lents que les alternatives:

$ 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

Vous pouvez obtenir le nom avec lequel il a été défini en utilisant l'approche indiquée par @Andreas Jung , mais ce n'est peut-être pas le nom avec lequel la fonction a été appelée:

import inspect

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

Foo2 = Foo

>>> Foo()
Foo

>>> Foo2()
Foo

Que cette distinction soit importante pour vous ou non, je ne peux pas le dire.

functionNameAsString = sys._getframe().f_code.co_name

Je voulais une chose très similaire parce que je voulais mettre le nom de la fonction dans une chaîne de journal qui allait à plusieurs endroits dans mon code. Ce n'est probablement pas la meilleure façon de le faire, mais voici un moyen d'obtenir le nom de la fonction actuelle.

Je garde cet utilitaire à portée de main:

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

Usage:

myself()

Je suppose que inspectc'est la meilleure façon de le faire. Par exemple:

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

J'ai trouvé un wrapper qui écrira le nom de la fonction

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

Cela imprimera

my_funky_name

TALON

Ceci est en fait dérivé des autres réponses à la question.

Voici mon point de vue:

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

L'avantage probable de cette version par rapport à l'inspection.stack () est qu'elle devrait être des milliers de fois plus rapide [voir la publication d'Alex Melihoff et les délais concernant l'utilisation de sys._getframe () par rapport à l'utilisation d'inspect.stack ()].

print(inspect.stack()[0].function) semble fonctionner aussi (Python 3.5).

Voici une approche évolutive.

La combinaison des suggestions de @ CamHart et @ Yuval avec la réponse acceptée de @ RoshOxymoron a l'avantage d'éviter:

• _hidden et méthodes potentiellement obsolètes
• indexation dans la pile (qui pourrait être réorganisée dans les futurs pythons)

Je pense donc que cela fonctionne bien avec les futures versions de python (testées sur 2.7.3 et 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())

Tester:

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

Production:

test_class_func_name
test_func_name

Je ne sais pas pourquoi les gens compliquent les choses:

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

Dans IDE, les sorties de code

bonjour, je suis foo, papa est

bonjour, je suis bar, papa est foo

bonjour, je suis bar, papa est

Vous pouvez utiliser un décorateur:

def my_function(name=None):
    return name

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

>>> get_function_name(my_function)
'my_function'

Je fais ma propre approche utilisée pour appeler super avec sécurité dans un scénario d'héritage multiple (je mets tout le code)

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

exemple d'utilisation:

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

le tester:

a = C()
a.test()

production:

called from C
called from A
called from B

À l'intérieur de chaque méthode décorée @with_name, vous avez accès à self .__ fname__ comme nom de fonction actuel.

J'ai récemment essayé d'utiliser les réponses ci-dessus pour accéder à la docstring d'une fonction à partir du contexte de cette fonction, mais comme les questions ci-dessus ne renvoyaient que la chaîne de nom, cela n'a pas fonctionné.

Heureusement, j'ai trouvé une solution simple. Si comme moi, vous voulez vous référer à la fonction plutôt que simplement obtenir la chaîne représentant le nom, vous pouvez appliquer eval () à la chaîne du nom de la fonction.

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

Je suggère de ne pas compter sur des éléments de pile. Si quelqu'un utilise votre code dans différents contextes (interprète python par exemple), votre pile changera et cassera votre index ([0] [3]).

Je vous suggère quelque chose comme ça:

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

C'est assez facile à réaliser avec un décorateur.

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