一、定义

函数是将可以被反复使用的、用在实现单一或相关联功能的代码封装或组织在一起，形成一个独立的程序单位，并为该程序单位定义一个相应的名称，这样的程序单位称为函数，该名称为函数名。
为了更好的管理大规模且反复被重用的大段代码，Python引入了模块的概念，将大段程序或多个函数段封装成一个文件，可以反复使用，进一步提出了包的概念。

1.1 定义

定义语法
def <函数名> ([参数列表]):
<函数体>
def 关键字用来定义函数
函数名 由用户定义的任意有效的标识符
函数名 后面的圆括号必须有，其中参数列表中的参数由变量充当，可以有多个参数，参数之间用逗号分割。
函数定义的时候，括号后面的冒号（:）必不可少，函数体是至少一句语言的代码块。
在主程序中直接通过函数名嗲用函数，函数名后面的也必须有括号，调用函数的过程就是执行函数中语句的过程

def my_len():                  ##定义函数
    s = 'hello world'
    length = 0
    for i in s:
        length = length + 1
    print(length)
my_len()                          ##调用函数

1.2 函数名的本质

函数名本质上就是函数的内存地址

func() # 函数名就是内存地址
func2 = func  #  函数名可以赋值
func2()
l = [func,func2] # 函数名可以作为容器类型的元素
 print(l)
 for i in l:
     i()
 def func():
     print(123)
 def wahaha(f):
     f()
        return f           #函数名可以作为函数的返回值
 ret = wahaha(func)        # 函数名可以作为函数的参数
 ret()

二、函数的调用

格式：
<函数名>(<参数列表>)
函数名为前面def语句定义的函数，参数列表中的参数必须有确定的值，为实参，实参可以由多个参数组成，中间用逗号分割。
调用函数的方式：
1.直接调用函数名，将函数语句完整执行一遍，调用程序往往不需要函数的返回值
2.函数作为表达式的一部分出现，调用程序将使用函数的返回值，并参与表达式的数据计算
3.函数被嵌套在另一个函数中，函数的返回值被当作另外函数的实参使用。

##求阶乘的函数
def jiechen(x):
    n = 1
    for i in  range(1,1+x):
        n = n * i
    return n
y = int(input("输入一个整数： "))
if y < 0:
    print("error")
else:
    print('y的阶乘：',jiechen(y))
##结果
输入一个整数： 5
y的阶乘： 120

三、 参数

3.1 参数传递的方式

当Python中的主程序调用函数的时候，实参的值传递给形参，实际上是将实参所指向的对象的地址传递给了形参。
如果传递的对象是不可变对象（eg：数值、字符、元组等），在函数体中形参值的变化不会影响到实参。
如果传递的对象是可变对象（eg：列表、字典等），在函数中形参值得变化会影响到实参。

##传递不可变对象，形参的变化不会影响到实参
def add(x):
    print("形参x的初始值为：",x)
    x+=1
    print("形参x的变化后的值为：",x)
y = 4
add(y)
print('实参y的值为：',y)
##结果
形参x的初始值为： 4
形参x的变化后的值为： 5
实参y的值为： 4
##传递可变对象，形参得变化会影响到实参
def change(x):
    print("形参x的初始值为：",x)
    x.append(3)
    print("形参x的变化后的值为：",x)
y = [4]
change(y)
print('实参y的值为：',y)
##结果
形参x的初始值为： [4]
形参x的变化后的值为： [4, 3]
实参y的值为： [4, 3]
def change(x):
    print("形参x的初始值为：",x)
    x.clear()
    print("形参x的变化后的值为：",x)
y = {4:5}
change(y)
print('实参y的值为：',y)
##结果
形参x的初始值为： {4: 5}
形参x的变化后的值为： {}
实参y的值为： {}

3.2 形参和实参

3.2.1 形参

在函数定义的时候出现的参数，可以看作是一个占位符，它没有数据，只能等到函数被调用的时候接收传递进来的数据，被称为形式参数。
形参出现在函数的定义中，在整个函数体中都可以使用，离开该函数就不可使用

3.2.2 实参

