设计模式Python

面向对象编程的概念

• 多态
• 封装
• 继承
• 抽象
• 组合

面向对象的设计原则

• 开放/封闭原则
  对拓展开放，对修改封闭。
• 控制反转原则
  基本模块和从属模块机应该有一个抽象层来耦合。
• 接口隔离原则
  客户端不应该依赖他不需要使用的接口。
• 单一职责原则
  类的职责单一，引起类变化的原因单一。
• 替换原则
  子类应该可以替换基类出现的任何地方。

设计模式的分类

• 创建型模式
  运行机制基于对象的创建
  例如：单例模式。
• 结构型模式
  通过组合获得更加强大的功能的对象和类的结构。
  例如：适配器模式。
• 行为型模式
  主要关注对象之间的交互和响应，在交互的时候保持松散耦合。
  例如：观察者模式。

单例模式

• 理解
  程序运行过程中只能生成一个实例，避免重复浪费公共资源。
• python实现

# 基于__new__的实现
class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, 'instance'):
            cls.instance = super(Singleton, cls).__new__(cls)
        return cls.instance


s = Singleton()
print(s)
s1 = Singleton()
print(s1)

# 基于metaclass的实现
class MetaSingleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(MetaSingleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]


class Logger(metaclass=MetaSingleton):
    pass


log1 = Logger()
print(log1)
log2 = Logger()
print(log2)

• 应用实例

# 说明：避免数据库连接的时候创建多个对象

import sqlite3


class MetaSingleton(type):
    _instance = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instance:
            cls._instance[cls] = super(MetaSingleton, cls).__call__(*args, **kwargs)
        return cls._instance[cls]


class Database(metaclass=MetaSingleton):
    connection = None

    def connect(self):
        self.connection = sqlite3.connect('db.sqlite3')
        self.cursor = self.connection.cursor()
        return self.cursor


db1 = Database().connect()
print(db1)
db2 = Database().connect()
print(db2)

monostate(单态)模式

• 理解：多个实例共享相同的状态
• python实现

class Monostate(object):
    __share_state = {}

    def __new__(cls, *args, **kwargs):
        obj = super(Monostate, cls).__new__(cls, *args, **kwargs)
        obj.__dict__ = cls.__share_state
        return obj


s = Monostate()
s.x = 1

s1 = Monostate()
# s的属性改变,s1的属性也会随之改变
print(s1.x)

观察者模式（监听者模式）

# 模拟监听开关按下次数，控制灯光颜色的例子
class Observer:
    """观察者的基类"""

    def update(self, observer):
        """观察者接收到通知需要触发的动作"""
        pass

class Observable:
    """被观察者的基类"""

    def __init__(self):
        self.__observers = []

    def add_observer(self, observer):
        """增加观察者"""
        self.__observers.append(observer)

    def remove_observer(self, observer):
        """移除观察者"""
        self.__observers.remove(observer)
        print('移除观察者：%s'%observer.__class__.__name__)

    def notify_observer(self, object = 0):
        """状态改变时通知观察者"""
        for observer in self.__observers:
            observer.update(self)

class Switch(Observable):
    """开关"""

    def __init__(self):
        super(Switch,self).__init__()
        self.__freq = 0

    def get_freq(self):
        """获取开关按的次数"""
        return self.__freq

    def set_freq(self, freq):
        """设定开关次数"""
        self.__freq = freq
        print("开关次数:%s"%self.__freq)
        self.notify_observer()


class White(Observer):
    """监听开关按一下为白色"""

    def update(self, observable):
        if observable.get_freq() == 1:
            print("我是白色灯")


class Red(Observer):
    """监听开关按两下为红色"""

    def update(self, observable):
        if observable.get_freq() == 2:
            print("我是红色灯")



def test_switch():
    """测试观察者模式"""
    switch = Switch()
    white_mode = White()
    reg_mode = Red()
    switch.add_observer(white_mode)
    switch.add_observer(reg_mode)
    switch.set_freq(1)
    switch.set_freq(2)
    switch.remove_observer(white_mode)
    switch.remove_observer(reg_mode)


if __name__ == '__main__':
    test_switch()     

适配器模式

# 给安卓充电宝增加type-c转换线
class Battery(object):
    """
    电池
    """

    def __init__(self):
        self.voltage = 0
        self.electric = 0

    def get_voltage(self):
        return self.voltage

    def get_electric(self):
        return self.electric


class AndroidBattery(Battery):
    """
    安卓充电宝
    """

    def __init__(self):
        self.voltage = 5
        self.electric = 2

    def get_line(self):
        return "我是安卓线"


class TypeCAdapter(AndroidBattery, Battery):
    """
    安卓充电线转type-c转换器
    """

    def __init__(self):
        self.voltage = 3
        self.electric = 1

    def get_line(self):
        return "我是type-c线"


if __name__ == '__main__':
    print("给小米手机充电")
    xiaomi_charge = AndroidBattery()
    print("充电线", xiaomi_charge.get_line())
    print("电流", xiaomi_charge.get_electric())
    print("电压", xiaomi_charge.get_voltage(), '\r\n')

    print("给华为手机充电")
    huawei_charge = TypeCAdapter()
    print("充电线", huawei_charge.get_line())
    print("电流", huawei_charge.get_electric())
    print("电压", huawei_charge.get_voltage())

待更新……