Python之闭包函数、装饰器

1、闭包函数

#作用域关系在函数定义阶段时就已经固定死了，与调用位置无关
# 即：在任意位置调用函数都需要跑到定义函数时寻找作用域关系

# def f1():
#     x=1
#     def inner():
#         print(x)   #闭包的含义：内部函数中的变量x引用外部作用域的x，而非全局作用域的x
#     return inner
# func=f1()          #f1()=inner
#
#
# def f2():
#     x=111111
#     func()        #func()=inner()
# f2()


# 闭包函数：
# 闭指的是：该函数是一个内部函数
# 包指的是：指的是该函数包含对外部作用域（非全局作用域）名字的引用
# def outter():
#     x = 1
#     def inner():
#         print(x)        #内部函数inner中的x是对外部作用域的引用，而非全局作用域的引用
#
#     return inner
#
# f=outter()
#
# def f2():
#     x=1111111
#     f()
#
# f2()
#
#
# def f3():
#     x=4444444444444
#     f()
#
# f3()


# 为函数传值的两种方式：
# 为函数体传值的方式一：使用参数的形式
# def inner(x):
#     print(x)
#
# inner(1)
# inner(1)
# inner(1)


# 为函数体传值的方式二：包给函数
'''
def outter(x):
    # x=1
    def inner():
        print(x)    #通过闭包函数将值报给内部函数
    return inner

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


# 例子：
# 方法一：通过传参的形式将值传给函数内的变量
# import requests
# def get(url):
#     response=requests.get(url)
#     if response.status_code == 200:
#         print(response.text)
#
# get('https://www.baidu.com')
# get('https://www.baidu.com')
# get('https://www.baidu.com')
#
# get('https://www.python.org')
# get('https://www.python.org')
# get('https://www.python.org')
# get('https://www.python.org')


# 方法二：通过闭包函数将值包给其内部的函数
import requests
def outter(url):                             #通过传参的形式，可以爬去任意网页的源代码
    # url='https://www.baidu.com'            #功能被写死，所以改成传参的形式
    def get():
        response=requests.get(url)           #url是通过outter函数，将值包给函数get内的函数体代码用的
        if response.status_code == 200:      #成立说明，成功爬去网页的源代码
            print(response.text)
    return get                               #返回get给外部的调用者，打破层级的限制(函数对象的知识)

baidu=outter('https://www.baidu.com')        #本质就是传入了参数的get的内存地址
python=outter('https://www.python.org')


baidu()                                      #本质就是已经给url传入了参数的get的内存地址，加括号即调用
baidu()

python()
python()

 

2、装饰器

'''
1、什么是装饰器
    器指的是工具，而程序中的函数就具备某一功能的工具
    装饰指的是为被装饰器对象添加额外功能

    就目前的知识来看：
        定义装饰器就是定义一个函数，只不过该函数的功能是用来为
        其他函数添加额外的功能

    其实：
        装饰器本身其实可以是任意可调用的对象
        被装饰的对象也可以是任意可调用的对象


2、为什么要用装饰器
    软件的维护应该遵循开放封闭原则
    开放封闭原则指的是：
        软件一旦上线运行后对修改源代码是封闭的，对扩展功能的是开放的
        这就用到了装饰器

    装饰器的实现必须遵循两大原则：
        1、不修改被装饰对象的源代码
        2、不修改被装饰对象的调用方式
    装饰器其实就在遵循1和2原则的前提下为被装饰对象添加新功能

3、如何用装饰器
'''


# 方式一
# 给原函数添加上了新功能，没有改变原函数的调用方式，但是却改变了源代码
import time
# def index():
#     start=time.time()
#     print('welcom to index')
#     time.sleep(3)
#     stop=time.time()
#     print('run time is %s' %(stop-start))
# index()

# 方法二
# 没有改变源代码，也没有改变调用方式，但是给不同函数扩展相同的功能时，是在重复写代码的过程
import time
# def index():
#     print('welcom to index')
#     time.sleep(3)
#
# def f2():
#     print('from f2')
#     time.sleep(2)

# 以下为两个函数添加上了引得功能，但是重复写代码
# start=time.time()
# index()
# stop=time.time()
# print('run time is %s' %(stop-start))
# #
# start=time.time()
# f2()
# stop=time.time()
# print('run time is %s' %(stop-start))


# 方法三
# 将重复写代码的过程，定义为一个函数的功能，虽然没有该源代码，但是改变了函数的调用方式
# import time
#
# def index():
#     print('welcom to index')
#     time.sleep(3)
#
# def timmer(func):
#     start=time.time()
#     func()
#     stop=time.time()
#     print('run time is %s' %(stop-start))
#
# timmer(index)

# 方法四
# 利用闭包函数，为函数添加上新的功能

'''
import time
def index():
    print('welcom to index')
    time.sleep(3)

