装饰器

定义

就是给已有函数增加额外功能的函数，它本质上就是一个闭包函数。

装饰器的功能特点:

1. 不修改已有函数的源代码
2. 不修改已有函数的调用方式
3. 给已有函数增加额外的功能

DEMO

# 添加一个登录验证的功能
def check(fn):
    def inner():
        print("请先登录....")
        fn()
    return inner


def comment():
    print("发表评论")

# 使用装饰器来装饰函数
comment = check(comment)
comment()

# 装饰器的基本雏形
# def decorator(fn): # fn:目标函数.
#     def inner():
#         '''执行函数之前'''
#         fn() # 执行被装饰的函数
#         '''执行函数之后'''
#     return inner

代码说明:

• 闭包函数有且只有一个参数，必须是函数类型，这样定义的函数才是装饰器。
• 写代码要遵循开放封闭原则，它规定已经实现的功能代码不允许被修改，但可以被扩展。
• 其实最后就是要把原来的函数指针指向指到装饰过的函数

执行结果:

请先登录....
发表评论

语法糖写法

语法糖的书写格式是: @装饰器名字，通过语法糖的方式也可以完成对已有函数的装饰

# 添加一个登录验证的功能
def check(fn):
    print("装饰器函数执行了")
    def inner():
        print("请先登录....")
        fn()
    return inner

# 使用语法糖方式来装饰函数
@check
def comment():
    print("发表评论")


comment()

说明:

• @check 等价于 comment = check(comment)
• 装饰器的执行时间是加载模块时立即执行。
• 执行完后就已经指向inner函数了

执行结果:

请先登录....
发表评论

装饰带有参数的函数

# 添加输出日志的功能
def logging(fn):
    def inner(num1, num2):
        print("--正在努力计算--")
        fn(num1, num2)

    return inner


# 使用装饰器装饰函数
@logging
def sum_num(a, b):
    result = a + b
    print(result)


sum_num(1, 2)

装饰什么函数，在inner那个地方就应该跟装饰的函数的形参列表一样。

装饰带有返回值的函数

# 添加输出日志的功能
def logging(fn):
    def inner(num1, num2):
        print("--正在努力计算--")
        result = fn(num1, num2)
        return result
    return inner


# 使用装饰器装饰函数
@logging
def sum_num(a, b):
    result = a + b
    return result


result = sum_num(1, 2)
print(result)

运行结果:

--正在努力计算--
3

装饰带有不定长参数的函数

# 添加输出日志的功能
def logging(fn):
    def inner(*args, **kwargs):
        print("--正在努力计算--")
        # 这里写*args和**kwargs的原因是，在参数列表中的*args表示一个元组，在对其传参时
        fn(*args, **kwargs)

    return inner


# 使用语法糖装饰函数
@logging
def sum_num(*args, **kwargs):
    result = 0
    for value in args:
        result += value

    for value in kwargs.values():
        result += value

    print(result)

sum_num(1, 2, a=10)

运行结果:

--正在努力计算--
13

说明

# 函数一
# def fun(a, b, *args, **kwargs):
#     print(a)
#     print(b)
#     print(args)
#     print(kwargs)
#
# fun(1, 2, 3, 4, name = "hello", age = 20)
#
# 结果：
# 2
# (3, 4)
# {'name': 'hello', 'age': 20}

# 函数二
# def fun(a, b, *args, **kwargs):
#     print(a)
#     print(b)
#     print(args)
#     print(kwargs)
#
# tup = (11,22,33)
# dic = {"name":"hello", "age":20}
# fun(1, 2, *tup, **dic)
#
# 结果：
# 2
# (11, 22, 33)
# {'name': 'hello', 'age': 20}

'''
通过对比函数一和函数二，可以得出，如果在传参时，传给args或者kwargs不是直接以元组或者字典传的
像这句fun(1, 2, 3, 4, name = "hello", age = 20)，当中，1，2对应a,b,但3,4就会被自动组包成一个元组，
后面的name和age也会组包成一个字典。
像函数二，直接传元组和字典，在传参时，就要用*args和**dic传递
'''

# 所以在inner里面传值时，inner的参数列表中就已经组好包了，在inner函数里面，给fn传参数就需要像函数二一样传
# 就是在定义时就已经是组包了，在闭包里使用传进来的参数，需要解包

多个装饰器使用

def make_div(func):
    """对被装饰的函数的返回值 div标签"""
    def inner(*args, **kwargs):
        return "<div>" + func() + "</div>"
    return inner


