闭包函数和装饰器

闭包函数

定义：闭是封闭（函数内部的函数），闭包指的是内部函数包含对外部作用域而非全局作用域的引用。

函数对象：可以将定义在函数内的函数返回到全局使用，从而打破函数的层级限制。

def outter():
    x = 1

    def inner():
        print(x)
    return inner

f = outter()

def f2():
    x = 2
    f()

f2()


# 1

为函数传参的两种方式

1.使用参数的形式

def func(x):
    print(x)

func(1)
func(1)
func(1)

'''
1
1
1
'''

2.包给函数

ef outter(x):
    x = 1

    def inner():
        print(x)
    return inner

f = outter(1)
f()
f()
f()
'''
1
1
1
'''

闭包函数的应用

闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域。

# 普通的传参的方式   每用一次需要传一次参数，显得极其麻烦

import requests


def get(url):
    response = requests.get(url)
    print(f"done: {url}")
    
get('https://www.baidu.com')
get('https://www.baidu.com')
get('https://www.baidu.com')


get('https://www.cnblogs.com/linhaifeng')
get('https://www.cnblogs.com/linhaifeng')
get('https://www.cnblogs.com/linhaifeng')

# 把传的参数包给函数后，把内层函数对象返回到外层，在外层直接调用该函数对象即可，不用频繁的传值了。

import requests
def outter(url):
    def get():
        response = requests.get(url)
        print(f"done: {url}")
    return get

baidu=outter('https://www.baidu.com')
python = outter('https://www.python.org')

baidu()
baidu()

python()
python()

装饰器

1. 什么是装饰器
器:指的是具备某一功能的工具
装饰:指的是为被装饰器对象添加新功能

装饰器就是用来为被装饰器对象添加新功能的工具
注意:装饰器本身可以是任意可调用对象,被装饰器的对象也可以是任意可调用对象

2. 为何要用装饰器
开放封闭原则:封闭指的是对修改封闭,对扩展开放
装饰器的实现必须遵循两大原则:
1). 不修改被装饰对象的源代码
2). 不修改被装饰器对象的调用方式
装饰器的目标:就是在遵循1和2原则的前提下为被装饰对象添加上新功能

3.装饰器的应用（装饰器其实也是闭包函数的一种应用场景）

上面的这张图中outter（）的功能就是装饰器，它装饰了index函数，他在没有改变被调用对象的源代码和调用方式的前提下，实现了统计函数运行时间的功能，感官体验好像还是index（）的调用。

装饰器升级版：装饰器同时装饰两个函数。下图中outter()函数是装饰器，index函数和home函数是被装饰对象。index（）函数（其实是wrapper函数）不需要传参，而home（）函数（其实是wrapper函数）需要传参，那么要想外部调用home（）（其实是wrapper函数）就需要给定义阶段的wrapper（）传形参，比如wrapper（name），然后调用wrapper（）阶段才能传实参，但一个装饰器在同时需要兼顾两个函数，一个需要传值，另一个不需要传值，同时调用，就会报错。那么我们该如何解决呢？？？？这时我们就需要对装饰器outter()内部函数wrapper（）传入两个参数了叫做*args和**kwargs,众所周知这两个参数的作用（在形参中，这两个参数可以接收实参传来的多余位置参数和关键字参数；在实参中，*args这个参数可以将其后面的元组打散成位置实参给位置形参传值，**kwargs这个参数可以将其后面的字典形式的关键字参数打散，传给形参中的关键字参数），所以上图中index不传参，*args和**kwargs没有接收到多余的参数，形成了一个空的（）和空的{}，在下面调用func（）的时候，func括号中（即index括号中）的*args将空元组打散，**kwarg将空字典打散，就没有什么参数传给index函数了。而home()传了位置实参“zhang”,wrapper（）形参中的*args默认接收了形参中多余的位置实参‘zhang’，将‘zhang’存元组的形式，而此时**kwargs还是一个空字典，到下面遇到func（*args，**kwargs），*args将（‘zhang’）打散成字符串原封不动的传给了*args，**kwargs的一个空字典被打散没有了。这样两个函数都被装饰上了，添加上了新的功能，也并没有改变原函数的代码，也没改变他们的调用方式。

注意：现在以home函数为例，如果home函数内部有个返回值（return 234），那么加上装饰器outter（），接收outter(home)的返回值，print（res=outter(home)) 返回值是None，因为这里的home（）就是wrapper（）。

装饰器的语法糖

在被装饰函数上面一行加上@+装饰器，即，例如：

@timmer

def func()

表示装饰func（）函数，意思是func=timmer(func),func是最原始的那个func的内存地址。

 运行原理:
 python解释器一旦运行到@装饰器的名字,就会调用装饰器,然后将被装饰函数的内存地址当作参数
 传给装饰器,最后将装饰器调用的结果赋值给原函数名

         

 装饰器模板

