Como obter um nome de função como uma string?

No Python, como obtenho um nome de função como uma string, sem chamar a função?

def my_function():
    pass

print get_function_name_as_string(my_function) # my_function is not in quotes

deve produzir "my_function".

Essa função está disponível no Python? Se não, alguma idéia de como implementar get_function_name_as_string, em Python?

my_function.__name__

Usar __name__é o método preferido, pois se aplica de maneira uniforme. Ao contrário func_name, ele funciona também em funções internas:

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

Além disso, os sublinhados duplos indicam ao leitor que este é um atributo especial. Como bônus, as classes e os módulos também têm um __name__atributo; portanto, você só lembra de um nome especial.

Para obter o nome da função ou método atual de dentro, considere:

import inspect

this_function_name = inspect.currentframe().f_code.co_name

sys._getframetambém funciona em vez de, inspect.currentframeembora o último evite acessar uma função privada.

Para obter o nome da função de chamada, considere f_backcomo em inspect.currentframe().f_back.f_code.co_name.

Se também estiver usando mypy, pode reclamar que:

erro: o item "Nenhum" de "Opcional [FrameType]" não tem atributo "f_code"

Para suprimir o erro acima, considere:

import inspect
import types
from typing import cast

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

my_function.func_name

Existem também outras propriedades divertidas das funções. Digite dir(func_name)para listá-los. func_name.func_code.co_codeé a função compilada, armazenada como uma string.

import dis
dis.dis(my_function)

exibirá o código em formato legível quase humano. :)

Esta função retornará o nome da função do chamador.

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

É como a resposta de Albert Vonpupp com uma embalagem amigável.

Se você estiver interessado em métodos de classe também, Python 3.3+ tem __qualname__além __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"

Eu gosto de usar um decorador de funções. Eu adicionei uma classe, que também calcula o tempo da função. Suponha que o gLog seja um logger python padrão:

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

então agora tudo o que você tem a ver com a sua função é decorá-la e pronto

@func_timer_decorator
def my_func():

import inspect

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

Onde

• stack () [0] o chamador

• stack () [3] o nome da string do método

Como uma extensão da resposta de @ Demyn , criei algumas funções utilitárias que imprimem o nome da função atual e os argumentos da função atual:

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ão está garantido que esteja disponível em todas as implementações do Python ( consulte ref ), você pode usar o tracebackmódulo para fazer a mesma coisa, por exemplo.

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

   return funcName

Uma chamada para stack[-1]retornará os detalhes do processo atual.

Você só quer obter o nome da função aqui é um código simples para isso. digamos que você tenha essas funções definidas

def function1():
    print "function1"

def function2():
    print "function2"

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

a saída será function1

Agora, digamos que você tenha essas funções em uma lista

a = [function1 , function2 , funciton3]

para obter o nome das funções

for i in a:
    print i.__name__

a saída será

função1
função2
função3

Eu já vi algumas respostas que utilizavam decoradores, embora eu achasse que algumas eram um pouco detalhadas. Aqui está algo que eu uso para registrar nomes de funções, bem como seus respectivos valores de entrada e saída. Eu a adaptei aqui para apenas imprimir as informações em vez de criar um arquivo de log e as adaptei para aplicar ao exemplo específico do 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()

Resultado:

{'function_name': 'my_function'}