day11_7.11 闭包函数与装饰器

补充：

　　callable 代表可调用的，加括号可以执行。（函数或者类）

　　import this  查看python之禅

一。闭包函数

　　所谓闭包函数，就是定义在函数内部的函数，也就是函数定义的嵌套。而在其内部函数中可以引用外部函数作用域的名字。

　　闭包的直接问题是传参。

　　一般的传参方法都是将参数直接传递给函数，函数内部就可以引用，如：

def foo(oop):
    print(oop)
foo(123)
#输出结果>>>123

　　foo收到参数123后直接打印，而在闭包函数中需要从内函数调用外函数的参数，进行运算，如下：

def outter():
    x=1
    y=2
    def inner():
        print(x+y)
        return x+y
    return inner
res=outter()
res()
#输出结果>>>3

　　像内函数inner()就调用了外函数的x与y参数。这里复习一下闭包函数的运行过程。

　　当outter被调用时，执行return inner，返回的是inner的内存地址，所以outter()就是outter函数的返回值，所以res就被赋予inner的内存地址，加上（）后才能执行print（x+y）。

　　res仅仅代表着1与2的值，在运行时并不能对其进行传参，所以一下代码等同于以上代码：

def outter(x,y):
    def inner():
        print(x+y)
        return x+y
    return inner
res=outter(1,2)
res()
res=outter(3,4)
res()
#输出结果>>>3  7

　　x，y是形参，在创建和传参时就相当于使得x=1，y=2，在外函数中始终有效，所以outter变成了一个有参函数，

　　可以对res进行重新赋值改变其return的值。

　　对于闭合函数的应用，res可以反复使用而不需要重复对其传参，当参数改变的时侯可以重新对outter进行传参，这种 方便更多的体现在爬虫中（了解）：

import requests
def outter(url):
    def inner():
        res=requests.get(url)#把url网站请求赋值给res
        print(res.text)
        print(res)
    return inner
res=outter('https://i.cnblogs.com/EditPosts.aspx?opt=1')
res()

　　res.text代表的就是输出网站所有内容，当不使用以上办法时，需要每次使用时都要对同一函数进行相同的赋值，而闭包函数只需要res即可，对于爬虫来说非常方便。

二。装饰器

　　装饰器就是可以给被装饰的对象添加新的功能。

　　装饰器满足开放封闭原则，开放就是对外扩展原则，可以对原先的功能进行扩展，封闭：不能修改原来的函数。

　　做成一个装饰器必须要满足两个条件：

　　1，不改变被装饰对象的源码。

　　2，不改变装饰对象的调用方式。

　　复习：外函数返回的值是内函数的内存地址，内存地址+（）可执行代码，带着这个概念和两个条件，开始接触装饰器：

　　补充：

　　inport time 模块，time.time()是时间戳，可以返回现在时间距离1970-1-1日的相差秒数（1970.1.1是unix系统诞生的日子）

　　time.sheep(3)

　　有一个函数，index，需要判断其程序的运行时间，如何使用装饰器对其进行功能的拓展。

　　首先用time模块可以对其进行功能上的实现：

import time

def index():
    time.sleep(3)
    print('我是登录程序')

time1=time.time()
index()
time2=time.time()
print(time2-time1)
#输出结果>>>
#我是登录程序
#3.0007030963897705

　　然而并没有使用函数进行封装，所以使用函数版：

def get_time():
    time1=time.time()
    index()
    time2=time.time()
    print(time2-time1)
get_time()

　　get_time函数只能对index函数进行功能拓展，所以并没有实现装饰器功能，调用的时候没有使用原来的调用名index，所以，为了达到这一目的，可以使用闭包函数，将get_time()的内存地址返回给外函数，再将外函数的值传给原函数，就可以使用原函数的名字调用get_time函数了。

def outter():
    def get_time():
        time1=time.time()
        index()
        time2=time.time()
        print(time2-time1)
    return get_time
res=outter()
res()

　　这样一个针对index的函数的装饰器差不多构成了，但还是不满足调用原函数实现拓展功能的目标，而且这里不能直接将get_time的内存地址赋给内函数传给原函数，否则执行index=get_time()函数时会将get_time里的函数都执行一遍，给外函数就不会出现这个问题。

　　对于上代码中只是针对index做的装饰器，换做其他的函数就不可用，所以要将装饰器中的index()当成参数传入，其形参就定义再外函数中被传入。

def register():
    time.sleep()
    print('我是注册程序')

def outter(func):
    def get_time():
        time1=time.time()
        func()
        time2=time.time()
        print(time2-time1)
    return get_time
res=outter(index)
index=res
index()
register=outter(register)
register()
#输出结果>>>我是登录程序
#3.000358819961548
#我是注册程序
#3.0000927448272705

　　这样将函数名代表的内存地址传入内函数中，加上（）就可以被执行，将外函数返回的内函数内存地址赋值给原函数名，再加（）就可以执行，效果和装饰器一致，所以，outter满足了无参函数的装饰器所有规定。