import time
def outter(func):
def wrapper(*args,**kwargs):
#在调用函数前加功能
res=func(*args,**kwargs) #调用被装饰的\也就是最原始的那个函数
 在调用函数后加功能
return res
return wrapper

@outter #index=outter(index) #index=wrapper
def index():
print('welcome to index page')
time.sleep(3)

index()

叠加多个装饰器

import time

def timmer(func):  #func=wrapper2
    def wrapper1(*args,**kwargs):
        start=time.time()
        res=func(*args,**kwargs)  #res=wrapper2(*args,**kwargs)
        stop=time.time()
        print('run time is %s' %(stop - start))
        return res
    return wrapper1

def auth(func): #func=最原始的那个index的内存地址
    def wrapper2(*args,**kwargs):
        inp_user = input('please input your username: ').strip()
        inp_pwd = input('please input your password: ').strip()
        if inp_user == 'zhang' and inp_pwd == '123':
            print('login successfull')
            res=func(*args,**kwargs) # 调用最原始的那个/也就是被装饰的那个函数
            return res
        else:
            print('username or password error')
    return wrapper2

# 解释@语法的时候是自下而上运行
# 而执行装饰器内的那个wrapper函数时的是自上而下
@timmer # index=timmer(wrapper2) #index=wrapper1
@auth # index=auth(最原始的那个index的内存地址) #index=wrapper2
def index():
    print('welcome to index page')
    time.sleep(3)

index() #wrapper1() # 首先调用wrapper1函数

'''
有参装饰器由于需要外部传值，而原无参装饰器外层和内层括号内参数又不能动，所以只能在外层再定义一层函数，
利用必报函数的思想，为内部传值，而且不限定传值的个数，所以装饰器最多也只有三层

'''
# 有参装饰器的模板
def outter1(x,y,z):
    def outter2(func):
        def wrapper(*args,**kwargs):
            res=func(*args,**kwargs)
            return res
        return wrapper
    return outter2

# 无参装饰器的模板
def outter(func):
    def wrapper(*args,**kwargs):
        res=func(*args,**kwargs)
        return res
    return wrapper

有参装饰器应用实例：

import time

current_user={'username':None}

# 补充:所有的数据类型的值自带布尔值,可以直接当作条件去用,只需要记住布尔值为假的那一些值即可(0,空,None)


def login(engine='file'): #engine='mysql'
    def auth(func): #func=最原始那个index的内存地址
        def wrapper(*args,**kwargs):
            if current_user['username']:
                print('已经登录过了,无需再次登陆')
                res=func(*args,**kwargs)
                return res

            if engine == 'file':
                inp_user = input('please input your username: ').strip()
                inp_pwd = input('please input your password: ').strip()
                if inp_user == 'egon' and inp_pwd == '123':
                    print('login successfull')
                    current_user['username']=inp_user # 在登陆成功之后立刻记录登录状态
                    res=func(*args,**kwargs) # res=最原始那个index的内存地址(*args,**kwargs)
                    return res
                else:
                    print('username or password error')
            elif engine == 'mysql':
                print('基于mysql的认证机制')
            elif engine == 'ldap':
                print('基于ldap的认证机制')
            else:
                print('无法识别的认证源')
        return wrapper
    return auth

@login('file')  #@auth # index=auth(最原始那个index的内存地址) #index=wrapper
def index():
    print('welcome to index page')
    time.sleep(3)

@login('file')
def home(name):
    print('welcome %s to home page' %name)
    time.sleep(2)
    return 123


index() #wrapper()
res=home('egon')
print(res)

伪装真正的装饰器

'''
wraps装饰器应该加到装饰器最内层的函数上，wraps是别人已经写好的装饰器，加在装饰器内层函数上，括号内将原函数名写上，就可以将原函数中的全部内置方法赋值给
最内层对应函数的内置方法上，以达到真正的装饰效果，即客户调用index.__name__或help（index），查到wrapper的内存地址。
'''
from functools import wraps
import time


def deco(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        res = func(*args, **kwargs)
        return res
    # wrapper.__name__=func.__name__
    # wrapper.__doc__=func.__doc__
    return wrapper

@deco #index=deco(index) #index=wrapper函数的内存地址
def index():
    """
    index 功能
    """
    print('welcome to index page')
    time.sleep(3)

# print(index.__name__)  # 仍然是wrapper，如果客户查看index的函数名，发现是wrapper就露馅了，
# print(help(index)) #index.__doc__  __doc__查看函数内部注释信息

# index()  # wrapper

print(index.__name__)
print(index.__doc__)