python装饰器案例

一、装饰器说明
1.Python装饰器是一种强大的语法特性，允许用户在不修改
原有函数定义的情况下，动态的给函数添加功能。
2.装饰器本质上是一个可以被调用的对象，通常是函数或者类
3.装饰器的语法糖为@decorator_name放置在函数定义之前，相当于
执行了func = decorator(func)的操作
4.在python中，函数是一等对象，函数可以像普通变量一样被传递，赋值，和返回。

二、装饰器案例一
def my_decorator(func):
def wrapper(*args,**kwargs):
print("before")
result = func(*args,**kwargs)
print("after")
return result

return wrapper

@my_decorator
def say_hello():
print("hello!")

####say_hello=my_decorator(say_hello)

say_hello()

三、案例二
import time

def timer(func):
def wrapper(*args,**kwargs):
start = time.time()
result = func(*args,**kwargs)
end = time.time()
print(f"{func.__name__}执行耗时:{end-start:.4f}秒")
return result
return wrapper

@timer
def slow_function():
time.sleep(1)

slow_function()

四、案例三
def repeat(n):
def decorator(func):
def wrapper(*args,**kwargs):
for _ in range(n):
result = func(*args,**kwargs)
return result
return wrapper
return decorator

@repeat(3)
def greet(name):
print(f"hello{name}")

greet("Alice")

其中语法糖@repeat(3) 相当于 greet = repeat(3)(greet)

五、多个装饰器修饰
当使用多个装饰器的时候，执行顺序是从下往上执行，
也就是靠近函数的装饰器先执行。
@decorator1
@decorator2
def func():
pass

# 等价于 func = decorator1(decorator2(func))
调用时，执行顺序是 decorator1 的包装代码 → decorator2 的包装代码 → 原函数 → decorator2 的收尾代码 → decorator1 的收尾代码（即类似洋葱模型）。

六、内置装饰器
Python 提供了几个常用的内置装饰器：
@staticmethod：将类中的方法定义为静态方法，无需实例即可调用。
@classmethod：定义类方法，第一个参数为类本身（cls）。
@property：将方法转换为属性访问，可以添加 @<name>.setter 和 @<name>.deleter 实现更细粒度的控制。
这三种内置装饰器的使用需要注意！！！！

1.关于类中的静态方法使用
@staticmethod
func()
@staticmethod是将类中的方法定义为静态方法，不需要实例化即可调用。
1.关于@staticmethod静态方法，不需要self或者cls参数，类似普通函数，但是这个普通函数放在类
的命名空间中。
2.将类中的方法使用@staticmethod修饰后，此方法就编程了静态方法。静态方法是不需要访问实例self
或者类cls的。静态函数就类似定义在类内部的普通函数，这个函数可以使用类来调用访问，也可以使用
类的实例来调用。
3.也就是说，这个静态函数的命名空间就是这个class类。既然这个静态函数的作用域是在类中，那么，
这个类可以访问这个静态函数，这个类的实例对象也可以访问这个静态函数。
class MyClass:
@staticmethod
def method_name(args):
# 方法体
pass

#class类访问静态函数method_name
MyClass.method_name("hello")

newclass = MyClass()
newclass.method_name("hello")

静态函数的特点：
1.无需传入 self 或 cls 参数。
2.可以通过类名直接调用，也可以通过实例调用。
3.不能访问实例属性或类属性（除非通过类名显式引用）。

class Calculator:
@staticmethod
def add(x, y):
return x + y

@staticmethod
def multiply(x, y):
return x * y

# 使用类名调用静态方法
print(Calculator.add(3, 5)) # 8
print(Calculator.multiply(4, 6)) # 24

# 使用类实例也可以通过实例调用
calc = Calculator()
print(calc.add(10, 20)) # 30

关于类方法:@classmethod

class Person:
create_str = "person class"
def __init__(self,name,age):
self.name = name
self.age = age

@classmethod
def create_anonymous(cls):
# 工厂方法：返回一个匿名的人
return cls("Anonymous", 0)

@classmethod
def get_species(cls):
return cls.create_str

# 调用类方法
p = Person.create_anonymous()
print(p.name, p.age) # Anonymous 0
print(Person.get_species()) # Homo sapiens

七、类装饰器
class CountCalls:
def __init__(self, func):
self.func = func
self.count = 0

def __call__(self, *args, **kwargs):
self.count += 1
print(f"调用 {self.func.__name__} 第 {self.count} 次")
return self.func(*args, **kwargs)

@CountCalls
def say_hi():
print("Hi!")

say_hi() # 调用 say_hi 第 1 次
say_hi() # 调用 say_hi 第 2 次

八、保留原函数信息（functools.wraps）
from functools import wraps

def my_decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
"""包装函数"""
return func(*args, **kwargs)
return wrapper

@my_decorator
def example():
"""原函数文档"""
pass

######### example = my_decorator(example)
######### my_decorator(example)------

print(example.__name__) # 'example' 而不是 'wrapper'
print(example.__doc__) # '原函数文档' 而不是 '包装函数'