Python 函数跟踪

Question

为了让递归的过程更加直观，给出这个例子给出：

def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)

def trace(f):
    f.indent = 0
    def g(x):
        print('|  ' * f.indent + '|--', f.__name__, x)
        f.indent += 1
        value = f(x)
        print('|  ' * f.indent + '|--', 'return', repr(value))
        f.indent -= 1
        return value
    return g


fib = trace(fib)
print(fib(4))

我可以理解“什么” “跟踪功能可以，但我不明白“如何”。具体来说：

1）为什么我们有 f.indent 而不是简单的 indent = 0 （嗯，我发现这不起作用，但我不明白为什么）。

2）我不明白如何

print('|  ' * f.indent + '|--', 'return', repr(value))

在找到值之前不执行。

有好心人能彻底解释一下整个事情吗？

Answer 1

如果您将缩进级别存储在 indent 中，那么它将是当前函数调用的本地缩进级别。每次调用函数时，您都会得到一个新变量，其值为 0。通过将其存储在函数对象中，每次函数调用都会相同（函数在 python 中也是对象）。

对于第二部分，我不太确定你在问什么。每当参数大于 1 时，就会对 fib 进行两次新调用，因此不会返回任何值。直到参数等于 1 或 0 为止，才会进行返回调用。

Answer 2

呼。好吧，我们开始吧！

首先，你有一个函数，任何函数。在你的例子中，那就是fib()。现在，在Python中，函数也是对象，它们可以在运行时创建，所以我们实际上可以这样做：（

def give_me_a_function():
    def f(x):
        return x

    return f

警告：在这个答案的其余部分中可怕地重复“函数”这个词）。

好吧，我们定义了一个不带参数并返回的函数，...另一个函数？这是正确的！函数就是对象！您可以在运行时创建它们！因此，我们在原始函数中定义了第二个函数，然后返回它，就像我们返回任何其他对象一样。

现在，让我们做一些更复杂的事情：

def alter(other_function):
    def altered(x):
        return other_function(x) + 1

    return altered

那到底是什么？

好吧，我们定义了一个函数，alter()。就像上面的例子一样，它在运行时创建一个函数并返回它，因为它是对象。我们已经介绍了这么多。

现在，如果函数是对象，并且可以创建和返回，为什么不能将其作为参数传递呢？当你在做的时候就打电话吧！没错：alter() 将函数作为参数 (*)，并使用它。

alter() 所需要做的就是将上述魔法与这个新魔法结合起来：我们接收一个函数作为参数，动态创建另一个使用它的函数，然后返回这个新函数-目的！

我们来试试吧。

>>> def f(x):
...     return 2*x
>>> new_function = alter(f)
>>> f(2)
4
>>> new_function(2)
5

就这样！ alter() 接受我的 f()，创建一个将返回 f() + 1 的新函数，并将其作为返回值。我将其分配给 new_function，并且我有一个新的、自制的、运行时创建的函数。

（我确实警告过您有关“函数”一词的使用，不是吗？）

现在，看您的代码。您正在做的事情比 f() + 1 更复杂。或不？好吧，您正在创建一个新函数，它接受原始函数，调用它，并打印一些数据。这并不比我们刚才所做的更神奇。最大的区别在哪里？

嗯，有一个细节：fib() 是递归的，所以它会调用自身，对吧？没有！不是本身。它调用 fib()，而您碰巧执行了以下操作：

fib = trace(fib)

WHAM。 fib() 不再是它本身了！ 现在 fib() 是 trace(fib)！因此，当 fib() 进入递归时，它不会调用自身，而是调用我们创建的自身的包装版本。

这就是为什么要这样处理缩进。再看看 trace()，现在知道它实际上是递归缩进，而且这是有道理的，不是吗？您希望每一级递归都有一个缩进，因此增加它，调用 fib() （请记住，现在是 trace(fib)），然后当我们回来了（所以递归来了又来，我们即将返回到调用链中的上一步）我们将其递减。

如果您仍然看不到它，请尝试将所有功能移至 fib()。忘记装饰功能，这很令人困惑。

啊。我真的希望这对你有所帮助，并且 2000 个人比我先找到答案并没有让这个问题变得过时。

干杯!

(*) 是的，是的，鸭子输入 yadda yadda 可调用对象 bla bla 不相关。

Answer 3

1. 如果我们只使用 indent 而不是 f.indent，它将成为内部函数 g()内的局部变量 code>，由于在 g() 中对 indent 进行了赋值。由于这似乎是 Python 3，因此实际上没有必要使用函数属性 - 您还可以使用 nonlocal 关键字：

   def 跟踪(f)：
       缩进=0
       定义 g(x):
           非局部缩进
           print('| ' * 缩进 + '|--', f.__name__, x)
           缩进 += 1
           值 = f(x)
           print('| ' * 缩进 + '|--', 'return', repr(value))
           缩进 -= 1
           返回值
       返回g
   

2. 第二个 print()在至少一次 f() 调用返回之前，不会到达调用。它出现在调用 f() 之后的代码中，因此执行流程只有在 f() 返回后才会到达那里。