Python：递归函数中的变量绑定

我在Python中遇到了一些奇怪之处，使用了类似于以下的函数：

    def foo(x):
        if int(x)!=4:
            x = raw_input("Wrong guess, please enter new value: " )
            foo(x)
        else:
            print "Good Job! %s was right"%x
        return x

    value = foo(x=raw_input("Guess a Number between 1 and 10: "))
    print value

如果我输入，例如：“1”然后“2”然后“3”然后“4”，我会打印出以下内容：

Good Job! 4 was right
2

这是令人困惑的，因为函数似乎成功地识别了正确的答案，但在这样做之后，它返回的值是给定的第二个响应，而不是最近的响应

---

有人能解释一下这个递归函数中“x”的绑定是怎么回事吗？

所以这主要是因为在

def foo(x):
    if int(x)!=4:
        x = raw_input("Wrong guess, please enter new value: " )
        foo(x) # <-- need return
    else:
        print "Good Job! %s was right"%x
    return x

value = foo(x=raw_input("Guess a Number between 1 and 10: "))
print value

或

在我突出显示的那行

让我们看看

value = foo(raw_input())
# foo is the same as in the question, I won't repeat it here
print value

在您的foo中，您可以看到：

# foo(1) calls foo(2) and sets x to 2
# foo(2) calls foo(3) and sets x to 3
# foo(3) calls foo(4) and sets x to 4
# foo(4) does:
print "Good Job! 4 was right"
return 4 # to foo(3)
# foo(3) does:
return 4 # to foo(2)
# foo(2) does:
return 3 # to foo(1)
# foo(1) does:
return 2 # to main

因为main的返回值（从最外层的递归）是

2

，所以

value

仍然是这个值

要解决此问题，您可以使其迭代：

def iter_foo(x):
    while int(x) != 4:
        x = raw_input("Wrong guess. Try again! ")
    print "Good Job! %s was right" % x
    return x

或者让每个递归返回新函数的结果

def recurse_foo(x):
    if int(x) != 4:
        return foo(raw_input("Wrong guess. Try again! "))
    else:
        print "Good Job! %s was right!" % x
        return x

---

请尝试以下代码：

def foo(x):
    if int(x)!=4:
        x = raw_input("Wrong guess, please enter new value: " )
        return foo(x)
    else:
        print "Good Job! %s was right"%x
        return x

value = foo(x=raw_input("Guess a Number between 1 and 10: "))
print value

---

您可以认为对函数foo的每次调用都会创建一个新的变量x。因此，递归调用生成一系列变量x1、x2、x3等。因此，当函数调用返回时，局部变量x保持不变。这就是为什么您仍然得到2，而不是上一个递归调用（4）的赋值。如果要更改传递到函数中的变量，则需要通过引用（或对象）而不是通过值进行传递。[有关更多详细信息，请参阅本文：

相关：您可能应该提到，由于Python没有，在此处使用递归可能会导致堆栈溢出。在提供的两种解决方法中，接受这一点，并对foo（）的用法进行了很好的解释。）执行之间相互调用。其他答案也很有用，我现在了解了递归调用是如何工作的

def recurse_foo(x):
    if int(x) != 4:
        return foo(raw_input("Wrong guess. Try again! "))
    else:
        print "Good Job! %s was right!" % x
        return x

def foo(x):
    if int(x)!=4:
        x = raw_input("Wrong guess, please enter new value: " )
        return foo(x)
    else:
        print "Good Job! %s was right"%x
        return x

value = foo(x=raw_input("Guess a Number between 1 and 10: "))
print value