python 闭包 如何使用闭包 使用闭包添加日志功能 装饰器的基本使用 多个装饰器的使用 指定参数个数的通用装饰器 类装饰器的使用

**

1，什么是闭包

**
1，闭包本质就是函数，但是这个函数有点特殊

**

2，如何创建闭包

**
1，嵌套函数定义（外部函数和内部函数）

2，内部函数使用外部函数中定义的变量

3，外部函数一定要有返回值，返回内部函数名

以上是创建闭包的三个必要条件，缺一不可

**

def funcOut1(func):
    def funcIn(a):
        print("新增功能1")
        func(a)
    return funcIn

def func1(a):
    print("a = %g " % a)
print(func1)

func1 = funcOut1(func1)

func1(5)

print(func1)

运行结果为：

<function func1 at 0x000001C178B62048>
新增功能1
a = 5 
<function funcOut1.<locals>.funcIn at 0x000001C178B620D0>

3，如何使用闭包

**
需求：使用闭包，完成两个数字的求和

def funcOut(num1):
    def funcIn(num2):
        return num1 + num2
    return funcIn

a = 10
b = 20
f = funcOut(a)
print(type(f))
result = f(b)
print(result)

运行结果为：

<class 'function'>
30

def funcOut(num1):
    def funcIn(num2):
        nonlocal num1       	# 如果想在内部函数中修改 外部函数中定义的局部变量
        num1 += 1               # 需要用 nonlocal 声明一下
        return num1 + num2
    return funcIn

a = 10
b = 20
f = funcOut(a)
result = f(b)
print(result)

需求，使用闭包求两点之间的距离

import math
def funcOut(x1,y1):
    def funcIn(x2,y2):
        return math.sqrt((x1-x2)**2 + (y1-y2)**2)
    return funcIn

funcIn = funcOut(0,0)
result1 = funcIn(10,10)
result2 = funcIn(20,20)
print("10,10距原点的距离是",result1)
print("20,20距原点的距离是",result2)

运行结果为：

10,10距原点的距离是 14.142135623730951
20,20距原点的距离是 28.284271247461902

**

4，使用闭包添加日志功能的引用

**

1，闭包的特殊用途：可以在不修改现有功能源码的前提下，增加新的功能。
2，日志功能：统计访问时间，访问功能，把统计的信息写到日志文件中
3，权限验证：例如验证当前账户是否为VIP会员
4，在开发过程中，有一个开闭原则。开放：对添加功能开放。关闭：对修改源代码关闭。所以不提倡修改别人的源代码

需求：在不修改源码的前提下，定义一个记录日志的函数：将访问的时间以及访问的函数名写入到文件中（log.txt）

import time
def writeLog(func):
    try:
        file = open("log.txt", "a", encoding="utf-8")
        file.write(func.__name__)  # 写入相关的数据信息:访问的函数名
        file.write("\t")
        file.write(time.asctime()) # 写入相关的数据信息:访问的时间
        file.write("\n")
    except Exception as e:
        print(e.args)
    finally:
        file.close()

def func1():
    writeLog(func1)
    print("我是功能1")

def func2():
    writeLog(func2)
    print("我是功能2")

func1()
func2()

注意：上面的代码它修改了源代码，不提倡用这种方式。

import time
def writeLog(func):
    try:
        file = open("log.txt", "a", encoding="utf-8")
        file.write(func.__name__)  # 写入相关的数据信息:访问的函数名
        file.write("\t")
        file.write(time.asctime()) # 写入相关的数据信息:访问的时间
        file.write("\n")
    except Exception as e:
        print(e.args)
    finally:
        file.close()

#闭包
def funcOut(func):
    def funcIn():
        writeLog(func)
        func()
    return funcIn

def func1():
    print("我是功能1")

def func2():
    print("我是功能2")

#闭包的调用
func1 = funcOut(func1)
func2 = funcOut(func2)

func1()
func2()

**

5，装饰器的基本使用

**
1，使用闭包在不修改源代码的前提下，在现有功能内添加新的功能
2，装饰器是和闭包结合使用的，可以让闭包的访问方式更简单。装饰器是和闭包息息相关的。
3，装饰器和闭包关系紧密，很多时候二者结合使用
4，装饰器可以更简化的让闭包进行调用

import time
def writeLog(func):
    try:
        file = open("log.txt", "a", encoding="utf-8")
        file.write(func.__name__)  # 写入相关的数据信息:访问的函数名
        file.write("\t")
        file.write(time.asctime()) # 写入相关的数据信息:访问的时间
        file.write("\n")
    except Exception as e:
        print(e.args)
    finally:
        file.close()

