函数嵌套

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

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

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

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

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

"""

def fn1():

num = 10

return num

num = fn1()

def fn2():

print(num)  # 本质访问的函数全局变量

fn2()

"""

"""

def fn1():

num = 10

fn2(num)  # fn2可以看到fn1的局部变量，但fn2的调用位置不在全局了

print('fn1 end')

def fn2(num):

print(num)

fn1()

"""

"""

def fn1():

num = 10

def fn2():

print(num)

fn2()

fn1()

"""

global关键字

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

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

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

-- 如果局部想改变全局变量的值(发生地址的变化)，可以用global声明该变量

num = 888

def fn1():

global num

# print(num)

# 没有global修饰，num就是自己局部的变量

# 有global修饰，num就是全局的num，全局中只能出现一个num，如果出现了值的改变，大家一起变

num = 666

def fn2():

print(num)

fn1()

fn2()

nonlocal关键字

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

1.必须有同名嵌套局部变量，就是统一嵌套局部与局部的同名变量

-- 如果局部想改变嵌套局部变量的值(发生地址的变化)，可以用nonlocal声明该变量

def outer():
    num=126
    def inner():
        nonlocal num
        num=456
        print(num)    ==> 456
    inner()
    print(num)    ==>

.v v
outer()

闭包

closure：被包裹的函数，称之为闭包

闭包的应用场景

1.闭包中使用的变量可以被外层函数所传递 - 外层函数可以为闭包传递参数

def outer1(num):

def inner1():

print(num)

inner1()

def t():

count = 10

outer1(count)

t()     ==>10

延迟执行

def get_site(url):    #url='https://www.baidu.com'

def site():

response=requests.get(url)

if response.status_code == 200:

print(response.text)

return site

baidu=get_site('https://www.baidu.com')

python=get_site('https://www.python.org')

开放封闭原则

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

开放：有些事，你可以干 - 拓展功能

封闭：有些事，你干不了 - 两个原则

1. 不能修改源代码

- 1.无权修改 2.功能不特有 3.修改的位置多个，需要一一修改

2.不能修改原函数的调用方式

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

装饰器

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

在原功能的基础上，不改变原功能的原代码和调用方式下，添加新的功能

@outer语法来调用outer，规定传入被装饰的函数对象，所以参数固定为一个，接受被装饰的函数对象

def outer(func):

不能确定被装饰的函数的参数：来者不拒，用可边长来接受

def inner(*args, **kwargs):

pass       新功能位

res = func(*args, **kwargs)  # 解压带给原功能

pass      新功能位

return res

return inner

使用装饰器(outer)，得到新功能(inner)

用被装饰的函数名去接受装饰器的执行结果，调用装饰器时传入被装饰的函数对象

@outer  # fn = outer(fn) = inner

def fn(): pass

Fn()

表面调用的是原函数，本质调用的是闭包(inner)，使用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 => 开始返回，从第三个返回到第二个再返回到第一个，最后返回到外界调用的位置

```