python-装饰器初识,闭包

函数名的运⽤, 第⼀类对象

⼀. 函数名的运⽤.
　　函数名是⼀个变量, 但它是⼀个特殊的变量, 与括号配合可以执⾏函数的变量

　　1. 函数名的内存地址

def func():
　　print("呵呵")
print(func)
结果:
<function func at 0x1101e4ea0>

　　2. 函数名可以赋值给其他变量

def func():
　　print("呵呵")
print(func)
a = func # 把函数当成⼀个变量赋值给另⼀个变量
a() # 函数调⽤ func()

　　3. 函数名可以当做容器类的元素

def func1():
    print("呵呵")
def func2():
    print("呵呵")
def func3():
    print("呵呵")
def func4():
    print("呵呵")lst = [func1, func2, func3]
for i in lst:
    i()

　4. 函数名可以当做函数的参数

def func():
    print("吃了么")
def func2(fn):
    print("我是func2")
    fn() # 执⾏传递过来的fn
    print("我是func2")
func2(func) # 把函数func当成参数传递给func2的参数fn.

　5. 函数名可以作为函数的返回值

def func_1():
    print("这⾥是函数1")
    def func_2():
        print("这⾥是函数2")
    print("这⾥是函数1")
    return func_2
fn = func_1() # 执⾏函数1. 函数1返回的是函数2, 这时fn指向的就是上⾯函数2
fn() # 执⾏上⾯返回的函数

　　

二. 闭包

　　什么是闭包? 闭包就是内层函数, 对外层函数(非全局)的变量的引⽤. 叫闭包

def func1():
　　name = "alex"
　　def func2():
　　print(name) # 闭包
　　func2()
func1()
结果:
alex

我们可以使⽤__closure__来检测函数是否是闭包. 使⽤函数名.__closure__返回cell就是 闭包. 返回None就不是闭包

def func1():
    name = "alex"
    def func2():
        print(name) # 闭包
    func2()
    print(func2.__closure__) # (<cell at 0x10c2e20a8: str object at
0x10c3fc650>,)
func1()

　　问题, 如何在函数外边调⽤内部函数呢?

def outer():
    name = "alex"
    # 内部函数
    def inner():
        print(name)
    return inner
fn = outer() # 访问外部函数, 获取到内部函数的函数地址
fn() # 访问内部函数

　　那如果多层嵌套呢? 很简单, 只需要⼀层⼀层的往外层返回就⾏了

def func1():
    def func2():
        def func3():
            print("嘿嘿")
        return func3
    return func2
func1()()()

　　由它我们可以引出闭包的好处. 由于我们在外界可以访问内部函数. 那这个时候内部函
数访问的时间和时机就不⼀定了, 因为在外部, 我可以选择在任意的时间去访问内部函数. 这
个时候. 想⼀想. 我们之前说过, 如果⼀个函数执⾏完毕. 则这个函数中的变量以及局部命名
空间中的内容都将会被销毁. 在闭包中. 如果变量被销毁了. 那内部函数将不能正常执⾏. 所
以. python规定. 如果你在内部函数中访问了外层函数中的变量. 那么这个变量将不会消亡.
将会常驻在内存中. 也就是说. 使⽤闭包, 可以保证外层函数中的变量在内存中常驻. 这样做
有什么好处呢? 非常⼤的好处. 我们来看⼀个关于爬⾍的代码:

from urllib.request import urlopen
def but():
    content = urlopen("http://www.xiaohua100.cn/index.html").read()
    def get_content():
        return content
    return get_content
fn = but() # 这个时候就开始加载校花100的内容
# 后⾯需要⽤到这⾥⾯的内容就不需要在执⾏⾮常耗时的⽹络连接操作了
content = fn() # 获取内容
print(content)
content2 = fn() # 重新获取内容
print(content2)

　　综上, 闭包的作⽤就是让⼀个变量能够常驻内存. 供后⾯的程序使⽤.

三. 装饰器初识

　　在说装饰器之前啊. 我们先说⼀个软件设计的原则: 开闭原则, ⼜被成为开放封闭原则,
你的代码对功能的扩展是开放的, 你的程序对修改源代码是封闭的. 这样的软件设计思路可以
更好的维护和开发.
　　开放: 对功能扩展开放
　　封闭: 对修改代码封闭

