面向对象+闭包装饰器

思维导图

面向对象-super关键字

作用：找到指定类的mro下一级

• 类的属性和方法的继承

class A():
    name = 'zs'
    def fn():
        print('fn')
class B(A):
    pass

直接继承了A的name和fn

• 类的动态属性和方法的继承

class A():
    def __init__(self):
        self.name = 'zs'
        self.age = 18
        
a = A()
a会拥有name和age属性
class B(A):
    pass
b = B()
b有没有name和age？有的，直接继承了A的__init__，所以实例化的时候也会调用

----------------------------------------------------------------------------------
class A():
    def __init__(self):
        self.name = 'zs'
        self.age = 18
        
a = A()
a会拥有name和age属性
class B(A):
    def __init__(self):
        # 继承的属性
        A.__init__(self)
        # 自己再添加额外的属性
        self.money = 100000
b = B()
b有没有name和age？重写以后需要手动调用一次才能实现继承
混合继承 = 类的属性/方法 + 动态属性/方法

垃圾回收机制

如果一个变量无法访达，就会被认定为垃圾，系统会自动回收这个变量

闭包

核心：绕开垃圾回收机制的高级编程技巧

实现：

1.有嵌套

2.有引用

3.有返回（返回的东西叫闭包）

def outer_fn(age):  #外部函数的变量有两种：1.外部函数内部定义的变量  2.外部函数的形参
    name = '123'
    1.外部函数嵌套内部函数
    def inner_fn():
        2.内部函数访问外部函数的变量
        print(name)
        # 如果内部函数需要修改外部函数变量
        nonlocal age
        age+=1
        print(age)
    3.外部函数返回内部函数
    return inner_fn

bibao = outer_fn()
# bibao是一个函数
bibao() #使用闭包是为了访问函数内部变量
print(bibao()) #None,没有意义！

关键点：
1. return 表示函数返回的内容
2. 函数的调用，fn()，相当于获取函数执行的结果，也就是fn的return的内容

装饰器的实现

内置装饰器：

​ 类的方法默认叫做构造方法 - def fn(self):

​ @staticmethod:给类的方法进行装饰，将类的方法改造为静态方法 - def fn():

​ @classmethod：给类的方法进行装饰，将类的方法改造为类方法 - def fn(cls):

面向对象里面可以用装饰器，也学习了装饰器，但是：面向对象不会和自定义装饰器结合使用

---

实现：

1.有嵌套

2.有引用

3.有返回（返回的东西叫闭包）

4.有实现内容

装饰器的分类

• 无参数无返回值

def check(fn):
    def inner_fn():
        fn()
    return inner_fn

手搓：
def work():
    print('work')
1.通过check装饰work,构造一个新的fn
new_fn = check(work)
2.新的fn调用才能实现效果
new_fn()

语法糖：
@check
def work():
    print('work')
work()

• 有参数无返回值

def check(fn):
    def inner_fn(a,b):
        fn(a,b)
    return inner_fn

手搓：
def work(a,b):
    print(a+b)
1.通过check装饰work,构造一个新的fn
new_fn = check(work)
2.新的fn调用才能实现效果
new_fn(1,2)

语法糖：
@check
def work(a,b):
    print(a+b)
work(1,2)

• 无参数有返回值

def check(fn):
    def inner_fn():
        res = fn()
        return res
    return inner_fn

手搓：
def work():
    return 'work'
1.通过check装饰work,构造一个新的fn
new_fn = check(work)
2.新的fn调用才能实现效果
print(new_fn())

语法糖：
@check
def work():
    return 'work'
print(work())

• 有参数有返回值

def check(fn):
    def inner_fn(a,b):
        res = fn(a,b)
        return res
    return inner_fn

手搓
def work(a,b):
    return a+b
new_fn = check(work)
print(new_fn(1,2))

语法糖
@check
def work(a,b):
    return a+b
print(work(1,2))

• 通用装饰器

def check(fn):
    def inner_fn(*args,**kwargs):
        res = fn(*args,**kwargs)
        return res
    return inner_fn

手搓
def work(*args,**kwargs):
    sum = 0 
    # 位置参数的求和
    for i in args:
        sum += i
    # 关键字参数求和
    for i in kwargs.values():
        sum += i
    return sum
new_fn = check(work)
print(new_fn(1,2,a=1,b=2))

语法糖
@check
def work(*args,**kwargs):
        sum = 0 
    # 位置参数的求和
    for i in args:
        sum += i
    # 关键字参数求和
    for i in kwargs.values():
        sum += i
    return sum
print(work(1,2,a=1,b=2))

装饰器的其他使用（了解）

多装饰器的使用

def login(fn):
	def inner_fn():
        ------------------
        print('登录成功~')
        ------------------
        fn()
    return inner_fn
def comment(fn):
	def inner_fn():
        ------------------
        print('评论成功~')
        ------------------
        fn()
    return inner_fn
#效果：执行顺序从上到下
#原理：装饰的顺序从下到上
@login
@comment
def like():
    print('点赞')
    

装饰器参数的使用

def flag(flag):
	def outer_fn(fn):
   	 	def inner_fn():
            # 根据装饰器参数，内部实现不同逻辑
           	if flag =='+':
                print('执行了加法')
            else:
                print('执行了减法')
			fn()
   	 	return inner_fn
    
@flag('+')
def calc1(a,b):
    return a+b

@flag('-')
def calc2(a,b):
    return a+b