def make_p(func):
    """对被装饰的函数的返回值 p标签"""
    def inner(*args, **kwargs):
        return "<p>" + func() + "</p>"
    return inner


# 装饰过程: 1 content = make_p(content) 2 content = make_div(content)
# content = make_div(make_p(content))
@make_div
@make_p
def content():
    return "人生苦短"

result = content()

print(result)

代码说明:

• 多个装饰器的装饰过程是: 离函数最近的装饰器先装饰，然后外面的装饰器再进行装饰，由内到外的装饰过程

其实就是每个装饰器函数的func不一样，make_p的func指向原始的content，make_div的fun指向被make_p装饰后的content，也就是make_p的inner

带有参数的装饰器

在装饰器外面再包裹上一个函数，让最外面的函数接收参数，返回的是装饰器，因为@符号后面必须是装饰器实例。

# 添加输出日志的功能
def logging(flag):

    def decorator(fn):
        def inner(num1, num2):
            if flag == "+":
                print("--正在努力加法计算--")
            elif flag == "-":
                print("--正在努力减法计算--")
            result = fn(num1, num2)
            return result
        return inner

    # 返回装饰器
    return decorator


# 使用装饰器装饰函数
@logging("+")
def add(a, b):
    result = a + b
    return result


@logging("-")
def sub(a, b):
    result = a - b
    return result

result = add(1, 2)
print(result)

result = sub(1, 2)
print(result)

使用带有参数的装饰器，其实是在装饰器外面又包裹了一个函数，使用该函数接收参数，返回是装饰器，然后 @ 符号需要配合装饰器实例使用

类装饰器

装饰器还有一种特殊的用法就是类装饰器，就是通过定义一个类来装饰函数。

类装饰器示例代码:

class Check(object):
    def __init__(self, fn):
        # 初始化操作在此完成
        self.__fn = fn

    # 实现__call__方法，表示对象是一个可调用对象，可以像调用函数一样进行调用。
    def __call__(self, *args, **kwargs):
        # 添加装饰功能
        print("请先登陆...")
        self.__fn()


@Check
def comment():
    print("发表评论")


comment()

• @Check 等价于 comment = Check(comment), 所以需要提供一个init方法，并多增加一个fn参数。
• 要想类的实例对象能够像函数一样调用，需要在类里面使用call方法，把类的实例变成可调用对象(callable)，也就是说可以像调用函数一样进行调用。
• 在call方法里进行对fn函数的装饰，可以添加额外的功能。

执行结果:

请先登陆...
发表评论

property属性

property属性就是负责把一个方法当做属性进行使用，这样做可以简化代码使用。

定义property属性有两种方式

1. 装饰器方式
2. 类属性方式

装饰器方式

class Person(object):

    def __init__(self):
        self.__age = 0

    # 装饰器方式的property, 把age方法当做属性使用, 表示当获取属性时会执行下面修饰的方法
    @property
    def age(self):
        return self.__age

    # 把age方法当做属性使用, 表示当设置属性时会执行下面修饰的方法
    @age.setter
    def age(self, new_age):
        if new_age >= 150:
            print("成精了")
        else:
            self.__age = new_age

# 创建person
p = Person()
print(p.age)
p.age = 100
print(p.age)
p.age = 1000

运行结果:

0
100
成精了

代码说明:

• @property 表示把方法当做属性使用, 表示当获取属性时会执行下面修饰的方法
• @方法名.setter 表示把方法当做属性使用,表示当设置属性时会执行下面修饰的方法
• 装饰器方式的property属性修饰的方法名一定要一样。

类属性方式

class Person(object):

    def __init__(self):
        self.__age = 0

    def get_age(self):
        """当获取age属性的时候会执行该方法"""
        return self.__age

    def set_age(self, new_age):
        """当设置age属性的时候会执行该方法"""
        if new_age >= 150:
            print("成精了")
        else:
            self.__age = new_age

    # 类属性方式的property属性
    age = property(get_age, set_age)

# 创建person
p = Person()
print(p.age)
p.age = 100
print(p.age)
p.age = 1000

运行结果:

0
100
成精了

代码说明:

• property的参数说明:

  • 第一个参数是获取属性时要执行的方法
  • 第二个参数是设置属性时要执行的方法

小结

• 定义property属性有两种方式:

  1. 装饰器方式
  2. 类属性方式

• 装饰器方式:

  1. @property 修饰获取值的方法
  2. @方法名.setter 修饰设置值的方法

• 类属性方式:

  1. 类属性 = property(获取值方法, 设置值方法)