python3:递归函数中使用global nonlocal

绝地灬酷狼 2022-05-23 06:41 235阅读 0赞

首先是一个最简单的计算阶乘的递归函数：

def recuision(n):
        if(n == 1):
            return 1
        else:
            return n * recuision(n-1)
    print(recuision(4))

运行结果：![70][]

但现在有可能，你需要对每次调用递归时的n，进行一些记录：

value = 0
    li = []
    
    def recuision(n):
        global value,li
        #记录数的总和
        value += n
        #列表记录有哪些数
        li.append(n)
        #或者改成这句li = [n],记录最后一次递归过程的数
        if(n == 1):
            return 1
        else:
            return n * recuision(n-1)
    print(recuision(4))
    
    print(value,li)

运行结果：![70 1][]

比如这里的value：用来存储每次调用时的n的总和

li：列表用来存储每次调用时的n

这是设计递归程序，常用的一些手法，就是递归的过程中，对在外部定义的一些变量进行改变，用来记录某次特定的递归调用的状态。所以value和li就是我所说的外部变量。但这里必须有global这行代码，如果没有，将会有如下报错信息（因为如果没有使用global，且在函数内部对与外部变量同名的本地变量value执行+=，所以程序以为value是本地变量，但这个本地变量value还没有被赋值过，所以会报错）：

![70 2][]

当地变量value还么有定义就开始引用。

![20180606211411917][]运行结果为![70 3][]

![70 4][]

运行结果为![70 5][]

因为在函数进行赋值语句了，程序就认为a为本地变量，但这句话又在print的后面，所以报错。

对于此错误UnboundLocalError的进一步理解：

不使用global，且当变量为基本类型时：

value = 0
    li = []
    def recuision(n):
        print('value=',value)
        if(n == 1):
            return 1
        else:
            return n * recuision(n-1)
    print(recuision(4))
    print(value,li)

运行结果：![70 6][]

当对外部的基本类型变量，只是引用，而没有改变其值时，不会报错。

不使用global，且当变量为非基本类型时：

value = 0
    li = [1,2,3]
    def recuision(n):
        print('li=',li)
        if(n == 1):
            return 1
        else:
            return n * recuision(n-1)
    print(recuision(4))
    print(value,li)

运行结果：![70 7][]

当对外部的非基本类型变量，只是引用，而没有改变其值时，不会报错。

不使用global，且当变量为非基本类型时，且改变其引用：

value = 0
    li = [4,5,6,7]
    def recuision(n):
        li = [1]
        print('li=',li)
        if(n == 1):
            return 1
        else:
            return n * recuision(n-1)
    print(recuision(4))
    print(value,li)

运行结果：![70 8][]

外部的非基本类型变量。其实，这里在递归中的li和外部的li，已经不是同一个变量了，在递归调用时，为递归函数本地创建了一个li变量。

不使用global，且当变量为非基本类型时（list），且改变其引用的引用（这里是list\[index\]）：

value = 0
    li = [4,5,6,7]
    def recuision(n):
        li[n-1] = [n]
        print('li=',li)
        if(n == 1):
            return 1
        else:
            return n * recuision(n-1)
    print(recuision(4))
    print(value,li)

运行结果：![70 9][]

外部的非基本类型变量。可以发现，这里改变的是递归函数外部的li变量，而且这里并没有创建出一个本地的li变量。

导入写好的递归模块：

递归模块（假设此模块名为test1）：

value = 0
    li = []
    def recuision(n):
        global value,li
        value += n
        li.append(n)
        if(n == 1):
            return 1
        else:
            return n * recuision(n-1)

主模块：

import test1
    
    print(test1.value)
    print(test1.li)
    print(test1.recuision(4))
    print(test1.value)
    print(test1.li)

运行结果：![70 10][]。一般写好的递归模块，就可以这么使用。

在递归函数中使用nonlocal：

在以上的递归函数，外部变量都是global的，要想改变其引用，必须使用global。但现在如果有一个需求，需要把这些递归函数的外部变量不放在global域中（其实放在global域就够用了，我就是想研究一下==），然后能够，让给函数传一个参数，返回递归运行后那些外部变量，这时就得用到nonlocal了。这样函数看起来就很好看，不需要在外部设置那么多变量了。

**当变量是基本类型时，使用这种外部变量（不是函数里传参数，而是不传这个参数，直接使用），分为两种情况：**

**1.如果只是使用其引用，那么能够得到其正确的值**

**2.如果是对其进行赋值行为，那么此时程序认为你是创建了一个与外部变量同名的内部变量，所以你实际是在操作一个内部变量，而这个内部变量如果引用前没有赋初值，程序就会报错**

**当变量是非基本类型（即可变对象）时，使用这种外部变量（不是函数里传参数，而是不传这个参数，直接使用），就只有一种情况：**

**1.你操作的一直是这个可变对象**

nonlocal的基本用法：

def outer():  
        num = 10  
        def inner():  
            nonlocal num   # nonlocal关键字声明  
            num = 100  
            print(num)  
        inner()  
        print(num)  
    outer()

