[已解决]关于递归的运算顺序

落月沉星

想把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=[1]，此时python会把list1=[1]作为一个常量代入aaa(12)中，完整的执行一遍aaa(12)，而不是直接向下执行外层的list1.append(12%10)，这是递归的计算规则吗？

最佳答案

月排行榜 / 总排行榜

永恒的蓝色梦想

2020-4-2 10:12:53

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

每次都重新定义

1. list1=[]

复制代码

，当然得不到结果

帮你改了一下：

1. def func(n):
   
2.     if n:
   
3.         temp=func(n//10)
   
4.         temp.append(n%10)
   
5.         return temp
   
6. 
   
7.     else:
   
8.         return []

复制代码

PS:循环的可以这么写

1. def func(n):
   
2.     res=[]
   
3.     while n:
   
4.         res.append(n%10)
   
5.         n//=10
   
6.     res.reverse()
   
7.     return res

复制代码

跳转到最佳答案楼层

BngThea

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

_2_

不用那么麻烦

1. [i for i in iter(str(12345))]

复制代码

_2_

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

_荟桐_

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

落月沉星

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

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

把上面的代码换一种角度看，把每一次递归的内容都展开，变成下面的样子，只是为了看着方便，当然下面的内容已经不是正常的代码了：
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=[1]，此时python会把list1=[1]作为一个常量代入aaa(12)中，完整的执行一遍aaa(12)，而不是直接向下执行外层的list1.append(12%10)，这是递归的计算规则吗？

落月沉星

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

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

落月沉星

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

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

落月沉星

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

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

永恒的蓝色梦想

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

每次都重新定义

1. list1=[]

复制代码

，当然得不到结果

帮你改了一下：

1. def func(n):
   
2.     if n:
   
3.         temp=func(n//10)
   
4.         temp.append(n%10)
   
5.         return temp
   
6. 
   
7.     else:
   
8.         return []

复制代码

PS:循环的可以这么写

1. def func(n):
   
2.     res=[]
   
3.     while n:
   
4.         res.append(n%10)
   
5.         n//=10
   
6.     res.reverse()
   
7.     return res

复制代码

落月沉星

永恒的蓝色梦想 发表于 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
                [1]
                2354043745152
            4
            []
            2354051179072
            5
            [2]
            2354051179072
        4
        []
        2354043738112
        5
        [3]
        2354043738112
    4
    []
    2354040733376
    5
    [4]
    2354040733376
4
[]
2354051086976
5
[5]
2354051086976
原来每一层出现过list=[]之后，都会定义一个新的，虽然名字相同但却已经不是同一个了，还是知识没学透啊

永恒的蓝色梦想

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

递归并不简单，努力学吧