函数被调用的时候给出的参数，包含实实在在的数据，会被函数内部的代码使用，被称为实际参数。

在调用函数的时候，实参的值必须是确定的，该值将以参数传递的形式传递给函数中的形参。

3.2.3 实参和形参的特点

1.形参变量只有在函数被调用的时候才会分配内存，调用结束的时候立刻释放内存，所以形参只有在函数内部有效，不能再函数外部使用
2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的数据，在进行函数调用的时候，都必须由确定的值，以便把这些值传递给形参，需要提前用赋值、输入等办法使实参获得确定值。
3.实参和形参在数量上、类型上、顺序上必须严格一致，否则会发生“类型不匹配”的错误。
4.函数调用中发生的数据传递时单向的，只能把实参的值传递给形参，不能把形参的值反向传递给实参。在函数调用的过程中，形参值发生改变的时候，实参的值不会发生改变。

3.3 位置参数和关键字参数

3.3.1 位置参数

Python中要求调用函数时参数的个数、位置和顺序要与函数定义中的形参一致，这种参数被称为位置参数。
位置参数也叫必须参数，要求用户必须以正确的顺序传入函数。
如果实参的个数和形参的个数不一致的时候，就会报错

def posi_args(a,b):
    print("第一个参数：",a)
    print("第二个参数: ",b)
posi_args(100,200)
posi_args(200,100)
##结果
第一个参数： 100
第二个参数:  200
第一个参数： 200
第二个参数:  100
def posi_args(a,b):
    print("第一个参数：",a)
    print("第二个参数: ",b)
posi_args(100)
posi_args(200,100)
##结果，报错
    posi_args(100)
TypeError: posi_args() missing 1 required positional argument: 'b'

3.3.2 关键字参数

在调用函数的时候，可以明确指定参数值传递给哪个形参，这样的参数被称为关键字参数。
在设置函数的参数的时候，可以不按照它们的位置排列顺序，Python解释器可以用参数名进行匹配。
但是，实参和形参的数量还是要保持一致，否则就会报错。

def posi_args(a,b):
    print("传递给a的值为：",a,"传递给b的值为: ",b)
posi_args(a=100,b=200)
posi_args(b=200,a=100)
##结果
传递给a的值为： 100 传递给b的值为:  200
传递给a的值为： 100 传递给b的值为:  200
def posi_args(a,b):
    print("传递给a的值为：",a,"传递给b的值为: ",b)
posi_args(a=100,b=200)
posi_args(b=200)
##结果，实参和形参的数目不一致，会报错
传递给a的值为： 100 传递给b的值为:  200
  File "D:/pythontest/geshu.py", line 482, in <module>
    posi_args(b=200)
TypeError: posi_args() missing 1 required positional argument: 'a'

用户可以将位置参数与关键字参数混合使用，但必须将位置参数放在关键字参数的前面。

def posi_args(a,b):
    print("传递给a的值为：",a,"传递给b的值为: ",b)
posi_args(100,b=200)
##结果
传递给a的值为： 100 传递给b的值为:  200
##位置参数放在关键字参数后面会报错
def posi_args(a,b):
    print("传递给a的值为：",a,"传递给b的值为: ",b)
posi_args(a=100,200)
##结果
    posi_args(a=100,200)
                   ^
SyntaxError: positional argument follows keyword argument

3.4 默认值参数