接下来我们来看装饰器. ⾸先我们先模拟⼀下女娲造⼈

def create_people():
    print("⼥娲很厉害. 捏个泥⼈吹⼝⽓就成了⼈了")
create_people()

　　ok! 很简单. 但是现在问题来了. 上古时期啊. 天⽓很不稳定. 这时候呢⼤旱三年. 女娲再去
造⼈啊就很困难了. 因为啥呢? 没⽔. 也就是说. 女娲想造⼈必须得先和泥. 浇点⼉⽔才能造
⼈

def create_people():
    print("浇⽔") # 添加了个浇⽔功能
    print("⼥娲很厉害. 捏个泥⼈吹⼝⽓就成了⼈了")
create_people()

　　搞定. 但是, 我们来想想. 是不是违背了我们最开始的那个约定"开闭原则", 我们是添加了
新的功能. 对添加功能开放. 但是修改了源代码啊. 这个就不好了. 因为开闭原则对修改是封
闭的. 那怎么办. 我们可以这样做.

def create_people():
    # print("浇⽔") # 添加了个浇⽔功能, 不符合开闭原则了
    print("⼥娲很厉害. 捏个泥⼈吹⼝⽓就成了⼈了")
def warter():
    print("先浇⽔")
    create_people() # 造⼈
# create_people() # 这个就不⾏了.
warter() # 访问浇⽔就好了

　　现在问题⼜来了. 你这个函数写好了. 但是由于你添加了功能. 重新创建了个函数. 在这之
前访问过这个函数的⼈就必须要修改代码来访问新的函数water() 这也要修改代码. 这个也不
好. 依然违背开闭原则. ⽽且. 如果你这个函数被⼤量的⼈访问过. 你让他们所有⼈都去改. 那
你就要倒霉了. 不⼲死你就⻅⿁了.
　　那怎么办才能既不修改原代码, ⼜能添加新功能呢? 这个时候我们就需要⼀个装饰器了. 装
饰器的作⽤就是在不修改原有代码的基础上, 给函数扩展功能

def create_people():
    # print("浇⽔") # 添加了个浇⽔功能, 不符合开闭原则了
    print("⼥娲很厉害. 捏个泥⼈吹⼝⽓就成了⼈了")
def warter(fn):
    def inner():
        print("浇浇⽔")
        fn()
        print("施肥")
    return inner
# # create_people() # 这个就不⾏了.
# warter() # 访问浇⽔就好了
func = warter(create_people)
func() # 有⼈问了. 下游访问的不依然是func么, 不还是要改么?
create_people = warter(create_people)
create_people() # 这回就好了吧,

　　说⼀下执⾏流程:

1. ⾸先访问warter(create_people)

2. 把你的⽬标函数传递给warter的形参fn. 那么后⾯如果执⾏了fn意味着执⾏了你的⽬
标函数create_people
3. warter()执⾏就⼀句话. 返回inner函数. 这个时候. 程序认为warter()函数执⾏完. 那么
前⾯的create_people函数名被重新覆盖成inner函数
4. 执⾏create_people函数. 实际上执⾏的是inner函数. ⽽inner中访问的恰恰使我们最开
始传递进去的原始的create_people函数

结论: 我们使⽤warter函数把create_people给包装了⼀下. 在不修改create_people的前提下.
完成了对create_people函数的功能添加

这是⼀个装饰器的雏形. 接下来我们观察⼀下代码. 很不好理解. 所以呢. 我们可以使⽤语法
糖来简化我们的代码

def warter(fn):
    def inner():
        print("浇浇⽔")
        fn()
        print("施肥")
    return inner
@warter # 相当于 create_people = warter(create_people)
def create_people():
print("⼥娲很厉害. 捏个泥⼈吹⼝⽓就成了⼈了")
create_people()
结果:
浇浇⽔
⼥娲很厉害. 捏个泥⼈吹⼝⽓就成了⼈了
施肥

　　我们发现, 代码运⾏的结果是⼀样的. 所谓的语法糖语法: @装饰器
类似的操作在我们⽣活中还有很多. 比⽅说. 约⼀约.

