Как функция может стабильно ссылаться сама на себя?

Кажется, что обращение к my_own_id будет искать 'my_own_id' в словаре глобального пространства имен, поэтому это имя всегда будет использоваться в определении функции. Поскольку это имя может быть присвоено различным значениям, извлекаемое значение также может измениться. Если вы сделаете me аргументом по умолчанию, вы можете назначить его самой функции в определении функции, чтобы сохранить ссылку на реальную функцию.

Вы можете использовать этот декоратор, который неявно передает исходную функцию в качестве первого аргумента.

>>> from functools import wraps
>>> def save_id(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            return func(func, *args, **kwargs)
        return wrapper


>>> @save_id
def my_own_id(me): # me is passed implicitly by save_id
    return id(me)

>>> alias = my_own_id
>>> alias()
40775152
>>> my_own_id = 'foo'
>>> alias()
40775152

В самом деле, если вы полагаетесь только на имя функции, если это имя переопределено в пространстве глобальных переменных (в модуле функция была определена), ссылка, использующая имя самой функции, потерпит неудачу.

Более простой и удобный способ — написать для этого декоратор, который предоставит nonlocalvariable, содержащую ссылку на саму функцию.

from functools import wraps

def know_thyself(func):
   @wraps(func):
   def new_func(*args, **kwargs):
        my_own_id = func
        return func(*args, **kwargs)
   return new_func

И может использоваться как:

>>> @know_thyself
... def my_own_id():
...     me = my_own_id
...     return id(me)
... 

Существует еще один возможный подход, далеко не такой чистый, с использованием интроспекции фрейма и перестроением новой функции с повторным использованием того же объектного кода. Я использовал это в этом посте о самореферентном лямбда-выражении в Python: http://metapython.blogspot.com.br/2010/11/recursive-lambda-functions.html

Что ж, если вы не возражаете против вызова функции (чтобы получить желаемую функцию в глобальной области видимости), вы можете обернуть функцию, чтобы защитить ее определение:

>>> def be_known():
...     global my_own_id
...     def _my_own_id():
...         return id(_my_own_id)
...     my_own_id = _my_own_id
... 
>>> be_known()
>>> my_own_id()
140685505972568
>>> alias, my_own_id = my_own_id, None
>>> alias()
140685505972568

Обратите внимание, что защищенная функция должна вызывать себя с нелокальным, а не глобальным именем.

Подход декоратора, вероятно, лучший. Вот еще для развлечения:

1. Перехватите один из аргументов функции, чтобы предоставить статическую переменную.

   def fn(fnid=None):
       print "My id:", fnid
   fn.func_defaults = (id(fn),)
   

2. Здесь есть несколько способов получить текущую функцию: код Python получить текущую функцию в переменную?; большинство из них связано с поиском currentframe.f_code в различных местах. Они работают без каких-либо изменений исходной функции.

Это из-за масштаба

>>> def foo():
...     x = foo
...     print x
... 
>>> foo()
<function foo at 0x10836e938>
>>> alias = foo
>>> alias()
<function foo at 0x10836e938>
>>> foo = None
>>> alias()
None
>>> foo = []
>>> alias()
[]
>>> del foo
>>> alias()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in foo
NameError: global name 'foo' is not defined
>>> 

У Люка была идея, но, похоже, он не развил ее: используйте изменяемый параметр по умолчанию для хранения значения в объекте функции . Значения параметров по умолчанию оцениваются только один раз, когда функция определена, и после этого сохраняют свое предыдущее значение.

>>> def my_own_id(me=[None]):
    if not me[0]:
        me[0] = my_own_id
    return id(me[0])

>>> alias = my_own_id
>>> alias()
40330928
>>> my_own_id = None
>>> alias()
40330928

Это требует осторожности с вашей стороны, чтобы никогда не вызывать функцию с параметром.