python第十三天，函数的嵌套定义，global，nonlocal关键字的使用，闭包及闭包的运算场景，装饰器

今日内容

1. 函数的嵌套定义

2.global，nonlocal关键字

3.闭包及闭包的运用场景

4.装饰器

函数的嵌套定义

1. 概念：在一个函数内部定义另一个函数

2 .为什么要有函数的嵌套定义：

1) 函数fn2想要直接使用fn1函数的局部变量，可以将fn2直接定义到fn1的内部，这样fn2就可以直接访问fn1的变量

2) 函数fn2名字就变成fn1的局部变量了，正常只能在fn1中使用，想要在外部使用，可以将fn2函数对象作为fn1函数的返回值

3) 在外部也用同名的变量fn2来接收fn1函数的执行结果（也就是fn1函数的返回值）,那么fn2也就可以在外部被调用

global关键字

作用：将局部的变量提升为全局变量

1. 全局没有相同变量，直接提升局部变量为全局变量

2.有同名全局变量，就是统一全局与局部的同名变量

　　　　　　---　　如果局部想改变全局变量的值（也就是指发生地址改变），可以通过global声明该变量

num = 888        # 此处的起始值为888，而且为全局变量
def fn1():
    global num   # 通过global函数把num改为全局变量，
    num = 666    # 再把num的值改为666
    print(num)   # 此处打印的num是更改之后的值所以是666
def fn2():       # 我们再通过一个函数来查看全局变量是否已被修改
    print(num)   # 此处打印的依然还是666.所以证明num的值已被修改
fn1()            # 但是此处调用函数的顺序需要注意，如果是先调用fn2函数，那么fn2打印的依然是没有被修改的num.也就是888
fn2()

nonlocal关键字

作用：将局部的变量提升为嵌套局部变量

1.使用noncocal时，必须有同名的局部变量，然后再通过noncocal来改变嵌套局部便可的值（也是值发生地址改变）

def outer():
    num = 888          # 起始的局部变量为888,
    def inter():       # 定义嵌套函数
        nonlocal num  # 此处使用nonlocal来把嵌套变量num改为局部变量。
        num = 666      # 再把num重新赋值为666
        print(num)     #  此处打印的是更改后的值，所以是666
    inter()            # 而此处是调用的是嵌套函数，修改了num的变量域。所以会先执行
    print(num)         #  程序再走到这里时，打印的依然时666
outer()                #  需要注意的时nonlocal只能把变量改为局部变量

开放封闭原则

开放封闭的原则：在不修改源代码与调用方式的情况下为函数添加新功能  *****

1.不能修改源代码，---1.无权修改，2.功能不支持。3.修改的位置太多，并且需要一 一修改

2.不能修改原函数的调用方式  --- 修改调用方式的弊端，原项目的所有函数调用都要修改

装饰器

装饰器：满足开放封闭原则的一个闭包应用

def outer(fn):
    def inner(*args,**kwargs):   # 因为不能确定被装饰的函数参数的个数，所以设定为接受任意个，来着不拒，用可变长来接受
        pass                     # 此处可以添加新功能
        res = fn(*args,**kwargs) # 解压带给原功能
        pass                    #  此处可以添加新功能
        return res
    return inner               # 返回嵌套函数的值给fn()

# 使用 装饰器（outer），得到新功能（inter）
# 用被装饰的函数名去接受装饰器的执行结果，调用装饰器时传入被装饰的函数对象
@outer        #  # fn = outre(fn) = inter  1.通过@ 符号加函数名来调用函数，此处为@outer语法来调用outer,规定传入被装饰的函数对象，所以参数固定为一个，接受被装饰的函数对象
def fn():    #  此处为原函数
    print('原函数')
fn()         # 表面上感觉调用的是原函数，本质调用的是闭包（inter）,使用fn调用和fn定义及inner需要参数统一

一个函数被多次装饰

def outer(func):
    def inner(*args,**kwargs):
        res = func(*args,**kwargs)
        return res
    return inner

def check_user(func):
    def inner(*args,**kwargs):
        # 账号验证功能
        user = args[0]    # type :str
        if not(user.isalpha() and len(user) >= 3):
            print('账号不合法')
            return False
        res = func(*args,**kwargs)
        return res
    return inner
def check_pwd(func):
    def inner(*args,**kwargs):
        pwd = args[1]
        if len(pwd) < 3:
            print('密码不合法')
            return False
        res = func(*args,**kwargs)
        return res
    return inner
def format_return(func):
    def inner(*args,**kwargs):
        res =func(*args,**kwargs)
        if res:
            return '登陆成功'
        return '登陆失败'
    return inner
# 登陆原功能
@format_return
@check_user
@check_pwd
def login(user,pwd):
    if user == 'owen' and pwd == '123':
        return True
    return False
user = input('user:')
pwd = input('pwd:')
res = login(user,pwd)
print(res)
# 执行过程：调用login ->进入第一个装饰器（format_return）的inner
# ->进入第二个装饰器（check_user）的inner
# ->进入第三个装饰器（check_pwd）的inner
# ->开始返回，从第三个返回到第二个再返回到第一个，最后返回到外界调用的位置