¿Cómo obtener un nombre de función como una cadena?

En Python, ¿cómo obtengo el nombre de una función como una cadena, sin llamar a la función?

def my_function():
    pass

print get_function_name_as_string(my_function) # my_function is not in quotes

debería salir "my_function".

¿Esta función está disponible en Python? Si no, ¿alguna idea sobre cómo implementar get_function_name_as_string, en Python?

my_function.__name__

El uso __name__es el método preferido ya que se aplica de manera uniforme. A diferencia func_name, también funciona en funciones integradas:

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

También los guiones bajos dobles indican al lector que este es un atributo especial. Como beneficio adicional, las clases y los módulos también tienen un __name__atributo, por lo que solo debe recordar un nombre especial.

Para obtener el nombre de la función o método actual desde adentro, considere:

import inspect

this_function_name = inspect.currentframe().f_code.co_name

sys._getframetambién funciona en lugar de inspect.currentframeaunque este último evita acceder a una función privada.

Para obtener el nombre de la función de llamada, considere f_backcomo en inspect.currentframe().f_back.f_code.co_name.

Si también lo usa mypy, puede quejarse de que:

error: el elemento "Ninguno" de "Opcional [FrameType]" no tiene el atributo "f_code"

Para suprimir el error anterior, 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

También hay otras propiedades divertidas de funciones. Escriba dir(func_name)para enumerarlos. func_name.func_code.co_codees la función compilada, almacenada como una cadena.

import dis
dis.dis(my_function)

mostrará el código en un formato legible para humanos. :)

Esta función devolverá el nombre de la función del llamante.

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

Es como la respuesta de Albert Vonpupp con una envoltura amigable.

Si también está interesado en los métodos de clase, Python 3.3+ tiene __qualname__además __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"

Me gusta usar un decorador de funciones. Agregué una clase, que también multiplica el tiempo de la función. Suponga que gLog es un registrador de python estándar:

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

así que ahora todo lo que tienes que hacer con tu función es decorarlo y listo

@func_timer_decorator
def my_func():

import inspect

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

dónde

• apilar () [0] la persona que llama

• stack () [3] el nombre de cadena del método

Como una extensión de la respuesta de @ Demyn , creé algunas funciones de utilidad que imprimen el nombre de la función actual y los argumentos de la función actual:

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()no se garantiza que esté disponible en todas las implementaciones de Python ( consulte la referencia ), puede usar el tracebackmódulo para hacer lo mismo, por ejemplo.

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

   return funcName

Una llamada a stack[-1]devolverá los detalles del proceso actual.

Solo desea obtener el nombre de la función aquí, es un código simple para eso. digamos que tienes estas funciones definidas

def function1():
    print "function1"

def function2():
    print "function2"

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

la salida será function1

Ahora digamos que tiene estas funciones en una lista

a = [function1 , function2 , funciton3]

para obtener el nombre de las funciones

for i in a:
    print i.__name__

la salida será

función1
función2
función3

He visto algunas respuestas que utilizan decoradores, aunque sentí que algunas eran un poco detalladas. Aquí hay algo que uso para registrar nombres de funciones, así como sus respectivos valores de entrada y salida. Lo he adaptado aquí para imprimir la información en lugar de crear un archivo de registro y lo he adaptado para aplicarlo al ejemplo específico de 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()

Salida:

{'function_name': 'my_function'}