我希望有一个函数可以引用自己，比如递归。
所以我要做的像这样：
def fib(n):
return n if n <= 1 else fib(n-1)+fib(n-2)
这通常是可以的，但是fib实际上并不是指向自己；它指向封闭块中fib的绑定。所以如果由于某种原因fib被重新分配，它会出问题：
>>> foo = fib
>>> fib = foo(10)
>>> x = foo(8)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in fib
TypeError: 'int' object is not callable
如果可能的话，我该如何防止这种情况发生（在fib内部）？据我所知，在函数定义完全执行之前，fib的名称不存在；是否有任何解决方法？
我没有一个真正的使用案例，它可能会真的发生；我只是出于好奇而问。
from functools import wraps
def selfcaller(func):
@wraps(func)
def wrapper(*args, **kwargs):
return func(wrapper, *args, **kwargs)
return wrapper
并像这样使用它
@selfcaller
def fib(self, n):
return n if n <= 1 else self(n-1)+self(n-2)
这实际上是一种可读性高的定义固定点组合子（或Y组合子）的方法：
fix = lambda g: (lambda f: g(lambda arg: f(f)(arg))) (lambda f: g(lambda arg: f(f)(arg)))
用法：
fib = fix(lambda self: lambda n: n if n <= 1 else self(n-1)+self(n-2))
或者：
@fix
def fib(self):
return lambda n: n if n <= 1 else self(n-1)+self(n-2)
你想做的事情是无法实现的。你说得对，fib在函数定义执行之前不存在（或者更糟糕的是，它存在但指向完全不同的东西...），这意味着从fib内部没有任何解决方法能够可能起作用。*
然而，如果你愿意放弃这个要求，有一些可行的解决方法。例如：
def _fibmaker():
def fib(n):
return n if n <= 1 else fib(n-1)+fib(n-2)
return fib
fib = _fibmaker()
del _fibmaker
fib指向来自调用_fibmaker的本地环境中闭包绑定。当然，即使你真的想这样做，它也可以被替换，但这不容易（fib.__closure__属性不可写；它是一个元组，因此无法替换其中任何一个单元格；每个单元格的cell_contents是一个只读属性，...），你不可能无意间这样做。fib中使用一个特殊的占位符，并使用装饰器将占位符替换为装饰的函数），它们都同样不明显且丑陋，这似乎违反了TOOWTDI的原则。但在这种情况下，“it”是您可能不想进行的操作，因此并不重要。self而不需要额外的self参数来传递函数：def selfcaller(func):
env = {}
newfunc = types.FunctionType(func.__code__, globals=env)
env['self'] = newfunc
return newfunc
@selfcaller
def fib(n):
return n if n <= 1 else self(n-1)+self(n-2)
def selfcaller(func):
env = dict(func.__globals__)
newfunc = types.FunctionType(func.__code__, globals=env)
env[func.__code__.co_name] = newfunc
return newfunc
这是特定于Python 3.x的；在2.x中，一些属性名称可能不同，但其他方面是相同的。
这仍然不是100％完全通用的。例如，如果您想要能够将其用于方法，以便它们可以调用自己，即使类或对象重新定义了它们的名称，您需要使用稍微不同的技巧。还有一些病态情况可能需要构建一个新的CodeType，其中包含func.__code__.co_code。但基本思想是相同的。
* 就Python而言，在名称绑定之前，它并不存在...但显然，在内部，解释器必须知道您正在定义的函数的名称。至少一些解释器提供了非可移植的方法来获取该信息。
例如，在CPython 3.x中，您可以非常容易地获取当前正在定义的函数的名称-只需使用sys._getframe().f_code.co_name即可。
当然，这对您没有任何直接好处，因为没有任何内容（或错误的内容）与该名称绑定。但请注意其中的f_code。那是当前帧的代码对象。当然，您无法直接调用代码对象，但是您可以间接地这样做，通过生成一个新的函数或使用bytecodehacks。
例如：
def fib2(n):
f = sys._getframe()
fib2 = types.FunctionType(f.f_code, globals=globals())
return n if n<=1 else fib2(n-1)+fib2(n-2)
再次说明，这种方法不能处理所有的病态情况...但我能想到的唯一解决方法是实际上保留对帧的循环引用，或至少保留其全局变量（例如，通过传递 globals = f.f_globals），但这似乎是一个非常糟糕的主意。
请参见Frame Hacks以了解更多聪明的技巧。
最后，如果你愿意完全离开Python，你可以创建一个导入hook，它会预处理或编译你的代码，从Python自定义扩展中转换为纯Python和/或字节码。
如果你认为“但这听起来更像宏而不是预处理程序的黑客，如果只有Python有宏”......那么你可能更喜欢使用一个给Python提供宏的预处理程序黑客，比如MacroPy，然后将你的扩展编写为宏。
fib内部来看，没有什么可以反映的。但是，是的，从外部——例如，在装饰器中——您可以获得各种信息，例如函数中未绑定名称的列表。 （inspect模块文档在顶部显示了所有易于反射的内容的漂亮图表。）如果您愿意，您可以使用它来制作一个不需要添加显式self参数的装饰器，就像Abe Karplus的那样。 - abarnertsys._getframe(1)。请参阅Frame Hacks以了解一些可行的示例。 - abarnerttypes.FunctionTypes来构建一个新函数，该函数具有原始代码，但具有特殊的全局环境。给我一秒钟，我会详细说明。 - abarnert就像abamert说的"..没有从内部解决这个问题的方法。"
这是我的方法：
def fib(n):
def fib(n):
return n if n <= 1 else fib(n-1)+fib(n-2)
return fib(n)
有人向我询问基于宏的解决方案，所以这里提供一个：
# macropy/my_macro.py
from macropy.core.macros import *
macros = Macros()
@macros.decorator()
def recursive(tree, **kw):
tree.decorator_list = []
wrapper = FunctionDef(
name=tree.name,
args=tree.args,
body=[],
decorator_list=tree.decorator_list
)
return_call = Return(
Call(
func = Name(id=tree.name),
args = tree.args.args,
keywords = [],
starargs = tree.args.vararg,
kwargs = tree.args.kwarg
)
)
return_call = parse_stmt(unparse_ast(return_call))[0]
wrapper.body = [tree, return_call]
return wrapper
>>> import macropy.core.console
0=[]=====> MacroPy Enabled <=====[]=0
>>> from macropy.my_macro import macros, recursive
>>> @recursive
... def fib(n):
... return n if n <= 1 else fib(n-1)+fib(n-2)
...
>>> foo = fib
>>> fib = foo(10)
>>> x = foo(8)
>>> x
21
... 的 return fib(...)defreturn 语句一起放入新函数def的主体中parse_stmt(unparse_ast(return_call))[0] 的垃圾代码只是为了快速让东西工作（实际上，您无法仅从函数的参数列表中复制 argument AST 并在 Call AST 中使用它们），但这只是细节。print unparse_ast 语句来查看转换后的函数的样子：@macros.decorator()
def recursive(tree, **kw):
...
print unparse_ast(wrapper)
return wrapper
def fib(n):
def fib(n):
return (n if (n <= 1) else (fib((n - 1)) + fib((n - 2))))
return fib(n)
看起来正是你所需要的！它应该适用于任何带有多个参数、kwargs、默认值等的函数，但我懒得测试。使用AST有点繁琐，而MacroPy仍然是超级实验性的，但我认为它非常棒。
selfcaller适用于实际的fib函数，但 Y 组合子适用于返回fib函数的函数。绑定发生在创建函数的函数的形式参数中。这只是一个本地变量，没有理由将其作为参数。此外，内部函数没有必要是lambda而不是def- 在这种情况下，您已经拥有了本地名称。这意味着 Y 组合子没有添加任何内容；你所需要的装饰器只是调用创建函数的函数。这就是... 我的答案。 - abarnert(x,y) -> z等价于高阶函数x -> (y -> z)，因此selfcaller等同于Y组合子。 - Abe Karplusfib一样。 - abarnert