def timmer(func): #func=最原始的index
    # func=index           #这样就把被装饰的对象写死了，所以需要以传参的形式将，被装饰的函数传进来
    def inner():
        start=time.time()
        func()
        stop=time.time()
        print('run time is %s' %(stop-start))
    return inner

# f=timmer(index)
# f()

# index=timmer(被装饰函数的内存地址)
index=timmer(index) #index=inner

index() #inner()


'''
import time

def index():
    print('welcom to index')
    time.sleep(3)

def timmer(func):        #将被装饰的函数传进来，不至于将被装饰的对象写死，固定是某一个，而是可以装饰任意一个函数
    #func=最原始的index ，即被装饰函数的的内存地址
    def wrapper():       #该函数即是为被装饰函数添加上的新功能
        start=time.time()
        func()           #最原始的index加括号即使调用最原始的函数
        stop=time.time()
        print('run time is %s' %(stop - start))
    return wrapper       #函数对象知识：返回给外部函数调用，打破层级限制

index=timmer(index)      #左边的index=wrapper函数的内存地址，右边的index即是我们要装饰的函数
index()                  #本质调用的是wrapper函数

三、装饰器修正

 

import time
def index():                                    #被装饰的函数无参，有返回值
    print('welcome to index')
    time.sleep(3)
    return 123

def home(name):                                #被装饰的函数有参，没有返回值
    print('welcome %s to home page' %name)
    time.sleep(2)


def timmer(func):
    #func=最原始的index
    def wrapper(*args,**kwargs):                #wrapper会将接收的参数，原封不动的传给被装饰的函数
        start=time.time()
        res=func(*args,**kwargs)                #因为被装饰的对象可能有的有参，有的是无惨，所以调用时用*args,**kwargs，无论有无参数都不会报错
        stop=time.time()
        print('run time is %s' %(stop - start))
        return res                              #接收被装饰函数的返回值，被装饰的函数没有返回值则为None，有则返回被装饰的返回值
    return wrapper                              #该返回值则是返回给外部函数用的，可以打破层级的限制，这样内部函数即给被装饰函数添加的新功能就可以被调用到


index=timmer(index)                             #将被装饰的函数传入，调用装饰器，本质就是调内部被加上新功能的函数
home=timmer(home)                               #将被装饰的函数传入，调用装饰器，本质就是调内部被加上新功能的函数

res=index()                                     #拿到调用函数的返回值，打印即可看到返回值
home('egon')                                    #被装饰的函数为有参，为被装饰函数进行传参
print(res)

#装饰器语法糖
# 在被装饰对象正上方，并且是单独一行写上@装饰器名
# import time
# def timmer(func):
#     #func=最原始的index
#     def wrapper(*args,**kwargs):
#         start=time.time()
#         res=func(*args,**kwargs)
#         stop=time.time()
#         print('run time is %s' %(stop - start))
#         return res
#     return wrapper
#
# @timmer # index=timmer(index)   #timmer即一个名字，所以装饰器的代码块要写在timmer的上方，@timmer本质就是调用了timmer(传入被装饰的函数名)
# def index():
#     print('welcome to index')
#     time.sleep(3)
#     return 123
#
# @timmer # home=timmer(home)
# def home(name):
#     print('welcome %s to home page' %name)
#     time.sleep(2)
#
# res=index()
# home('egon')


# 装饰器的万能模板：
def deco(func):                   #func即是要接收的被砖石的函数名
    def wrapper(*args,**kwargs):  #可以根据被装饰的函数需不需要传参，给被装饰的对象传入参数
        res=func(*args,**kwargs)  #本质就是调用被装饰的函数， 接收传进来的参数
        return res                #接收被装饰函数的返回值，没有则返回None
    return wrapper                #外部函数将内部函数的内存地址返回，打破层级限制