在有些特殊情况下，实参也可以少于形参，eg：设置了默认值参数。
Python允许在创建函数的时候为形参指定默认值。
调用函数的时候，如果没有传递参数，则会使用默认参数值，也可以通过显式赋值方式改变默认值。
指定了默认值的形参也被称为可选参数，没有指定默认值的形参被称为必选参数。
带有默认值的参数的函数定义：
def <函数名>(……<形参=默认值>……）
<函数体>
在定义函数的时候，必须保证位置参数在前，默认值参数在后。
默认值参数必须指向不可变对象，可变对象不能作为默认值参数的值，不可将列表作为参数的默认值。

  def power(x,n=2):
    s=1
    for i in  range(1,n+1):
        s = s*x
    return s
print(power(5))    ## 形参n为默认值5
print(power(2,5))  ## 改变默认值n为5
##结果
25
32
##多个默认参数同时使用
def add_three(x,y=3,z=5):
    s=x+y+z
    print(s)
add_three(5)
add_three(1,2,3)
##结果
13
6

3.5 可变参数

在Python中，可以定义可变参数，不事先指定参数的数量，调用函数的时候，可变参数可以接收任意多个参数。

3.5.1 单星号参数 *

通过带星号（*）的参数定义接收可变数量的参数，可变参数在函数调用的时候自动组装为一个元组。

def sq_sum(*number):
    print(type(number))
    print("可变参数 number的值为：",number)
    sum = 0
    for i in number:
        sum = sum + i * i
    print("平方和为：",sum)
    return sum
sq_sum(1,2,3)
sq_sum(2)
sq_sum()
##结果
<class 'tuple'>
可变参数 number的值为： (1, 2, 3)
平方和为： 14
<class 'tuple'>
可变参数 number的值为： (2,)
平方和为： 4
<class 'tuple'>
可变参数 number的值为： ()
平方和为： 0

3.5.2 双星号参数 **

通过带双星号（）的参数定义接收可变数量的参数，可变参数在函数调用的时候自动组装为一个字典。
如果一个函数定义中的最后一个形参有双星号（）前缀，所有正常参数之外的其他关键字参数都将被放置在一个字典中传递该参数。

def school(x,**y):
    print(type(y))
    print("y的值",y)
    print(type(x))
    print("x的值",x)
    for i in y:
        print(i+":"+str(y[i]))
school("abc",a="lhuan",b="lars",c="mj")
school("def",a="lll",b="daidai",c="ccy",d="gyon")
##结果
<class 'dict'>
y的值 {'a': 'lhuan', 'b': 'lars', 'c': 'mj'}
<class 'str'>
x的值 abc
a:lhuan
b:lars
c:mj
<class 'dict'>
y的值 {'a': 'lll', 'b': 'daidai', 'c': 'ccy', 'd': 'gyon'}
<class 'str'>
x的值 def
a:lll
b:daidai
c:ccy
d:gyon

当参数本身就是一个序列（元组、列表、字典、集合）的时候

def sq_sum(*number):
    print(type(number))
    print("可变参数 number的值为：",number)
    sum = 0
    for i in number:
        sum = sum + i * i
    print("平方和为：",sum)
    return sum 
nums=[1,2,3]           ##参数本身就是列表
sq_sum(nums)
##结果会报错
  File "D:/pythontest/geshu.py", line 532, in <module>
    sq_sum(nums)
  File "D:/pythontest/geshu.py", line 528, in sq_sum
    sum = sum + i * i
TypeError: can't multiply sequence by non-int of type 'list'
 def sq_sum(*number):
    print(type(number))
    print("可变参数 number的值为：",number)
    sum = 0
    for i in number:
        sum = sum + i * i
    print("平方和为：",sum)
    return sum
nums=[1,2,3]
sq_sum(nums[0],nums[1],nums[2])      ##这个列表的值，在函数内部将这三个值组装成一个元组
##结果
<class 'tuple'>
可变参数 number的值为： (1, 2, 3)
平方和为： 14

3.5.3 参数传递时的序列解包

对于序列类型的实参，可以在前面添加一个星号（*），将实参的序列进行解包，然后在调用函数的时候传递给可变参数。
如果不将实参进行序列解包而直接传递，实参和形参个数不相等，程序将会出错。

##序列解包后传递给可变参数
def sq_sum(*number):
    print(type(number))
    print("可变参数 number的值为：",number)
    sum = 0
    for i in number:
        sum = sum + i * i
    print("平方和为：",sum)
    return sum
nums=[1,2,3]
sq_sum(*nums)
##结果
<class 'tuple'>
可变参数 number的值为： (1, 2, 3)
平方和为： 14
##序列解包后传递给多个普通参数
def add_three(x,y,z):
    s=x+y+z
    print(s)
list=[1,2,3]
add_three(*list)
tup=(1,2,3)
add_three(*tup)
dic={1:'x',2:'y',3:'z'}
add_three(*dic)
set=(1,2,3)
add_three(*set)
##结果
6
6
6
6

四、 函数的返回值

返回值是指函数返回给主调用程序的结果，通过函数中的关键字return实现，return后面的值就是函数的返回值。
不带参数值的return语句，返回None。
return <表达式列表>
return后面可以返回多个表达式的值，执行完return语句后函数结束。

def cal(x,y):
    s = x+y
    a = x*y
    p = x**y
    return s,a,p
print(cal(5,6))
##结果
(11, 30, 15625)
函数内部没有输出语句，调用函数的时候必须使用print语句才能输出函数的返回值

五、 变量的作用域

变量的作用域指变量的作用范围，作用域不相同，即使变量名相同，变量之间也不相互影响。
根据变量作用域的不同，可以将变量分为全局变量（Global variales）和局部变量（Local variales）。
全局变量的作用域是整个程序，这种变量在整个程序范围内都可以被引用。
局部变量定义在函数体内部，作用域只是在函数体内，只能在函数内被引用，一旦程序执行离开函数，变量将失效，不可引用。

5.1 全局变量

1.在主程序中定义的变量是全局变量，在主程序中出现在赋值语句等等号左侧的变量是全局变量
2.用global声明的变量是全局变量，global语句可以声明多个变量为全局变量，变量中间用逗号（,）隔开
3.没有用global语句声明，但出现在函数内赋值号右侧且不是函数参数的变量是全局变量，或者说，如果在函数体内只是引用了某个变量的值而没有为其赋新值，则该变量是全局变量

5.2 局部变量

1.函数的行输参数是局部变量
2.在函数体内部赋值号左侧出现的变量是局部变量，作用域在该函数体内部，或者说只要子啊函数体内部有为变量赋值的操作，该变量即为局部变量。

x = 100           ##全局变量
def changex():
    x=200         ##局部变量
    return  x
print(x)
print(changex())
x = 100
def changex():
    global x        ##声明全局变量
    x=200
    return  x
print(x)
print(changex())
print(x)

5.3 global

1. 声明一个全局变量。
2. 在局部作用域想要对全局作用域的全局变量进行修改时，需要用到 global(限于字符串，数字)。

对可变数据类型（list，dict，set）可以直接引用不用通过global

globals() 函数返回一个全局变量的字典，包括所有导入的变量。
locals() 返回字典类型的局部变量**

5.4 nonlocal

1. 不能修改全局变量。
2. 在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，并且引用的哪层，从那层及以下此变量全部发生改变。
3. nonlocal 只能用于局部变量 找上层中离当前函数最近一层的局部变量

4. 声明了nonlocal的内部函数的变量修改会影响到 离当前函数最近一层的局部变量

   对全局无效
   对局部 也只是对 最近的 一层 有影响

#例子1
a = 1
def outer():    #声明了global后只修改全局变量不会修改局部变量
    a = 1
    def inner():
        b =2
        print(a,'inner')
        def inner2():
            global a
            a += 1
            print('###',a)
        inner2()
    inner()
outer()
print('全局',a)
例子2
a = 1
def outer():
    a = 1
    def inner():
        a = 2
        def inner2():
            nonlocal a  #声明了一个上面第一层局部变量
            a += 1   #不可变数据类型的修改
        inner2()
        print('##a## : ', a)
    inner()
    print('**a** : ',a)
outer()
print('全局 ：',a)
例子3
a = 0
def outer():
    a = 1
    def inner():
        a = 2
        def inner2():
            nonlocal a
            print(a)
        inner2()
    inner()
outer()
print('全局',a)

a=2
def out():
    a=2
    def in1():
       a = 4
       def in2():
           nonlocal a
           a += 3
       in2()
       print("ccc",a)
    in1()
    print("111",a)
out()
print("ddd",a)

ccc 7
111 2
ddd 2

ps:对于不可变数据类型 在局部可是查看全局作用域中的变量
但是不能直接修改
如果想要修改，需要在程序的一开始添加global声明
如果在一个局部（函数）内声明了一个global变量，那么这个变量在局部的所有操作将对全局的变量有效

5.函数的嵌套和作用域链

函数的嵌套调用
内部函数可以使用外部函数的变量

def max(a,b):
    return a if a>b else b
def the_max(x,y,z):  #函数的嵌套调用
    c = max(x,y)
    return max(c,z)
print(the_max(1,2,3))
def outer():
    def inner():
        print('in inner')
    inner() #不加这一句就无法使用
outer()
def outer():
    a = 1
    def inner():
        print(a)
        print('in inner')
    inner()#不加这一句就无法使用
outer()

作用域链
在内部函数使用变量的时候，是从小局部到大局部到全局到内置的过程，一级一级往上找，找到最近的一个就使用

def f():
   a = 1
    def f1():
         print(a)
    f1()
 f()
def f():
    a = 1
    def f1():
        def f2():
            print(a)
        f2()
    f1()
f()
def f():
    a = 1
    def f1():
        a = 3
        def f2():
            print(a)
        f2()
    f1()
f()

6.函名的本质

函数名本质上就是函数的内存地址

func() # 函数名就是内存地址
func2 = func  #  函数名可以赋值
func2()
l = [func,func2] # 函数名可以作为容器类型的元素
 print(l)
 for i in l:
     i()
 def func():
     print(123)
 def wahaha(f):
     f()
        return f           #函数名可以作为函数的返回值
 ret = wahaha(func)        # 函数名可以作为函数的参数
 ret()

7.闭包

嵌套函数，内部函数调用外部函数的变量
优点：
方便外部调用
内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。
闭包找到的是同一地址中父级函数中对应变量最终的值
内部函数总是可以访问其所在的外部函数中声明的变量和参数，即使在外部函数被返回（寿命终结）之后

特点：

1.让外部访问函数内部变量成为可能
2.局部变量会常驻在内存中
3.可以避免使用全局变量，防止全局变量被污染
4.会造成内存泄漏，有一块内存空间被长期占用，不被释放。每次外部函数执行的时候，外部函数的引用地址不同，都会重新创建一个新的地址。

判断闭包函数的方法

closure
**

print(outer.__closure__)
def func():
    name = 'aaron'
    def inner():
        print(name)
    print(inner.__closure__)
    return inner
f = func()
f()
# 最后运行的结果里面有cell就是闭包
name = 'aaron'
def func():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner
f = func()
f()

常用应用闭包的方式
虽然a不是全局变量 但是当inn想使用就可以一直使用，延长变量a的使用周期，也保护了内部变量

def outer():
    a = 1
    def inner():
        print(a)
    return inner     ## 一定要return
inn = outer()
inn()

闭包的应用

import urllib  #模块   闭包的应用from urllib.request import urlopen
ret = urlopen('https://bing.ioliu.cn/').read()
print(ret)
def get_url():
    url = 'https://bing.ioliu.cn/'    
    ret = urlopen(url).read()
    print(ret)
get_url()
def get_url():
    url = 'https://bing.ioliu.cn/'   
    def get():
        ret = urlopen(url).read()
        print(ret)
    return get
get_func = get_url()
get_func()

• 
  

  六、 函数内置属性和命名空间

  6.1 函数的内置属性

  函数有很多内置属性，使用dir(函数名称)，就可以显示这些内置属性。 ```python def L_huan(): return 0 print(dir(L_huan()))

结果

[‘abs‘, ‘add‘, ‘and‘, ‘bool‘, ‘ceil‘, ‘class‘, ‘delattr‘, ‘dir‘, ‘divmod‘, ‘doc‘, ‘eq‘, ‘float‘, ‘floor‘, ‘floordiv‘, ‘format‘, ‘ge‘, ‘getattribute‘, ‘getnewargs‘, ‘gt‘, ‘hash‘, ‘index‘, ‘init‘, ‘init_subclass‘, ‘int‘, ‘invert‘, ‘le‘, ‘lshift‘, ‘lt‘, ‘mod‘, ‘mul‘, ‘ne‘, ‘neg‘, ‘new‘, ‘or‘, ‘pos‘, ‘pow‘, ‘radd‘, ‘rand‘, ‘rdivmod‘, ‘reduce‘, ‘reduce_ex‘, ‘repr‘, ‘rfloordiv‘, ‘rlshift‘, ‘rmod‘, ‘rmul‘, ‘ror‘, ‘round‘, ‘rpow‘, ‘rrshift‘, ‘rshift‘, ‘rsub‘, ‘rtruediv‘, ‘rxor‘, ‘setattr‘, ‘sizeof‘, ‘str‘, ‘sub‘, ‘subclasshook‘, ‘truediv‘, ‘trunc‘, ‘xor‘, ‘bit_length’, ‘conjugate’, ‘denominator’, ‘from_bytes’, ‘imag’, ‘numerator’, ‘real’, ‘to_bytes’]

查看函数的命名空间

def Lhuan(): return 0 print(Lhuan.__dict)

结果

{}

查看函数的文件字符串

def Lhuan(x,y): “return x+y” return x+y print(Lhuan.__doc)

结果

return x+y

查看该函数的名称

def Lhuan(x,y): “return x+y” return x+y print(Lhuan.__name)

结果

L_huan

<a name="1oupP"></a>
### 6.2 函数的命名空间
<a name="QYMvc"></a>
#### 6.2.1  介绍
Python使用动态命名空间。<br />每一个函数、模块与类创建的时候，都会定义其自己的命名空间。<br />代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；<br />在函数的运行中开辟的临时的空间叫做局部命名空间。
<a name="qPLqv"></a>
#### 6.2.2  分类
命名空间一共分为三种：
- 全局命名空间 （global namespace）：写在函数外面的变量名，位于模块的最上层
- 局部命名空间（local namespace）：每一个函数都拥有自己的命名空间
- 内置命名空间（bulit-in namespace）：Python解释器提供的，启动之后就可以使用的名字，int、string、def、print等。
<a name="7nHcs"></a>
#### 6.2.3  取值顺序
- 在局部调用：局部命名空间->全局命名空间->内置命名空间
- 在全局调用：全局命名空间->内置命名空间
当用户在Python解释器中输入一个指令或语句的时候，Python会**先**搜索**局部命名空间**，**然后**搜索**全局命名空间**。
<a name="jFUeT"></a>
#### 6.2.4  加载顺序
           内置命名空间（程序运行前加载）---->全局命名空间（程序运行中：从上到下加载）-------->局部命名空间（程序运行中：调用时才加载，函数调用结束后消失）
<a name="sflmw"></a>
## 七、 函数的嵌套
<a name="00MAO"></a>
### 7.1 函数嵌套的定义
Python支持嵌套函数，即在函数定义的时候，函数体内部又包含另外一个函数的完整定义，并且可以多层嵌套。<br />被定义在其他函数体内部的函数被称为内部函数，内部函数所在的函数称为外部函数。
```python
def First():            ##定义First()函数
    a=3
    def Score():        ##定义内部函数Score()函数             
        b=4
        print(a+b)
    Score()             ##在First中调用Score函数
    print(a)
First()                 ##调用First函数      
##结果
7
3

7.2 lambda函数

lamdba函数又被称为匿名函数，代表临时使用的简单小函数。
<函数名>=lambda<参数列表>:<表达式>
参数列表即lambda函数包含的形式参数列表
通过对表达式的计算，将函数的返回结果赋值给函数名
lambda相当于下面的
def <函数名>(参数列表):
retrun<表达式>

lambda函数中的表达式只能为单个表达式，不允许包含复杂语句，但在表达式中可以包含函数，并支持默认值参数和关键字参数，表达式的计算结果相当于普通函数的返回值。不能有return。

f = lambda x,y,z:x+y+z
print(f(10,20,30))
##结果
60
f = lambda x,y=3,z=5:x+y+z
print(f(10))
##结果
18
f = lambda x,y=3,z=5:x+y+z
print(f(10,z=55,y=88))
##结果
153

7.3 偏函数

Partial function，通过设置参数的默认值，可以降低函数调用的难度。

from functools import  partial
int2= partial(int,base=2)   ##base参数用于进制转换，省略的话，默认为10进制
print(int2('110000'))
print(int2('11001100'))
##结果
48
204

functools.partial的作用就是把一个函数的某些参数固定住（设置默认值），返回一个新函数。

八、 递归函数

8.1 介绍

在函数内部调用自身的调用方式称为递归（recursion）
应用递归函数需要满足的条件
1.可以通过递归调用缩小问题规模，但新问题必须雨原问题又相同的形式
2.必须存在一种使递归终止的条件，当达到该条件的时候结束递归

##计算阶乘
def f(n):
    if n==1:
        return 1
    else:
        return n*f(n-1)
n = int(input())
print(f(n))
##结果
5
120

8.2 利用递归函数解决汉诺塔问题。

def move(n,a,b,c):
    if n==1:
        print(a,'-->',b)
        return
    else:
        move(n-1,a,c,b) ##需要把（n-1）个圆盘移动到b
        move(1,a,b,c)   ##将a的最后一个圆盘移动到c
        move(n-1,b,a,c) ##将b的（n-1）个圆盘移动到c
move(4,'A','B','C')
##结果
A --> C
A --> B
B --> A
A --> C
C --> B
C --> A
A --> C
A --> B
B --> A
B --> C
C --> B
B --> A
A --> C
A --> B
B --> A

8.3 防止栈溢出

使用递归函数的时候，需要防止栈溢出。
在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层帧。因为栈的大小不是无限的，所以递归调用的次数过多，会导致栈溢出。

##防止栈溢出
def f(n):
    if n==1:
        return 1
    else:
        return n*f(n-1)
print(f(1000))
##结果
Traceback (most recent call last):
  File "D:/pythontest/geshu.py", line 611, in <module>
    print(f(1000))
  File "D:/pythontest/geshu.py", line 610, in f
    return n*f(n-1)
  File "D:/pythontest/geshu.py", line 610, in f
    return n*f(n-1)
  File "D:/pythontest/geshu.py", line 610, in f
    return n*f(n-1)
  [Previous line repeated 995 more times]
  File "D:/pythontest/geshu.py", line 607, in f
    if n==1:
RecursionError: maximum recursion depth exceeded in comparison
 ##提示超过最大递归深度

使用尾递归优化。
尾递归是指在函数返回的是调用函数本身，并且return语句不能含有表达式。这样解释器或编译器就可以对尾递归进行优化，使递归无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

def f(n):
    return f1(n,1)
def f1(num,product):
    if num == 1:
        return product
    return f1(num-1,num*product)
print(f1(6,1000))
##结果
720000

九、 闭包

9.1 介绍

嵌套函数，内部函数调用外部函数的变量
优点：
方便外部调用
内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。
闭包找到的是同一地址中父级函数中对应变量最终的值
内部函数总是可以访问其所在的外部函数中声明的变量和参数，即使在外部函数被返回（寿命终结）之后

9.2 特点：

1.让外部访问函数内部变量成为可能
2.局部变量会常驻在内存中
3.可以避免使用全局变量，防止全局变量被污染
4.会造成内存泄漏，有一块内存空间被长期占用，不被释放。每次外部函数执行的时候，外部函数的引用地址不同，都会重新创建一个新的地址。

9.3 判断闭包函数的方法

closure
**

print(outer.__closure__)
def func():
    name = 'aaron'
    def inner():
        print(name)
    print(inner.__closure__)
    return inner
f = func()
f()
# 最后运行的结果里面有cell就是闭包
name = 'aaron'
def func():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner
f = func()
f()

常用应用闭包的方式
虽然a不是全局变量 但是当inn想使用就可以一直使用，延长变量a的使用周期，也保护了内部变量

def outer():
    a = 1
    def inner():
        print(a)
    return inner     ## 一定要return
inn = outer()
inn()

9.4 闭包的应用

import urllib  #模块   闭包的应用from urllib.request import urlopen
ret = urlopen('https://bing.ioliu.cn/').read()
print(ret)
def get_url():
    url = 'https://bing.ioliu.cn/'    
    ret = urlopen(url).read()
    print(ret)
get_url()
def get_url():
    url = 'https://bing.ioliu.cn/'   
    def get():
        ret = urlopen(url).read()
        print(ret)
    return get
get_func = get_url()
get_func()