Determine o nome da função a partir dessa função (sem usar o rastreamento)

No Python, sem usar o tracebackmódulo, existe uma maneira de determinar o nome de uma função de dentro dessa função?

Digamos que eu tenho um módulo foo com uma barra de funções. Ao executar foo.bar(), existe uma maneira de a barra saber o nome da barra? Ou melhor ainda, foo.baro nome?

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

Python não possui um recurso para acessar a função ou seu nome dentro da própria função. Foi proposto, mas rejeitado. Se você não quiser jogar com a pilha, use "bar"ou usebar.__name__ dependendo do contexto.

O aviso de rejeição fornecido é:

Este PEP é rejeitado. Não está claro como ela deve ser implementada ou qual deve ser a semântica precisa nos casos extremos, e não há casos de uso importantes suficientes. a resposta foi morna, na melhor das hipóteses.

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

Existem algumas maneiras de obter o mesmo resultado:

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)

Observe que as inspect.stackchamadas são milhares de vezes mais lentas que as alternativas:

$ 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

Você pode obter o nome que foi definido usando a abordagem que @Andreas Jung mostra , mas esse pode não ser o nome com o qual a função foi chamada:

import inspect

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

Foo2 = Foo

>>> Foo()
Foo

>>> Foo2()
Foo

Se essa distinção é importante para você ou não, não posso dizer.

functionNameAsString = sys._getframe().f_code.co_name

Eu queria uma coisa muito semelhante, porque queria colocar o nome da função em uma sequência de log que fosse em vários lugares no meu código. Provavelmente não é a melhor maneira de fazer isso, mas aqui está uma maneira de obter o nome da função atual.

Eu mantenho esse útil utilitário por perto:

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

Uso:

myself()

Eu acho que inspecté a melhor maneira de fazer isso. Por exemplo:

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

Encontrei um invólucro que escreverá o nome da função

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

Isso imprimirá

my_funky_name

STUB

Na verdade, isso é derivado das outras respostas à pergunta.

Aqui está a minha opinião:

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

A provável vantagem desta versão em relação ao uso do inspect.stack () é que ele deve ser milhares de vezes mais rápido [veja a postagem e os horários de Alex Melihoff sobre o uso de sys._getframe () versus o uso de inspect.stack ()].

print(inspect.stack()[0].function) parece funcionar também (Python 3.5).

Aqui está uma abordagem preparada para o futuro.

A combinação das sugestões de @ CamHart e @ Yuval com a resposta aceita do @ RoshOxymoron tem o benefício de evitar:

• _hidden e métodos potencialmente obsoletos
• indexação na pilha (que pode ser reordenada em futuros pitães)

Então, acho que isso funciona bem com futuras versões do python (testadas em 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())

Teste:

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

Resultado:

test_class_func_name
test_func_name

Não sei por que as pessoas complicam:

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

No IDE, o código gera

olá, eu sou foo, papai é

olá, eu sou bar, papai é foo

olá, eu sou bar, papai é

Você pode usar um decorador:

def my_function(name=None):
    return name

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

>>> get_function_name(my_function)
'my_function'

Eu faço minha própria abordagem usada para chamar super com segurança dentro do cenário de herança múltipla (coloquei todo o código)

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

uso da amostra:

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

testando:

a = C()
a.test()

resultado:

called from C
called from A
called from B

Dentro de cada método decorado @with_name, você tem acesso a self .__ fname__ como o nome da função atual.

Recentemente, tentei usar as respostas acima para acessar a documentação de uma função a partir do contexto dessa função, mas como as perguntas acima estavam retornando apenas a string de nome, ela não funcionou.

Felizmente, encontrei uma solução simples. Se como eu, você deseja se referir à função em vez de simplesmente obter a string que representa o nome que pode aplicar eval () à string do nome da função.

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

Sugiro não confiar nos elementos da pilha. Se alguém usar seu código em contextos diferentes (intérprete python por exemplo), sua pilha mudará e quebrará seu índice ([0] [3]).

Eu sugiro que você algo assim:

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

Isso é muito fácil de realizar com um decorador.

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