运行结果：![70 11][]。两个num都是outer函数域里面的num，是同一个变量。

def outer():  
        num = 10  
        def inner():   
            num = 100  
            print(num)  
        inner()  
        print(num)  
    outer()

运行结果：![70 12][]。两个num不是同一个，outer有一个num变量，在inner的外部。inner也有个本地的num变量。

如何在递归函数中使用nonlocal：

def te(count):
        value = 0
        flag = [False]*count
        result_flag = [False]*count
    
        def recursion(i):
            nonlocal value,flag,result_flag
            value +=1
            flag[i] = True
            print(flag)
            if(flag == [True,True,False,False,False]):
                result_flag = flag
            for j in range(i+1,count):
                recursion(j)
            flag[i] = False
            
        for i in range(count):
            recursion(i)
    
        return (value,result_flag)
    
    
    print(te(5))

运行结果：![20180604131811699][]。可以看出来，递归一共调用31次。

其实也就是![20180604132240203][]。比如C51，就是，从5个里面选一个出来的情况，只有5种：1,2,3,4,5。

其递归过程形如（没有画完，反正就是这个意思啦）：

![20180604130849211][]

此递归程序，不需要设置递归的终点，因为二叉树的分支越来越少，到最后就没有分支了，递归也就到终点了。把上图的12345当成Ture，False的状态就行，有这个数，就代表这个数字上的位置为True，否则为False。

因为value，flag，result\_flag，都是相对于递归函数的外部变量，但是这三个变量又都在te函数里，且刚好在recursion函数的外部，所以这里需要使用nonlocal。

以上这种递归程序的写法：在函数中定义真正的递归函数，然后在该函数中调用该递归函数。就可以达到，不需要定义全局变量，而且只给函数传一个参数，的效果。

引用变量赋值错误：

观察运行结果，返回的元祖，其中的result\_flag应该为![70 13][]的，但是并没有，result\_flag的每个元素都是False。其实，这里是引用型变量赋值造成的：

就好比flag是一条狗绳，牵在第一条狗身上，result\_flag是另一条狗绳，牵在第二条狗身上。考虑flag的变化，虽然此变量在递归过程中一直在变化，但是递归结束后，flag必定都是False，因为在递归中，开始时有![70 14][]，结束时有![70 15][]，改变状态后，还会恢复状态。

执行了result\_flag = flag，那么就把result\_flag这条狗绳，也牵在了第一条狗身上，那么第二条狗没人管了，也就跑了（被垃圾回收了），但实际上，程序想要的效果是，同时存在两条狗，且返回第二条狗，第一条狗只是作为一个变量在递归中使用。

所以需要进行如下修改：

if(flag == [True,True,False,False,False]):
                for m in range(len(flag)):
                    result_flag[m] = flag[m]

运行结果：![70 16][]

此时，result\_flag和flag，这两个引用实际指向的是，两个不同的变量。也就是，同时存在了两条狗。

或者重新构造一个新的list:

if(flag == [True,True,False,False,False]):
                result_flag = [True,True,False,False,False]

[70]: /images/20220523/dbf9a7651c594523b497252fd09e6e02.png
[70 1]: /images/20220523/59446ec1b8164defbc3199860bb0f88c.png
[70 2]: /images/20220523/dca8441c95bc4246ad27a9e067051fae.png
[20180606211411917]: https://img-blog.csdn.net/20180606211411917
[70 3]: /images/20220523/6f77b9c4a60442089a32c4575607f294.png
[70 4]: /images/20220523/a490d390cdb74924b250d92b8c5826fd.png
[70 5]: /images/20220523/0bd5885a5d784e6a972870c67184ba48.png
[70 6]: /images/20220523/30cae3fc0dab489dbdc27cf4eaf02c5a.png
[70 7]: /images/20220523/b7f23d046deb4852adefb1065fbd3fea.png
[70 8]: /images/20220523/a144aae1b79748c09c89bd57b01a2078.png
[70 9]: /images/20220523/eb7374b8ae944e979619be0a7af2acc7.png
[70 10]: /images/20220523/4f3d452209ab4c1f8ccaac760becc3b2.png
[70 11]: /images/20220523/466e6a464c36442693fbe84d1db6daec.png
[70 12]: /images/20220523/931cbfcca3d04e2abba34a27365f44f9.png
[20180604131811699]: /images/20220523/6c02e360657644ecb60a57b75bb20904.png
[20180604132240203]: /images/20220523/21b81d20afde4419850870970d89df1c.png
[20180604130849211]: /images/20220523/a1258cd2109646c6a0f7521199639e0b.png
[70 13]: /images/20220523/0efd480f370e4dba9c5b6815b01fa1d5.png
[70 14]: https://img-blog.csdn.net/20180604133750954?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 15]: /images/20220523/2ede3c83b06148b7bbc1ed1299ca4afc.png
[70 16]: /images/20220523/a97a84d2ff19479faa7c7977aa2b0f5a.png