　　既然有无参函数，就有有参函数，当有参函数被传入的时后，其参数不能被内函数接受，所以，要装饰有参函数，必须要将参数以某种形式传入，这里选择了可以接受多余参数的*和** 做为形参。

def print_name(name):
    time.sleep()
    print('我是%s'%name)
　　return 'name'

def outter(func):
    def get_time(*args,**kwargs):
        time1=time.time()
        func(*args,**kwargs)
        time2=time.time()
        print(time2-time1)
    return get_time
print_name('lzx')
print_name=outter(print_name)
print_name('lzx')
#输出结果>>>我是lzx
#我是lzx
#3.0001375675201416

　　这样的装饰器，有一个小小的问题，当用户需要返回print_name的返回值时，会出现不一样的情况

print(print_name('lzx'))
print_name=outter(print_name)
print_name('lzx')
print(print_name('lzx'))
#输出结果>>>我是lzx
#name
#我是lzx
#3.0016050338745117
#我是lzx
#3.0001797676086426
#None

　　在装饰器之前打印次函数的返回值时时name原返回值，但是当装饰之后只会返回none，那返回值去哪了返回的是谁的返回值呢，这里需要短暂的分析

　　当程序运行时，编译好outter函数后，再将其返回的get_time内存地址返回给print_name也就是原函数，再运行原函数时实际就是运行内函数get_time所以再执行第三步时其实是返回的get_time的返回值，而其中真正的返回值只要函数func拥有，所以为了实现完美装饰器功能，必须将get_name的函数返回值与原函数的返回值一致。

def register():
    time.sleep()
    print('我是注册程序')
def print_name(name):
    time.sleep()
    print('我是%s'%name)
    return 'name'

def outter(func):
    def get_time(*args,**kwargs):
        time1=time.time()
        res=func(*args,**kwargs)
        time2=time.time()
        print(time2-time1)
        return res
    return get_time
# print(print_name('lzx'))
print_name=outter(print_name)
# print_name('lzx')
print(print_name('lzx'))
#输出结果>>>我是lzx
#3.0002002716064453
#name

　　如上便是一个完整功能的装饰器。

　　装饰器语法糖

　　在每次需要调用装饰器时，都要执行原函数=装饰器（原函数）这样的操作，很麻烦，所以可以使用装饰器语法糖

def outter(func):
    def get_time(*args,**kwargs):
        time1=time.time()
        res=func(*args,**kwargs)
        time2=time.time()
        print(time2-time1)
        return res
    return get_time

@outter
def register():
    time.sleep(3)
    print('我是注册程序')

register()
#输出结果>>>我是注册程序
#3.000058889389038

　　@outter对于register相当于register=outter(register)，将紧挨着的那个对象当作参数赋值给它，和上述语法差不多。

　　装饰器模板

def outter(func):
    def inner(*args,**kwargs):
        print('执行被装饰函数之前 你可以做的操作')
        res = func(*args,**kwargs)
        print('执行被装饰函数之后 你可以做的操作')
        return res
    return inner

　　这便是装饰器的模板

　　有参装饰器

　　当装饰器中需要调用额外的参数时，如何将参数传递呢，在内函数中，参数时提供给原函数使用，如果改变，势必要改变原函数，与装饰器原则不符，而外函数的参数是传递原函数，如果增加，在使用语法糖时会报错（参数不足），所以，需要在外函数外再报一个函数：

def outter2(choose):
    def outter(func):
        def get_time(*args,**kwargs):
            if choose==1:
                time1=time.time()
                res=func(*args,**kwargs)
                time2=time.time()
                print(time2-time1)
                return res
            elif choose==2:
                return 0
        return get_time
    return outter

@outter2(1)
def register():
    time.sleep(3)
    print('我是注册程序')
#输出结果>>>我是注册程序
#3.0003597736358643

　　语法糖是可以传入参数的，当传如1时会执行语句，传入0 时什么都不执行，这个参数可以传入多个，所有多余参数都可以写入。

　　装饰器修复：

　　当用户对被装饰后的函数去内存地址和备注时，并不会返回原来的内存地址，而是返回内函数的，所以为了以假乱真，可以使用from functools import wraps，再再外函数里使用@wrap(func)语句就可以返回原来的内存地址及注释

from functools import wraps
def outter2(choose):
    def outter(func):
        @wraps(func)
        def get_time(*args,**kwargs):
            if choose==1:
                time1=time.time()
                res=func(*args,**kwargs)
                time2=time.time()
                print(time2-time1)
                return res
            elif choose==2:
                return 0
        return get_time
    return outter

　　多个装饰器

　　当多个装饰器装饰一个函数时他们的顺序是规定 的

@outter1  # index = outter1(wapper2)
@outter2  # wrapper2 = outter2(wrapper3)
@outter3  # wrapper3 = outter3(最原始的index函数内存地址)
def index():
    print('from index')

　　其执行顺序是

加载了outter3

加载了outter2

加载了outter1

执行了wrapper1

执行了wrapper2

执行了wrapper3

from index　　

　　所以它们的执行规则应该是装饰顺序为从下往上，执行顺序为从上往下。