论坛 › Python交流 › 关于递归的运算顺序

落月沉星 发表于 2020-4-1 19:00:05

关于递归的运算顺序

想把12345转换为列表，然后返回，代码如下：
def aaa(x):
    list1=[]
    if x>0:
      aaa(x//10)
      list1.append(x%10)      
aaa(12345)
print(list1)

把代码换一种角度看，变成这样：
def aaa(12345):
    list1=[]
    if 12345>0:
      def aaa(1234):
            list1=[]
            if x>0:
                def aaa(123):
                  list1=[]
                  if x>0:
                        def aaa(12):
                            list1=[]
                            if x>0:
                              def aaa(1):
                                    list1=[]
                                    if x>0:
                                        aaa(0)
                                        list1.append(1%10)                               
                              list1.append(12%10)                        
                        list1.append(123%10)               
                list1.append(1234%10)
      list1.append(12345%10)
aaa(12345)
print(list1)

黑体加粗部分def aaa(1)可以看做是递归最后一层，运行完之后得到list1=，此时python会把list1=作为一个常量代入aaa(12)中，完整的执行一遍aaa(12)，而不是直接向下执行外层的list1.append(12%10)，这是递归的计算规则吗？

BngThea 发表于 2020-4-1 19:14:56

你这不是递归，你这是闭包

_2_ 发表于 2020-4-1 19:33:57

本帖最后由 _2_ 于 2020-4-1 19:35 编辑

不用那么麻烦

_2_ 发表于 2020-4-1 19:39:42

再说了，你这个不是递归，递归是重复调用某一个函数，而不是你这样定义好几个函数然后逐个调用

_荟桐_ 发表于 2020-4-1 20:04:37

递归是在函数内调用函数本身
闭包是在函数内定义一个函数

落月沉星 发表于 2020-4-2 09:59:10

一开始没讲明白我的问题，有点误会，想把12345转换为列表，然后返回，代码如下：
def aaa(x):
    list1=[]
    if x>0:
      aaa(x//10)
      list1.append(x%10)      
aaa(12345)
print(list1)

这段代码将list1=[]放在函数里，最后的结果就只有一个，而把它放在定义函数的外面就会正常执行，所以想问问为什么现在的代码运行时，每次列表都会被重置

把上面的代码换一种角度看，把每一次递归的内容都展开，变成下面的样子，只是为了看着方便，当然下面的内容已经不是正常的代码了：
def aaa(12345):
    list1=[]
    if 12345>0:
      
            list1=[]   #aaa(1234)
            if x>0:
               
                  list1=[]   #aaa(123)
                  if x>0:
                        
                            list1=[]   #aaa(12)
                            if x>0:
                              
                                  list1=[]   #aaa(1)
                                    if x>0:
                                        aaa(0)
                                        list1.append(1%10)                               
                              list1.append(12%10)                        
                        list1.append(123%10)               
                list1.append(1234%10)
      list1.append(12345%10)
aaa(12345)
print(list1)

黑体加粗部分aaa(1)可以看做是递归最后一层，aaa(1)运行完之后得到list1=，此时python会把list1=作为一个常量代入aaa(12)中，完整的执行一遍aaa(12)，而不是直接向下执行外层的list1.append(12%10)，这是递归的计算规则吗？

落月沉星 发表于 2020-4-2 10:04:57

BngThea 发表于 2020-4-1 19:14
你这不是递归，你这是闭包

不好意思，我的问题一开始没讲明白，把第一段代码的递归部分展开后，就变成第二段的代码，它只是一个草稿图，不会用他来运行

落月沉星 发表于 2020-4-2 10:07:27

_2_ 发表于 2020-4-1 19:33
不用那么麻烦

刚刚学到递归，第二段代码只是想把原代码里递归的内容给展开，为了方便看

落月沉星 发表于 2020-4-2 10:09:10

_荟桐_ 发表于 2020-4-1 20:04
递归是在函数内调用函数本身
闭包是在函数内定义一个函数

第二段代码是我瞎写的，为了把原代码的递归部分展开，不是用来运行的，只是方便看，误会误会

永恒的蓝色梦想 发表于 2020-4-2 10:12:53

本帖最后由 永恒的蓝色梦想 于 2020-4-2 10:17 编辑

落月沉星 发表于 2020-4-2 09:59
一开始没讲明白我的问题，有点误会，想把12345转换为列表，然后返回，代码如下：
def aaa(x):
    list ...

每次都重新定义list1=[]，当然得不到结果

帮你改了一下：def func(n):
    if n:
      temp=func(n//10)
      temp.append(n%10)
      return temp

    else:
      return []

PS:循环的可以这么写def func(n):
    res=[]
    while n:
      res.append(n%10)
      n//=10
    res.reverse()
    return res

落月沉星 发表于 2020-4-2 10:39:04

永恒的蓝色梦想 发表于 2020-4-2 10:12
每次都重新定义，当然得不到结果

帮你改了一下：


你一说重新定义，让我有点想明白了，我把代码给改了一下，输出结果有点乱
def aaa(x):
    print(1)
    list1=[]
    print(id(list1))
    print(list1)
    print(2)
    print(list1)
    print(id(list1))
    if x>0:
      print(3)
      print(list1)
      print(id(list1))
      aaa(x//10)
      print(4)
      print(list1)
      print(id(list1))
      list1.append(x%10)
      print(5)
      print(list1)
      print(id(list1))
      
aaa(12345)
print(list1)

输出结果：
1
2354051086976
[]
2
[]
2354051086976
3
[]
2354051086976
    1
    2354040733376
    []
    2
    []
    2354040733376
    3
    []
    2354040733376
      1
      2354043738112
      []
      2
      []
      2354043738112
      3
      []
      2354043738112
            1
            2354051179072
            []
            2
            []
            2354051179072
            3
            []
            2354051179072
                1
                2354043745152
                []
                2
                []
                2354043745152
                3
                []
                2354043745152
                  1
                  2354043744576
                  []
                  2
                  []
                  2354043744576
                4
                []
                2354043745152
                5
               
                2354043745152
            4
            []
            2354051179072
            5
            
            2354051179072
      4
      []
      2354043738112
      5
      
      2354043738112
    4
    []
    2354040733376
    5
   
    2354040733376
4
[]
2354051086976
5

2354051086976
原来每一层出现过list=[]之后，都会定义一个新的，虽然名字相同但却已经不是同一个了，还是知识没学透啊

永恒的蓝色梦想 发表于 2020-4-2 10:52:31

落月沉星 发表于 2020-4-2 10:39
你一说重新定义，让我有点想明白了，我把代码给改了一下，输出结果有点乱
def aaa(x):
    print(1)


递归并不简单，努力学吧

查看完整版本: 关于递归的运算顺序