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

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é a alguien que dijo que usara la clase para resolver este problema, pero eso puede ser un problema para redefinir todas las funciones existentes. ¿Alguna sugerencia?

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 haga 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)  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 utiliza 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 que un método fuera capaz de hacer referencia a sí mismo, tendría que hacer algo más como la solución original.

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__ 

¿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  >>> x = f >>> x() My name is f and I am  >>>