#闭包
def funcOut(func):
    def funcIn():
        writeLog(func)
        func()
    return funcIn

@funcOut        		# 等价于func1 = funcOut(func1)  @后面必须跟闭包的外部函数名字，不能随意写
def func1():
    print("我是功能1")

@funcOut        		# 等价于func2 = funcOut(func2)  @后面必须跟闭包的外部函数名字，不能随意写
def func2():
    print("我是功能2")

func1()
func2()

**

6，多个装饰器的使用

**
需求：使用装饰器完成：不修改一个函数源码的前提下，增加新的功能

def bookName():
    return "西游记"
print(bookName())

例如以上代码的输出结果为西游记，在不修改源码的前提下，使其输出结果改为《西游记》

def funcOut(func):
    def funcIn():
        return "《" + func() + "》"
    return funcIn

def bookName():
    return "西游记"

bookName = funcOut(bookName)
print(bookName())

或者

def funcOut(func):
    def funcIn():
        return "《" + func() + "》"
    return funcIn

@funcOut
def bookName():
    return "西游记"

print(bookName())

运行结果为：

《西游记》

当用多个装饰器的时候，装饰顺序是：最靠近函数的装饰器先执行，离函数远的装饰器后执行

def funcOut(func):
    print("闭包1开始装饰")
    def funcIn():
        return "《" + func() + "》"
    return funcIn

def funcOut2(func):
    print("闭包2开始装饰")
    def funcIn():
        return "$" + func() + "$"
    return funcIn

@funcOut2       #等价于bookName = funcOut2(bookName)
@funcOut        #等价于bookName = funcOut(bookName)
def bookName():
    return "西游记"

print(bookName())

运行结果为：

闭包1开始装饰
闭包2开始装饰
$《西游记》$

**

7，指定参数个数的通用装饰器

**

def funcOut1(func):
    def funcIn1(a):
        print("新增功能1")
        func(a)
    return funcIn1

def funcOut2(func):
    def funcIn2(n, m):
        print("新增功能2")
        func(n, m)
    return funcIn2

@funcOut1
def func1(a):
    print("a = %g " % a)

@funcOut2
def func2(n,m):
    print("n的值为%g m的值为%g" % (n, m))

func1(5)
func2(10, 20)

运行结果为：

新增功能1
a = 5 
新增功能2
n的值为10 m的值为20

注意：被修饰的函数可能有很多，不同的函数可能参数的个数不一致，这时，用通用装饰器会更实用方便。

以上修改后的代码为：

def funcOut(func):
    def funcIn(*args, **kwargs):
        print("新增功能")
        return func(*args, **kwargs)  # 被修饰的函数的返回值。如果函数不指定返回值的话，会返回None
    return funcIn


@funcOut  # 等价于 func1 = funcOut(func1)
def func1(a):
    print("a = %g " % a)


@funcOut  # 等价于 func2 = funcOut(func2)
def func2(n,m):
    print("n的值为%g m的值为%g" % (n, m))

func1(5)
func2(10, 20)

运行结果为：

新增功能
a = 5 
新增功能
n的值为10 m的值为20

**

8，类装饰器的使用

**
类装饰器的作用：在不修改源代码的前提下，增加新的功能

借助了一个类，在实现现有功能的情况下，不修改函数源码前提下，再增加新的功能

class AAA:
    def __init__(self, func):
        print("我是AAA的初始化方法")
        print(func)
        print(func.__name__)  	# func这个参数接收test函数
        self.__func = func    	# 也可以做成私有属性

    def __call__(self, *args, **kwargs):
        # print("在这可以新增任意功能")
        self.add_func()
        self.__func()

    def add_func(self):
        print("用户权限验证")
        print("日志系统处理")

        
@AAA        # 加一个类装饰器
# 相当于test = AAA(test) 类名加括号走init方法之后，得到一个对象，并存储到=前面的test里面
def test():  			# 不修改这个函数源代码的前提下，在调用的时候给这个函数增加新的功能
    print("我是功能1")

# 此时的test相当于一个对象，对象加()直接调用的话，会出现下面的错误
# TypeError: 'AAA' object is not callable重写call方法之后才能成为“可调用对象”
test()

运行结果为：

我是AAA的初始化方法
<function test at 0x000001BB804FCF28>
test
用户权限验证
日志系统处理
我是功能1