python - propias - ¿Hay una forma genérica para que una función se refiera a sí misma?

que significa none en python

Question

Puedo acceder al atributo de una función python dentro de la propia función mediante el siguiente código:

def aa():
    print aa.__name__
    print aa.__hash__
    # other simliar

Sin embargo, si sobre la función aa() hay una plantilla para escribir otro código, digamos bb() , tengo que escribir:

def bb():
    print bb.__name__
    print bb.__hash__
    # other simliar

¿Hay un "puntero" similar al argumento self en un método de clase para que pueda escribir código como este?

def whatever():
    print self.__name__
    print self.__hash__
    # other simliar

Busqué y encontré que alguien dijo que usara la clase para resolver este problema, pero eso podría ser un problema para redefinir todas las funciones existentes. ¿Alguna sugerencia?

Answer 1

¿Qué tal un truco rápido para hacer tu propio "auto" nombre, como este:

>>> def f():
...     self = f
...     print "My name is ", self.__name__, "and I am", self.__hash__
...
>>> f()
My name is  f and I am <method-wrapper ''__hash__'' of function object at 0x00B50F30>
>>> x = f
>>> x()
My name is  f and I am <method-wrapper ''__hash__'' of function object at 0x00B50F30>
>>>

Answer 2

No hay una forma genérica para que una función se refiera a sí misma. Considere usar un decorador en su lugar. Si lo único que deseaba era imprimir información sobre la función que se puede hacer fácilmente con un decorador:

from functools import wraps
def showinfo(f):
    @wraps(f)
    def wrapper(*args, **kwds):
         print(f.__name__, f.__hash__)
         return f(*args, **kwds)
    return wrapper

@showinfo
def aa():
    pass

Si realmente necesita hacer referencia a la función, solo agréguela a los argumentos de la función:

def withself(f):
    @wraps(f)
    def wrapper(*args, **kwds):
        return f(f, *args, **kwds)
    return wrapper

@withself
def aa(self):
      print(self.__name__)
      # etc.

Editar para agregar un decorador alternativo :

También puede escribir un decorador más simple (y probablemente más rápido) que hará que la función ajustada funcione correctamente con la introspección de Python:

def bind(f):
    """Decorate function `f` to pass a reference to the function
    as the first argument"""
    return f.__get__(f, type(f))

@bind
def foo(self, x):
    "This is a bound function!"
    print(self, x)


>>> foo(42)
<function foo at 0x02A46030> 42
>>> help(foo)
Help on method foo in module __main__:

foo(self, x) method of builtins.function instance
    This is a bound function!

Esto aprovecha el protocolo descriptor de Python: las funciones tienen un método __get__ que se usa para crear métodos enlazados. El decorador simplemente usa el método existente para hacer de la función un método enlazado de sí mismo. Solo funcionará para funciones independientes. Si deseaba un método para poder hacer referencia a sí mismo, tendría que hacer algo más como la solución original.

Answer 3

http://docs.python.org/library/inspect.html parece prometedor:

import inspect
def foo():
     felf = globals()[inspect.getframeinfo(inspect.currentframe()).function]
     print felf.__name__, felf.__doc__

También puede usar el módulo sys para obtener el nombre de la función actual:

import sys
def bar():
     felf = globals()[sys._getframe().f_code.co_name]
     print felf.__name__, felf.__doc__