Python装饰器、类方法扩展和元类管理实例(Python装饰器、类方法扩展与元类管理实战案例)

原创

ithorizon 6个月前 (10-20) 阅读数 29 #后端开发

Python装饰器、类方法扩展与元类管理实战案例

一、Python装饰器

Python装饰器是一种特殊类型的函数，用于修改其他函数的功能。装饰器本质上是一个接受函数作为参数并返回一个新函数的函数。在Python中，装饰器广泛应用于权限校验、日志记录、输入数据检查等功能。

1.1 装饰器的基本使用

下面是一个明了的装饰器示例，用于打印函数执行前后的日志信息：


def log_decorator(func):
    def wrapper(*args, **kwargs):
        print("函数{}起始执行".format(func.__name__))
        result = func(*args, **kwargs)
        print("函数{}执行完成".format(func.__name__))
        return result
    return wrapper
@log_decorator
def say_hello():
    print("Hello, world!")
say_hello()

1.2 装饰器进阶：带参数的装饰器

装饰器本身也可以接受参数，实现更纷乱的功能。下面是一个带参数的装饰器示例，用于设置日志级别：


def log_decorator(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if level == "DEBUG":
                print("函数{}起始执行".format(func.__name__))
            result = func(*args, **kwargs)
            if level == "DEBUG":
                print("函数{}执行完成".format(func.__name__))
            return result
        return wrapper
    return decorator
@log_decorator("DEBUG")
def say_hello():
    print("Hello, world!")
say_hello()

二、类方法扩展

在Python中，类方法扩展指的是在不修改原有类定义的情况下，为类添加新的方法或属性。这可以通过继承、混入（Mixin）等做法实现。

2.1 通过继承扩展类方法

下面是一个通过继承扩展类方法的示例，为原有的Human类添加一个新的方法run：


class Human:
    def __init__(self, name):
        self.name = name
    def walk(self):
        print(f"{self.name} 正在走路")
class Athlete(Human):
    def run(self):
        print(f"{self.name} 正在跑步")
human = Human("小明")
athlete = Athlete("小李")
human.walk()
athlete.walk()
athlete.run()

2.2 通过混入（Mixin）扩展类方法

混入是一种特殊的类，用于实现代码复用。下面是一个通过混入扩展类方法的示例，为Human类添加一个新的方法fly：


class FlyMixin:
    def fly(self):
        print(f"{self.name} 正在飞行")
class Human:
    def __init__(self, name):
        self.name = name
    def walk(self):
        print(f"{self.name} 正在走路")
class HumanWithFly(Human, FlyMixin):
    pass
human = Human("小明")
human_with_fly = HumanWithFly("小李")
human.walk()
human_with_fly.walk()
human_with_fly.fly()

三、元类管理实例

元类是Python中的一种特殊类型的类，用于创建和管理其他类的实例。元类可以用来实现单例模式、代理模式等设计模式。

3.1 使用元类实现单例模式

下面是一个使用元类实现单例模式的示例：


class SingletonMeta(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        return cls._instances[cls]
class Singleton(metaclass=SingletonMeta):
    def some_method(self):
        print("这是一个单例方法")
singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # 输出 True，证明是同一个实例

3.2 使用元类实现代理模式

下面是一个使用元类实现代理模式的示例，代理一个明了的Calculator类：


class ProxyMeta(type):
    def __call__(cls, *args, **kwargs):
        instance = super().__call__(*args, **kwargs)
        proxy = Proxy(instance)
        return proxy
class Calculator:
    def add(self, x, y):
        return x + y
    def subtract(self, x, y):
        return x - y
class Proxy:
    def __init__(self, target):
        self.target = target
    def __getattr__(self, name):
        return getattr(self.target, name)
    def __setattr__(self, name, value):
        if name == "target":
            super().__setattr__(name, value)
        else:
            setattr(self.target, name, value)
class ProxyCalculator(Calculator, metaclass=ProxyMeta):
    pass
proxy_calculator = ProxyCalculator()
print(proxy_calculator.add(10, 5))  # 输出 15
print(proxy_calculator.subtract(10, 5))  # 输出 5