修改

Question

我正在阅读获得“逆转”徽章的答案，我发现了一个关于递归的问题，其中OP没有费心去完成他们的大部分家庭作业。除了一些非常有趣的答案之外，@ machielo在python中发布了an answer，我必须在我的机器上运行以获得控制权。我还是不理解它。

def recursive(x):
    if x > 10:
        print recursive(x/10)
    return x%10

>>> recursive(2678)
2
6
7
8

我尝试了我的第一个猜测，但我知道这是错误的

>>> 2678/10
267
>>> 267/10
26
>>> 26/10
2
>>> 2%10
2

好的......那是两个。这如何评估x中其他数字的输出？

修改

这是我没有到达的print声明。我修改了代码：

>>> def recursive(x):
if x > 10:
    print x
    print recursive(x/10)
return x%10

>>> #I will comment the interpreter session here...
>>> recursive(2345)
2345 # first feed in...print the raw number `x`
234  # 2345/10 does equal 234...the 5 is being held back somewhere...
23   # and each pass through the recursive loop removes the last digit...
2    # but where was it being stored at, so that each evaluation of
3    # x > 10 finally started returning False
4    # and returns the number, exiting the function
5    # ...

我在想，在每次试运行期间，对print recursive(x/10)的调用会创建一个新的功能对象，每个功能对象都有自己的全新基础案例和输入......

另一个提示，有人吗？

最后

感谢大家。我觉得我现在理解了这一点......诀窍并不像print那样x%10。 2345%10 == 5 ...

>>> def recursive(x):
print "Raw `x`:", x
if x > 10:
    print "Recurse `x`:", x
    print recursive(x/10)
print "Last `x`:", x    
return x%10

>>> recursive(2345)
Raw `x`: 2345
Recurse `x`: 2345
Raw `x`: 234
Recurse `x`: 234
Raw `x`: 23
Recurse `x`: 23
Raw `x`: 2
Last `x`: 2
2
Last `x`: 23
3
Last `x`: 234
4
Last `x`: 2345
5

另外，对于进入并更新了I previously linked to的初始答案的人来说，我很感激...我即将赞成你的评论：

>>> def recursive(x):
if x >= 10:
    print recursive(x/10)    
return x%10

Answer 1

我认为添加一些print语句非常有用：

def recursive(x):
  print '[start] recursive({0})'.format(x)
  if x > 10:
    print recursive(x/10)
  print '[return] recursive({0}) = {1}'.format(x, x%10)
  return x%10

print recursive(2678)

输出结果为：

[start] recursive(2678)
[start] recursive(267)
[start] recursive(26)
[start] recursive(2)
[return] recursive(2) = 2
2
[return] recursive(26) = 6
6
[return] recursive(267) = 7
7
[return] recursive(2678) = 8
8

Answer 2

单步执行伪代码示例（破折号表示递归深度）：

-call recursive(2678)
--2678 > 10, call recursive(267)
---267 > 10, call recursive(26)
----26 > 10, call recursive(2)
-----return 2%10 (which is 2)
----print 2, then return 26 % 10 (which is 6)
---print 6, then return 267 % 10 (which is 7)
--print 7, then return 2678 % 10 (which is 8)
-return 8

Answer 3

此功能打印出数字的数字。

它的工作原理如下：

def recursive(x):
  if x > 10:
    # Divide x by 10 and round down. This chops off the last decimal place.
    # Now feed that new x without the last decimal place back into recursive()

  # return x's last digit

基本上，在print是一位数字之前，它不会x。

您感到困惑的部分可能就是为什么它会按顺序打印出每个小数位。这是因为当函数递归时，父函数仍在运行。

尝试扩展该单个数字的代码。

编辑：我也很困惑。

您的代码在 print之前调用return ，这意味着当 last 级别的递归完成时，倒数第二次打印超出第一个数字。下一层也是如此。

Answer 4

在考虑递归时请记住调用堆栈。递归调用是在打印任何内容之前将所有recursive()函数调用推送到堆栈上，这样你最终得到的就是

recursive(2) # end condition is met so returns 2%10
recursive(26)
recursive(267)
recursive(2678) # the initial call

一旦达到结束条件2％10（2）返回到上一个函数的print语句并打印，那么该函数返回26％10（6），并且这一直持续到堆栈上的所有递归函数调用都有回。结果就是这一系列的打印电话：

print 2 
print 6
print 7
8

8实际上并未打印;它只是返回，从口译员可以很好。如果你想确保它打印在例如python脚本中，你可以调用print recursive(2678)

我不明白这种递归的使用

修改

最后

4 个答案: