装饰器

装饰器

装饰器=高阶函数+函数嵌套+闭包

器即函数

装饰即修饰，意指为其他函数添加新功能

装饰器定义：

　　本质就是函数，功能是为其他函数添加新功能

遵循的原则：　

　　1.不修改被装饰函数的源代码（开放封闭原则）

　　2.为被装饰函数添加新功能后，不修改被修饰函数的调用方式

 

高阶函数

定义:　　

　　1.函数接收的参数是一个函数名

　　2.函数的返回值是一个函数名

　　3.满足上述条件任意一个,都可称之为高阶函数

　　

def foo():
    print('我的函数名作为参数传给高阶函数')

def gao_jie1(func):
    print('我就是高阶函数1,我接收的参数名是%s' %func)
    func()

def gao_jie2(func):
    print('我就是高阶函数2,我的返回值是%s' %func)
    return func

gao_jie1(foo)
gao_jie2(foo)

　　

#高阶函数应用1:把函数当做参数传给高阶函数
import time
def foo():
    print('from the foo')

def timmer(func):
    start_time=time.time()
    func()
    stop_time=time.time()
    print('函数%s 运行时间是%s' %(func,stop_time-start_time))

timmer(foo)

#总结:我们确实为函数foo增加了foo运行时间的功能,但是foo原来的执行方式是foo(),现在我们需要调用高阶函数timmer(foo),改变了函数的调用方式

　　

#高阶函数应用2:高阶函数直接返回函数名
import time
def foo():
    print('from the foo')

def timmer(func):
    start_time=time.time()
    return func
    stop_time=time.time()
    print('函数%s 运行时间是%s' %(func,stop_time-start_time))

foo=timmer(foo)
foo()

#总结:我们确实没有改变foo的调用方式,但是我们也没有为foo增加任何新功能

　　高阶函数总结
　　　　1.函数接收的参数是一个函数名
　　　　　　作用:在不修改函数源代码的前提下,为函数添加新功能,
　　　　　　不足:会改变函数的调用方式
　　　　2.函数的返回值是一个函数名
　　　　　　作用:不修改函数的调用方式
　　　　　　不足:不能添加新功能

 

函数嵌套

　　在一个函数中定义了另外一个函数.

def outer():
　　def inner():
　　　　print('inner')
　　print('outer')
　　inner()
outer()
inner()    # 此句会出错

#函数有可见范围，这就是作用域的概念
#            一个标识符的可见范围，这就是标识符的作用域。一般常说的是变量的作用域
#            全局作用域（global）：在整个程序运行环境中都可见;
#            局部作用域：在函数、类等内部可见
#内部函数不能被外部直接使用，会抛NameError异常    　　

　　global使用原则：

　　　　外部作用域变量会内部作用域可见，但也不要在这个内部的局部作用域中直接使用，因为函数的目的是为了封装，尽量与外界隔离。

　　　　如果函数需要使用外部全局变量，请使用函数的形参传参解决。

　　　　一句话：不用global，学习它就是为了深入理解变量作用域。

 

闭包

　　自由变量：未在本地作用域中定义的变量。例如定义在内存函数外的外层函数的作用域中的变量。

　　闭包：出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就行成了闭包。（相当于打了一个包）最熟悉的就是JavaScript

>>>def addx(x):  
>>>    def adder(y): return x + y  
>>>    return adder  
>>> c =  addx(8)  
>>> type(c)  
<type 'function'>  
>>> c.__name__  
'adder'  
>>> c(10)  
18  

结合这段简单的代码和定义来说明闭包：

　　如果在一个内部函数里：adder(y)就是这个内部函数，
　　对在外部作用域（但不是在全局作用域）的变量进行引用：x就是被引用的变量，x在外部作用域addx里面，但不在全局作用域里，
　　则这个内部函数adder就是一个闭包。

#闭包函数的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer( a ):
    b = 10
    # inner是内函数
    def inner():
        #在内函数中 用到了外函数的临时变量
        print(a+b)
    # 外函数的返回值是内函数的引用
    return inner

if __name__ == '__main__':
    # 在这里我们调用外函数传入参数5
    #此时外函数两个临时变量 a是5 b是10 ，并创建了内函数，然后把内函数的引用返回存给了demo
    # 外函数结束的时候发现内部函数将会用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数

    demo = outer(5)

    # 我们调用内部函数，看一看内部函数是不是能使用外部函数的临时变量
    # demo存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数
    demo() # 15

    demo2 = outer(7)
    demo2()#17　　

把这些名词按照自己的理解去解释：

1 外函数返回了内函数的引用：

　　引用是什么？在python中一切都是对象，包括整型数据1，函数，其实是对象。

　　当我们进行a=1的时候，实际上在内存当中有一个地方存了值1，然后用a这个变量名存了1 所在内存位置的引用。

　　引用就好像c语言里的指针，大家可以把引用理解成地址。a只不过是一个变量名字，a里面存的是1这个数值所在的地址，就是a里面存了数值1的引用。

　　相同的道理，当我们在python中定义一个函数def demo():  的时候，内存当中会开辟一些空间，存下这个函数的代码、内部的局部变量等等。这个demo只不过是一个变量名字，它里面存了这个函数所在位置的引用而已。我们还可以进行x = demo， y = demo， 这样的操作就相当于，把demo里存的东西赋值给x和y，这样x 和y 都指向了demo函数所在的引用，在这之后我们可以用x() 或者 y() 来调用我们自己创建的demo() ，调用的实际上根本就是一个函数，x、y和demo三个变量名存了同一个函数的引用。

　　返回内函数的引用：

　　　　对于闭包，在外函数outer中 最后return inner，我们在调用外函数 demo = outer() 的时候，outer返回了inner，inner是一个函数的引用，这个引用被存入了demo中。所以接下来我们再进行demo() 的时候，相当于运行了inner函数。

　　　　一个函数，如果函数名后紧跟一对括号，相当于现在我就要调用这个函数；　　如果不跟括号，相当于只是一个函数的名字，里面存了函数所在位置的引用。

2 外函数把临时变量绑定给内函数：

　　一般，一个函数结束的时候，会把自己的临时变量都释放还给内存，之后变量都不存在了。

　　但是闭包是一个特别的情况。

　　外部函数发现，自己的临时变量会在将来的内部函数中用到，自己在结束的时候，返回内函数的同时，会把外函数的临时变量送给内函数绑定在一起。所以外函数已经结束了，调用内函数的时候仍然能够使用外函数的临时变量。

　　python中一切都是对象，虽然函数我们只定义了一次，但是外函数在运行的时候，实际上是按照里面代码执行的，外函数里创建了一个函数，我们每次调用外函数，它都创建一个内函数，虽然代码一样，但是却创建了不同的对象，并且把每次传入的临时变量数值绑定给内函数，再把内函数引用返回。虽然内函数代码是一样的，但其实，我们每次调用外函数，都返回不同的实例对象的引用，他们的功能是一样的，但是它们实际上不是同一个函数对象。

 

闭包中内函数修改外函数局部变量：

　　在闭包内函数中，我们可以随意使用外函数绑定来的临时变量，但是如果我们想修改外函数临时变量数值的时候发现出问题了！

　　在基本的python语法当中，一个函数可以随意读取全局数据，但是要修改全局数据的时候有两种方法:1 global 声明全局变量 2 全局变量是可变类型数据的时候可以修改

　　在闭包内函数也是类似的情况。在内函数中想修改闭包变量（外函数绑定给内函数的局部变量）的时候：

　　　　1 在python3中，可以用nonlocal 关键字声明 一个变量， 表示这个变量不是局部变量空间的变量，需要向上一层变量空间找这个变量。

　　　　2 在python2中，没有nonlocal这个关键字，我们可以把闭包变量改成可变类型数据进行修改，比如列表。

#修改闭包变量的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer( a ):
    b = 10  # a和b都是闭包变量
    c = [a] #这里对应修改闭包变量的方法2
    # inner是内函数
    def inner():
        #内函数中想修改闭包变量
        # 方法1 nonlocal关键字声明
        nonlocal  b
        b+=1
        # 方法二，把闭包变量修改成可变数据类型 比如列表
        c[0] += 1
        print(c[0])
        print(b)
    # 外函数的返回值是内函数的引用
    return inner

