第020讲：函数：内嵌函数和闭包

测试题

0.如果希望在函数中修改全局变量的值，应该使用什么关键字？

global 关键字

>>> count = 5
>>> def MyFun():
                global count
                count = 10
                print(count)
 
>>> MyFun()
10
>>> count
10

>>> count = 5
>>> def MyFun():
                count = 10
                print(count)
 
>>> MyFun()
10
>>> count
5
#没有加gobal，如果对全局变量进行修改函数会启动shadowing来保护全局变量，在内部创建一个同名的局部变量

1.在嵌套的函数中，如果希望在内部修改外部函数的局部变量，应该使用什么关键字？

nonlocal

举个例子

>>> def Fun1():
                x = 5
                def Fun2():
                        nonlocal x#没有这个  调用fun1会报错
                        x *= x
                        return x
                return Fun2()
 
>>> Fun1()
25

2. Python 的函数可以嵌套，但要注意访问的作用域问题哦，请问以下代码存在什么问题呢？

def outside():
    print('I am outside!')
    def inside():
        print('I am inside!')
 
inside()

使用嵌套函数要注意一点就是作用域问题，inside() 函数是内嵌在 outside() 函数中的，在外边或者别的函数体里是无法对其进行调用的。

正确的调用

def outside():
    print('I am outside!')
    def inside():
        print('I am inside!')
        
    inside()
outside()

3. 请问为什么代码 A 没有报错，但代码 B 却报错了？应该如何修改？

代码A：

def outside():
    var = 5
    def inside():
        var = 3
        print(var)
        
    inside()
outside()

代码B：

def outside():
    var = 5
    def inside():
        print(var)
        var = 3
        
    inside()
outside()

这里 outside() 函数里有一个 var 变量，但要注意的是，内嵌函数 inside() 也有一个同名的变量，Python 为了保护变量的作用域，故将 outside() 的 var 变量屏蔽起来，因此此时是无法访问到外层的 var 变量的。

修改为

def outside():
    var = 5
    def inside():
        nonlocal var
        print(var)
        var = 3
        
    inside()
outside()

4. 请问如何访问 funIn() 呢？

def funOut():
    def funIn():
        print('宾果！你成功访问到我啦！')
    return funIn() #返回的是函数finIn的返回值  这样会执行一次funIn

#访问方式:只需要直接调用 funOut() 即可
funOut()
宾果！你成功访问到我啦！

5. 请问如何访问 funIn() 呢？

def funOut():
    def funIn():
        print('宾果！你成功访问到我啦！')
    return funIn   #少了括号  相当于返回内嵌函数的引用 和第4不同它不会执行funIn

区别于上一题，返回的是一个函数对象这里你就需要用 funOut()() 访问啦：

funOut()()
宾果！你成功访问到我啦！
#当然你也可以“曲线救国”：
go = funOut()
go()
宾果！你成功访问到我啦！

6. 以下是“闭包”的一个例子，请你目测下会打印什么内容？

def funX():
    x = 5
    def funY():
        nonlocal x #把x声明为非局部变量
        x += 1
        return x
    return funY
 
a = funX()#a是一个函数对象
print(a())
print(a())
print(a())

当a=funX()的时候，只要a变量没有被重新赋值，funX()就没有被释放，也就是说局部变量x就没有被重新初始化，所以当全局变量不适用的时候，可以考虑使用闭包更稳定和安全
打印出：
6
7
8

动动手

0. 请用已学过的知识编写程序，统计下边这个长字符串中各个字符出现的次数并找到小甲鱼送给大家的一句话。 （由于我们还没有学习到文件读取方法，大家下载后拷贝过去即可）

在这里插入代码片

1. 请用已学过的知识编写程序，找出小甲鱼藏在下边这个长字符串中的密码，密码的埋藏点符合以下规律：

str1 = '''ASDASdFSDFdFDSFdGSDGVDd'''
 
countFront = 0  # 统计前边的大写字母
countMid = 0  # 统计中间小写字母
countRear = 0  # 统计后边的大写字母
length = len(str1)
target=""
for i in range(length):
    if str1[i] == '\n':
        continue
    if str1[i].isupper():
        if countMid:
            countRear+=1
            if countRear==4:
                countRear=3
        else:
            countFront+=1
            if countFront==4:
                countFront=3
    if str1[i].islower():
        if countMid:
            countFront = 0
            countMid = 0
            countRear = 0
        else:
            countMid=1
            target=str1[i]
    if countFront==3 and countRear==3:
        print(target)
        countFront = 3
        countMid = 0
        countRear = 0

2. 请写下这一节课你学习到的内容：格式不限，回忆并复述是加强记忆的好方式

这节课主要讲解内嵌函数和闭包

（1）glabal 关键字

将函数体内部的局部变量变为全局变量。

（2）内嵌函数（内部函数）

需要注意的是内嵌函数的整个作用域，都在外部函数之内的，也就是说，出了外部函数的范围，是没有办法调用内部函数的。即：假设函数 fun2()的定义和调用的过程都在函数 fun1()内，那么除了在 fun1() 这个函数体里面可以随便调用 fun2()外，出了fun1()，就没有任何可以对fun2(）调用的方式了。

（3）闭包

闭包是函数式编程重要的语法结构。不同的编程语言实现闭包的形式不同，Python中闭包从表现形式上定义为：如果在一个内部函数里，对外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包。例如：

对于函数FunX()，内部函数为FunY()，内部函数的外部作用域就是FunX（）的整个函数空间，的变量就是x，对它进行引用了，达到这个要求了，所以就是内部函数FunY()就是一个闭包。那如何进行调用呢？

首先我们发现调用FunX()会得到一个函数，i是函数FunX（）的函数，如果需要得到x*y的值，我们还需要对FunY()进行调用。

使用闭包需要注意的是：因为闭包的概念是由内部函数演变而来，所以你也不能在外部函数的外边对内部函数进行调用。在闭包中，外部函数的局部变量对内部函数的局部变量就相当于之前的全局变量之于局部变量的关系。在内部函数中，你只能对外部函数的局部变量进行访问，但你不能对它进行修改。例如：

曲线救国：

列表不是存储在栈中

因为这里的 x *= x中的x被认为是一个局部变量，且没有被定义，所以报错。如果需要在局部使用全局的变量，需要用到nonlocal关键字，这个关键字的使用方法与global相同。