Python中的变量重新赋值——本体查询——使用牛顿法

Question

我正在阅读 Miller 和 Ranum 的关于使用 Python 的算法和数据结构的书。他们使用以下示例：

def squareroot(n):
    root = n/2
    for k in range(20):
        root = (1/2)*(root + n / root)

    return root 

我的问题是，变量 'root' 在 for 循环中被重新分配，因此每次迭代时，赋值运算符右侧的表达式中的 'root' 的值都会发生变化。我不确定我是否理解这怎么可能。

一旦进行函数调用，for 循环外的“root”变量（在第 2 行）的计算结果为一个值，然后由 for 循环块表达式中的“root”变量引用，允许表达式计算为单个值，该值在for循环块中重新分配给赋值运算符左侧的变量“root”。在下一次迭代开始时，'root' 不再是 n/2，而是 for 循环中的表达式计算的任何值。在这种情况下，变量“root”被重新分配了一个浮点值，因此不再是它最初定义的——一个使用“root”变量的表达式。

例如，如果我们使用函数调用 squareroot(9)，'root' 在第一次迭代后将保持 3.25 的值，因为 for 循环中的表达式计算为该值。一旦在 for 循环中为变量 'root' 重新分配了一个浮点值，最初定义为 'root' 的表达式就会被破坏。 'root' 已被重新定义为 3.25。在 for 循环中，'root' 不再指代表达式，而是指单个浮点值。然而，在这个例子中，for 循环中的“root”变量似乎在每次迭代之后都有两个含义：它既是浮点值又是表达式。我不明白这是怎么回事。

Answer 1

简短的回答是 Python 不会将表达式视为抽象公式；它将其视为要执行的一系列具体计算。每次循环时，它都会使用root 的当前值执行这些计算，然后使用结果更新root 的值。查看 Python 执行的实际操作序列可能会有所帮助，如下所示：

import dis
def squareroot(n):
    root = n/2
    for k in range(20):
        root = 0.5 * (root + n / root)
    return root
dis.dis(squareroot)

结果：

  2           0 LOAD_FAST                0 (n)
              3 LOAD_CONST               1 (2)
              6 BINARY_DIVIDE       
              7 STORE_FAST               1 (root)

  3          10 SETUP_LOOP              38 (to 51)
             13 LOAD_GLOBAL              0 (range)
             16 LOAD_CONST               2 (20)
             19 CALL_FUNCTION            1
             22 GET_ITER            
        >>   23 FOR_ITER                24 (to 50)
             26 STORE_FAST               2 (k)

  4          29 LOAD_CONST               3 (0.5)
             32 LOAD_FAST                1 (root)
             35 LOAD_FAST                0 (n)
             38 LOAD_FAST                1 (root)
             41 BINARY_DIVIDE       
             42 BINARY_ADD          
             43 BINARY_MULTIPLY     
             44 STORE_FAST               1 (root)
             47 JUMP_ABSOLUTE           23
        >>   50 POP_BLOCK           

  5     >>   51 LOAD_FAST                1 (root)
             54 RETURN_VALUE        

有趣的部分是以4 开头的块，它对应于您询问的作业。这就是发生的事情：

• 将以下内容加载到堆栈中：[0.5，root 的当前内容，n 的当前内容，root 的当前内容]。在第一次迭代期间（n=9），堆栈现在将保存 [0.5, 4.5, 9.0, 4.5]。
• 将堆栈中倒数第二项除以最后一项并将结果放入堆栈：堆栈现在为 [0.5, 4.5, 2.0]
• 将最后两项添加到堆栈中并将结果放入堆栈中：堆栈现在为 [0.5, 6.5]
• 将堆栈中的最后两项相乘，然后将结果放入堆栈：堆栈现在为 [3.25]
• 将堆栈中的最后一项 (3.25) 存储在变量 root 中。

因此，如您所见，表达式仅表示要遵循的一系列步骤。在这些步骤结束时，结果将存储到root。然后可以使用root 的新值再次执行这些步骤。