if __name__ == '__main__':

    demo = outer(5)
    demo() # 6  11

以上两种方法就是内函数修改闭包变量的方法.

 

使用闭包的过程中，一旦外函数被调用一次返回了内函数的引用，虽然每次调用内函数，是开启一个函数执行过后消亡，但是闭包变量实际上只有一份，每次开启内函数都在使用同一份闭包变量.

#coding:utf8
def outer(x):
    def inner(y):
        nonlocal x
        x+=y
        return x
    return inner


a = outer(10)
print(a(1)) //11
print(a(3)) //14

由此可见，每次调用inner的时候，使用的闭包变量x实际上是同一个.

 

闭包的作用：

3.1装饰器.（其中一个应用就是，我们工作中写了一个登录功能，我们想统计这个功能执行花了多长时间，我们可以用装饰器装饰这个登录模块，装饰器帮我们完成登录函数执行之前和之后取时间。）

3.2面向对象. 经历了上面的分析，我们发现外函数的临时变量送给了内函数。大家回想一下类对象的情况，对象有好多类似的属性和方法，所以我们创建类，用类创建出来的对象都具有相同的属性方法。闭包也是实现面向对象的方法之一。在python当中虽然我们不这样用，在其他编程语言入比如avaScript中，经常用闭包来实现面向对象编程

3.3实现单利模式. 

 

无参装饰器

无参装饰器=高级函数+函数嵌套

计算代码执行的时间：

import time, random

def index():
    time.sleep(random.randrange(1, 5))
    print("welcome to index page")

根据装饰器的特点，我们不能对index()进行任何修改,而且调用方式也不能变。这时候，我们就可以使用装饰器来完成如上功能.

import time, random


def outer(func):  # 将index的地址传递给func
    def inner():
        start_time = time.time()
        func()   # fun = index  即func保存了外部index函数的地址
        end_time = time.time()
        print("运行时间为%s"%(end_time - start_time))
    return inner  # 返回inner的地址


def index():
    time.sleep(random.randrange(1, 5))
    print("welcome to index page")

index = outer(index)  # 这里返回的是inner的地址，并重新赋值给index

index()

 

有参装饰器

被装饰的函数需要传递参数进去，有些函数又不需要参数，处理这种变参数函数：

如果被装饰的函数有返回值：

def timmer(func):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        res=func(*args,**kwargs) #res来接收home函数的返回值
        stop_time=time.time()
        print('run time is %s' %(stop_time-start_time))
        return res  
    return wrapper

def home(name):
    time.sleep(random.randrange(1,3))
    print('welecome to %s HOME page' %name)
    return 123123123123123123123123123123123123123123

home = timmer(home)
home()

　　home = timmer(home)  # 等式右边返回的是wrapper的内存地址,再将其赋值给home，这里的home不在是原来的的那个函数,而是被装饰以后的函数了。

　　像home = timmer(home)这样的写法,python给我们提供了一个便捷的方式------语法糖@.

　　以后我们再要在被装饰的函数之前写上@timmer,它的效果就和home = timmer(home)是一样的。

　　多个装饰器装饰一个函数,其执行顺序是从下往上.

　　

import time
import random

def timmer(func):
    def wrapper():
        start_time = time.time()
        func()
        stop_time=time.time()
        print('run time is %s' %(stop_time-start_time))
    return wrapper
def auth(func):
    def deco():
        name=input('name: ')
        password=input('password: ')
        if name == 'egon' and password == '123':
            print('login successful')
            func() #wrapper()
        else:
            print('login err')
    return deco

@auth   # index = auth(timmer(index))                 
@timmer # index = timmer(index)
def index():
 
    time.sleep(3)
    print('welecome to index page')

index()

 

类装饰器

装饰器不仅可以是函数，还可以是类，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。

使用类装饰器主要依靠类的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

class Foo(object):
    def __init__(self, func):
        self._func = func

    def __call__(self):
        print('class decorator runing')
        self._func()
        print('class decorator ending')


@Foo　　# bar = Foo(bar)
def bar():
    print('bar')


bar()　　# Foo(bar)()

# 结果
# class decorator runing
# bar
# class decorator ending