# 2--> 现在啊, 这个⾏情⽐较不好, 什么⽜⻤蛇神都出来了.
# 那怎么办呢? 问问⾦⽼板. ⾦⽼板在前⾯给⼤家带路
# 这时候我们就需要在约之前啊. 先问问⾦⽼板了. 所以也要给函数添加⼀个功能, 这⾥依然可以使
⽤装饰器
def wen_jin(fn):
    def inner():
        print("问问⾦⽼板, ⾏情怎么样, 质量好不好")
        fn()
        print("⺾, ⾦⽼板骗我")
    return inner
@wen_jin
def yue(): # 1--> 约⼀约函数
    print("约⼀约")
yue()

　　ok, 接下来. 我们来看⼀下, 我约的话, 我想约个⼈. 比如约wusir, 这时, 我们要给函数添加
⼀个参数

# 2--> 现在啊, 这个⾏情⽐较不好, 什么⽜⻤蛇神都出来了.
# 那怎么办呢? 问问⾦⽼板. ⾦⽼板在前⾯给⼤家带路
# 这时候我们就需要在约之前啊. 先问问⾦⽼板了. 所以也要给函数添加⼀个功能, 这⾥依然可以使
⽤装饰器
def wen_jin(fn):
    def inner():
        print("问问⾦⽼板, ⾏情怎么样, 质量好不好")
        fn()
        print("⺾, ⾦⽼板骗我")
    return inner
@wen_jin
def yue(name): # 1--> 约⼀约函数
    print("约⼀约", name)
yue("wusir")
结果:
Traceback (most recent call last):
File "/Users/sylar/PycharmProjects/oldboy/fun_2.py", line 131, in
<module>
yue("wusir")
TypeError: inner() takes 0 positional arguments but 1 was given

　　程序报错. 分析原因: 我们在外⾯访问yue()的时候. 实际上访问的是inner函数. ⽽inner函数
没有参数. 我们给了参数. 这肯定要报错的. 那么该怎么改呢? 给inner加上参数就好了

def wen_jin(fn):
    def inner(name):
        print("问问⾦⽼板, ⾏情怎么样, 质量好不好")
        fn(name)
        print("⺾, ⾦⽼板骗我")
    return inner
@wen_jin
def yue(name):
    print("约⼀约", name)
yue("wusir")

　　这样就够了么? 如果我的yue()改成两个参数呢? 你是不是还要改inner. 对了. ⽤*args和
**kwargs来搞定多个参数的问题

def wen_jin(fn):
        def inner(*args, **kwargs): # 接收任意参数
            print("问问⾦⽼板, ⾏情怎么样, 质量好不好")
            fn(*args, **kwargs) # 把接收到的内容打散再传递给⽬标函数
            print("⺾, ⾦⽼板骗我")
        return inner
@wen_jin
def yue(name):
    print("约⼀约", name)
yue("wusir")

　　搞定. 这时 wen_jin()函数就是⼀个可以处理带参数的函数的装饰器
光有参数还不够. 返回值呢?

def wen_jin(fn):
    def inner(*args, **kwargs):
        print("问问⾦⽼板, ⾏情怎么样, 质量好不好")
        ret = fn(*args, **kwargs) # 执⾏⽬标函数. 获取⽬标函数的返回值
        print("⺾, ⾦⽼板骗我")
        return ret # 把返回值返回给调⽤者
    return inner
@wen_jin
def yue(name):
    print("约⼀约", name)
    return "⼩萝莉" # 函数正常返回
r = yue("wusir") # 这⾥接收到的返回值是inner返回的. inner的返回值是⽬标函数的返回值
print(r)

　　返回值和参数我们都搞定了. 接下来给出装饰器的完整模型代码(必须记住)

# 装饰器: 对传递进来的函数进⾏包装. 可以在⽬标函数之前和之后添加任意的功能.
def wrapper(func):
    def inner(*args, **kwargs):
        '''在执⾏⽬标函数之前要执⾏的内容'''
        ret = func(*args, **kwargs)
        '''在执⾏⽬标函数之后要执⾏的内容'''
        return ret
    return inner
# @wrapper 相当于 target_func = wrapper(target_func) 语法糖
@wrapper
def target_func():
    print("我是⽬标函数")
# 调⽤⽬标函数
target_func()