【Python进阶编程】python编程高手常用的设计模式(持续更新中)

Python编程高手通常熟练运用各种设计模式,这些设计模式有助于提高代码的可维护性、可扩展性和重用性。

以下是一些Python编程高手常用的设计模式:

1.单例模式(Singleton Pattern)

确保一个类只有一个实例,并提供全局访问点。适用于需要共享资源或控制特定资源访问的情景。

class Singleton(object):
    _instance = None

    def __new__(cls):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance


s1 = Singleton()
s2 = Singleton()
print(id(s1))
print(id(s2)) # s1和s2的ID应该是一样的,表明这是同一个对象

【Python进阶编程】python编程高手常用的设计模式(持续更新中)_第1张图片

其他实现单例模式的方法。

1.1 使用模块级别的变量实现单例模式

# singleton_module.py

class Singleton:
    def __init__(self):
        self.value = None

    def set_value(self, value):
        self.value = value

    def get_value(self):
        return self.value

singleton_instance = Singleton()

Python模块在程序中只会被导入一次,因此模块级别的变量可以实现单例模式。

在其他文件中,可以通过导入singleton_module模块来获取单例对象:

# main.py

from singleton_module import singleton_instance

# 使用单例对象
singleton_instance.set_value(42)
print(singleton_instance.get_value())

1.2 使用类装饰器实现单例模式

可以使用装饰器来确保类只有一个实例,并通过装饰器在需要时创建实例。

# singleton_decorator.py

def singleton(cls):
    instances = {}

    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return get_instance

@singleton
class Singleton:
    def __init__(self):
        self.value = None

    def set_value(self, value):
        self.value = value

    def get_value(self):
        return self.value

在这种方式下,可以直接使用@singleton装饰器标记一个类为单例,然后通过类的实例获取单例对象:

# main.py

from singleton_decorator import Singleton

# 使用单例对象
singleton_instance = Singleton()
singleton_instance.set_value(42)
print(singleton_instance.get_value())



2. 工厂模式(Factory Pattern)

  1.  定义一个接口,但由子类决定实例化哪个类。工厂方法模式将类的实例化延迟到子类。

    
    class Product(ABC):
        @abstractmethod
        def create_product(self):
            pass
    
    class ConcreteProductA(Product):
        def create_product(self):
            return "Product A"
    
    class ConcreteProductB(Product):
        def create_product(self):
            return "Product B"

    3.观察者模式(Observer Pattern)

from abc import ABC, abstractmethod

class Observer(ABC):
    @abstractmethod
    def update(self, message):
        pass

class ConcreteObserver(Observer):
    def update(self, message):
        print(f"Received message: {message}")

class Subject:
    _observers = []

    def add_observer(self, observer):
        self._observers.append(observer)

    def remove_observer(self, observer):
        self._observers.remove(observer)

    def notify_observers(self, message):
        for observer in self._observers:
            observer.update(message)


​​​​​​4. 策略模式(Strategy Pattern)

  1. 定义一系列算法,将每个算法封装起来,并使它们可以互换。策略模式可以使算法独立于客户端而变化。

    from abc import ABC, abstractmethod
    
    class Strategy(ABC):
        @abstractmethod
        def execute(self):
            pass
    
    class ConcreteStrategyA(Strategy):
        def execute(self):
            return "Strategy A"
    
    class ConcreteStrategyB(Strategy):
        def execute(self):
            return "Strategy B"
    
    class Context:
        def __init__(self, strategy):
            self._strategy = strategy
    
        def execute_strategy(self):
            return self._strategy.execute()

5.装饰器模式(Decorator Pattern)

  1.  动态地给一个对象添加一些额外的职责,装饰模式比继承更加灵活。

     
    from abc import ABC, abstractmethod
    
    class Component(ABC):
        @abstractmethod
        def operation(self):
            pass
    
    class ConcreteComponent(Component):
        def operation(self):
            return "Concrete Component"
    
    class Decorator(Component):
        _component = None
    
        def __init__(self, component):
            self._component = component
    
        def operation(self):
            return self._component.operation()
    
    class ConcreteDecorator(Decorator):
        def operation(self):
            return f"{super().operation()}, Decorated"

你可能感兴趣的:(python,开发语言)