Determina il nome della funzione dall'interno di quella funzione (senza usare traceback)

In Python, senza usare il tracebackmodulo, c'è un modo per determinare il nome di una funzione all'interno di quella funzione?

Supponiamo di avere un modulo con una barra delle funzioni. Durante l'esecuzione foo.bar(), c'è un modo per bar di conoscere il nome della barra? O meglio ancora, foo.baril nome?

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

Python non ha una funzione per accedere alla funzione o al suo nome all'interno della funzione stessa. È stato proposto ma respinto. Se non vuoi giocare tu stesso con la pila, dovresti usare "bar"o in bar.__name__base al contesto.

L'avviso di rifiuto dato è:

Questo PEP è stato respinto. Non è chiaro come dovrebbe essere implementato o quale dovrebbe essere la semantica precisa nei casi limite e non ci sono abbastanza casi d'uso importanti dati. la risposta è stata al massimo tiepida.

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

Esistono alcuni modi per ottenere lo stesso risultato:

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)

Si noti che le inspect.stackchiamate sono migliaia di volte più lente delle alternative:

$ 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

Puoi ottenere il nome che è stato definito usando l'approccio mostrato da @Andreas Jung , ma potrebbe non essere il nome con cui è stata chiamata la funzione:

import inspect

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

Foo2 = Foo

>>> Foo()
Foo

>>> Foo2()
Foo

Se questa distinzione sia importante per te o no, non posso dire.

functionNameAsString = sys._getframe().f_code.co_name

Volevo qualcosa di molto simile perché volevo inserire il nome della funzione in una stringa di registro che andava in diverse posizioni nel mio codice. Probabilmente non è il modo migliore per farlo, ma ecco un modo per ottenere il nome della funzione corrente.

Tengo questa utile utility nelle vicinanze:

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

Uso:

myself()

Immagino inspectsia il modo migliore per farlo. Per esempio:

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

Ho trovato un wrapper che scriverà il nome della funzione

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

Questo stamperà

my_funky_name

STUB

Questo è in realtà derivato dalle altre risposte alla domanda.

Ecco la mia opinione:

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

Il probabile vantaggio di questa versione rispetto all'utilizzo di inspect.stack () è che dovrebbe essere migliaia di volte più veloce [vedi il post e i tempi di Alex Melihoff sull'uso di sys._getframe () rispetto all'utilizzo di inspect.stack ()].

print(inspect.stack()[0].function) sembra funzionare anche (Python 3.5).

Ecco un approccio a prova di futuro.

La combinazione dei suggerimenti di @ CamHart e @ Yuval con la risposta accettata di @ RoshOxymoron ha il vantaggio di evitare:

• _hidden e metodi potenzialmente deprecati
• indicizzazione nello stack (che potrebbe essere riordinato in pitoni futuri)

Quindi penso che questo funzioni bene con le future versioni di Python (testate su 2.7.3 e 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())

Test:

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

Produzione:

test_class_func_name
test_func_name

Non sono sicuro del motivo per cui le persone lo rendono complicato:

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

Nell'IDE il codice viene generato

ciao, sono pazzo, papà lo è

ciao, sono bar, papà è pazzo

ciao, sono bar, papà lo è

Puoi usare un decoratore:

def my_function(name=None):
    return name

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

>>> get_function_name(my_function)
'my_function'

Faccio il mio approccio usato per chiamare super con sicurezza all'interno di uno scenario di ereditarietà multipla (ho messo tutto il codice)

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

utilizzo del campione:

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

testandolo:

a = C()
a.test()

produzione:

called from C
called from A
called from B

All'interno di ogni metodo decorato @with_name hai accesso a self .__ fname__ come nome della funzione corrente.

Di recente ho provato a utilizzare le risposte di cui sopra per accedere al docstring di una funzione dal contesto di quella funzione, ma poiché le domande precedenti restituivano solo la stringa del nome, non funzionava.

Fortunatamente ho trovato una soluzione semplice. Se come me, vuoi fare riferimento alla funzione anziché semplicemente ottenere la stringa che rappresenta il nome, puoi applicare eval () alla stringa del nome della funzione.

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

Suggerisco di non fare affidamento sugli elementi dello stack. Se qualcuno usa il tuo codice in contesti diversi (ad esempio interprete python) il tuo stack cambierà e spezzerà il tuo indice ([0] [3]).

Ti suggerisco una cosa del genere:

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

Questo è abbastanza facile da realizzare con un decoratore.

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