首先是一个最简单的计算阶乘的递归函数：
def recuision(n):
if(n == 1):
return 1
else:
return n * recuision(n-1)
print(recuision(4))
运行结果：
但现在有可能，你需要对每次调用递归时的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)
运行结果：
比如这里的value：用来存储每次调用时的n的总和
li：列表用来存储每次调用时的n
这是设计递归程序，常用的一些手法，就是递归的过程中，对在外部定义的一些变量进行改变，用来记录某次特定的递归调用的状态。所以value和li就是我所说的外部变量。但这里必须有global这行代码，如果没有，将会有如下报错信息（因为如果没有使用global，且在函数内部对与外部变量同名的本地变量value执行+=，所以程序以为value是本地变量，但这个本地变量value还没有被赋值过，所以会报错）：
当地变量value还么有定义就开始引用。
运行结果为
因为在函数进行赋值语句了，程序就认为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)
运行结果：
当对外部的基本类型变量，只是引用，而没有改变其值时，不会报错。
不使用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)
运行结果：
当对外部的非基本类型变量，只是引用，而没有改变其值时，不会报错。
不使用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)
运行结果：
外部的非基本类型变量。其实，这里在递归中的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)
运行结果：
外部的非基本类型变量。可以发现，这里改变的是递归函数外部的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)
运行结果：
在递归函数中使用nonlocal：
在以上的递归函数，外部变量都是global的，要想改变其引用，必须使用global。但现在如果有一个需求，需要把这些递归函数的外部变量不放在global域中（其实放在global域就够用了，我就是想研究一下==），然后能够，让给函数传一个参数，返回递归运行后那些外部变量，这时就得用到nonlocal了。这样函数看起来就很好看，不需要在外部设置那么多变量了。
nonlocal的基本用法：
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()
运行结果：
def outer():
num = 10
def inner():
num = 100
print(num)
inner()
print(num)
outer()
运行结果：
如何在递归函数中使用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))
运行结果：
其实也就是
其递归过程形如（没有画完，反正就是这个意思啦）：
此递归程序，不需要设置递归的终点，因为二叉树的分支越来越少，到最后就没有分支了，递归也就到终点了。把上图的12345当成Ture，False的状态就行，有这个数，就代表这个数字上的位置为True，否则为False。
因为value，flag，result_flag，都是相对于递归函数的外部变量，但是这三个变量又都在te函数里，且刚好在recursion函数的外部，所以这里需要使用nonlocal。
以上这种递归程序的写法：在函数中定义真正的递归函数，然后在该函数中调用该递归函数。就可以达到，不需要定义全局变量，而且只给函数传一个参数，的效果。
引用变量赋值错误：
观察运行结果，返回的元祖，其中的result_flag应该为
就好比flag是一条狗绳，牵在第一条狗身上，result_flag是另一条狗绳，牵在第二条狗身上。考虑flag的变化，虽然此变量在递归过程中一直在变化，但是递归结束后，flag必定都是False，因为在递归中，开始时有
执行了result_flag = flag，那么就把result_flag这条狗绳，也牵在了第一条狗身上，那么第二条狗没人管了，也就跑了（被垃圾回收了），但实际上，程序想要的效果是，同时存在两条狗，且返回第二条狗，第一条狗只是作为一个变量在递归中使用。
所以需要进行如下修改：
if(flag == [True,True,False,False,False]):
for m in range(len(flag)):
result_flag[m] = flag[m]
运行结果：
此时，result_flag和flag，这两个引用实际指向的是，两个不同的变量。也就是，同时存在了两条狗。
或者重新构造一个新的list:
if(flag == [True,True,False,False,False]):
result_flag = [True,True,False,False,False]