python3安装时闪退

闭包装饰器

• 前提
  – 首先要明白引用和赋值
  – 函数名仅仅是个变量，只不过指向了定义的函数而已，所以才能通过函数名()调用，如果函数名=xxx被修改了，那么当在执行 函数名()时，调用的就不知之前的那个函数了

可以确定一点就是 函数名只是一个对象，和普通对象一样，这个对象可以引用其他函数的代码

• 为什么要使用装饰器？
  – 写代码要遵循开放封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，既：
  — 封闭：已实现的功能代码块
  — 开放：对扩展开发

---

闭包

• 概念
  – 内部函数和使用的外部函数提供的变量构成的整体称为闭包
  – 闭包就是一个嵌套定义的函数，在外层运行时才开始内层函数的定义，然后将内部函数的引用传递函数外的对象
• 注意点
  –由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存
• 特点
  —具有提高代码可复用性的作用
  —代码的可移植性

def test(num):
    # print("mun={num}".format(num=num))

    def test_within(num_in):
        # 内部函数访问外部变量num
        # print("num_in={num_in}".format(num_in=num_in))
        return num + num_in

    return test_within


t_2 = test(20)
print(t_2)  # 返回 test_within 函数的引用

print(t_2(100))  # 执行了 test_within ===> t_2(100) = test_within(100)
print("*"*20)

print(t_2(200))

执行结果

<function test.<locals>.test_within at 0x0000022BD8996620>
120
********************
220

---

装饰器

• 作用：
  – 装饰器在我们需要一个函数功能进行扩展而又不想去修改代码的时候使用。
  – 装饰器能够将一个函数的功能在不修改代码的情况下进行扩展
• 应用场景

• 引入日志
• 函数执行时间统计
• 执行函数前预备处理
• 执行函数后清理功能
• 权限校验等场景
• 缓存 等

• 分类

• 函数装饰器
• 类装饰器

函数装饰器

# 1. 修饰前的test(最先定义的test)是由func指向的
# 2. 修饰后的 test 其实就是call_fun
# 3. 装饰器不会更改原先函数的返回值和调用方式。
# 4. func , call_fun 的参数 和原先 test 保持一致

# 万能装饰器
 def set_fun(func):
        def call_fun(*args, **kwargs):
                #..........(额外添加的功能)
                return func(*agrs，**kwargs)
        return call_fun

 @set_fun
  def test(1,2)
        print("被装饰函数")

类装饰器

# 类装饰器

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

    # 实例对象()调用call方法
    def __call__(self, *args, **kwargs):
        print("添加额外的功能 ")
        self.func()  # 原先的函数


@MyFun  # test = MyFun(test)
def test():
    print("test")


test()

修改外层函数的值

def set_value(value):
    def call_value():
        nonlocal value  # 修改外层参数的值必须使用nonlocal修改,如果修改全局变量使用global

        value += 1
        print(value)

    return call_value


call_value = set_value(10000)
call_value()

装饰器传参（重点）

函数装饰器传参

from time import ctime, sleep


def timefun_arg(pre="hello"):
    def timefun(func):
        def wrapped_func():
            print("%s called at %s %s" % (func.__name__, ctime(), pre))
            return func()

        return wrapped_func

    return timefun


# 下面的装饰过程
# 1. 调用timefun_arg("java")
# 2. 将步骤1得到的返回值，即time_fun返回， 然后time_fun(foo)
# 3. 将time_fun(foo)的结果返回，即wrapped_func
# 4. 让foo = wrapped_fun，即foo现在指向wrapped_func
@timefun_arg("java")
def foo():
    print("I am foo")


@timefun_arg("python")
def too():
    print("I am too")


foo()
sleep(2)
foo()

too()
sleep(2)
too()

执行结果：

foo called at Mon Aug 27 17:12:45 2018 java
I am foo
foo called at Mon Aug 27 17:12:47 2018 java
I am foo
too called at Mon Aug 27 17:12:47 2018 python
I am too
too called at Mon Aug 27 17:12:49 2018 python
I am too

类装饰器传参

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

    def __call__(self, *args, **kwargs):
        print("已经额外增加了功能")
        self.func()

    @staticmethod
    def set_value(value):  # 添加语法糖后，先执行 set_value ，把其加入到内存中
        print("执行了set_value", value)
        return MyFun

    # @classmethod
    # def set_value(cls,value):
    #     print("执行了set_value", value)
    #     return cls


@MyFun.set_value("300")  # ====> 返回MyFun的引用，====> test = MyFun(test)
def test():
    print("基层函数")


test()

一个装饰器可以装饰多个函数，一个函数也可以被多个装饰器修饰

多个装饰器修饰一个函数

def set_fun1(func1):
    print("set_fun1")

    def call_fun1():
        print("call_fun1")
        func1()

    return call_fun1


def set_fun2(func2):
    print("set_fun2")

    def call_fun2():
        print("call_fun2")
        func2()

    return call_fun2


@set_fun2
@set_fun1
def test():
    print("test")


test()

执行结果：

set_fun1
set_fun2
call_fun2
call_fun1
test

• 多个装饰器修饰一个函数的执行顺序
  电梯法

先上后下，先外后内

秋裤法

先穿再拖，先外后内

一个装饰器装饰一个函数的内存流程图

两个装饰器装饰一个函数的内存流程图

总结：

装饰器函数只有一个参数就是被装饰的函数的应用
装饰器能够将一个函数的功能在不修改代码的情况下进行扩展
在函数定义的上方@装饰器函数名 即可直接使用装饰器对下面的函数进行装饰。