python代码结构设计

参考链接：https://blog.csdn.net/hbu_pig/article/details/80431304
参考链接： google搜索对于设计模式的描述

其实最近才了解到代码的设计模式一些理念，正是因为项目中写的代码，可扩展性差，前后兼容困，导致‘牵一发 而动全身’的尴尬

创建型模式

工厂模式

抽象工厂模式

from abc import ABCMeta, abstractmethod


class CountryDeposit(metaclass=ABCMeta):
    """抽象工厂基类"""

    @abstractmethod
    def exchange_rate(self, usd):
        return usd

    @abstractmethod
    def screen_right_award(self, data):
        pass

    @abstractmethod
    def end_time(self, start_time):
        pass

    @property
    def old_award(self):
        return

    @property
    def new_award(self):
        return

    def check_tidb_flink_data(self, data):
         pass


class ZhangSanDepositRule(CountryDeposit):
    expire_time = 7 * 24 * 3600 * 1000
    activity_number = 87987099091

    def exchange_rate(self, usd):
        # 汇率转换：1AUD=0.65USD
        return round(usd / 1.14, 2)

    def screen_right_award(self, kafka_deposit_records):


        return ""

    def end_time(self, start_time):
        return ""

    @property
    def old_award(self):
        return ""

    @property
    def new_award(self):
        return ""

    def note_deposit_info(self, user_id, account, award_id, license, transaction_id, tidb_data):
        pass


class LiSiDepositRule(CountryDeposit):
    expire_time = 7 * 24 * 3600 * 1000
    expire_count = 3
    activity_number = 888888888

    def exchange_rate(self, USD):
        return round(USD / 0.65, 2)

    def screen_right_award(self, kafka_deposit_records):

        return ""

    def end_time(self, start_time):
        return ""

    @property
    def old_award(self):
        return ""

    @property
    def new_award(self):
        return ""


def deposit_rule_factory(ID):
    self_class = None
    if ID == "CHINA":
        # 中国
        self_class = ZhangSanDepositRule()
    elif ID == "US":
        # us
        self_class = LiSiDepositRule()
    elif ID in ["USA"]:
        # USA
        self_class = LiSiDepositRule()
    return self_class

结构型模式

适配器模式

装饰器模式

行为型模式

观察者模式

有时，我们希望在一个对象的状态改变时更新另外一组对象。在MVC模式中有这样一个非常常见的例子，假设在两个视图（例如，一个饼图和一个电子表格）中使用同一个模型的数据，无论何时更改了模型，都需要更新两个视图。这就是观察者设计模式要处理的问题。
观察者模式描述单个对象（发布者，又称为主持者或可观察者）与一个或多个对象（订阅者，又称为观察者）之间的发布—订阅关系。在MVC例子中，发布者是模型，订阅者是视图。然而，MVC并非是仅有的发布—订阅例子。信息聚合订阅（比如，RSS或Atom）是另一种例子。许多读者通常会使用一个信息聚合阅读器订阅信息流，每当增加一条新信息时，他们就能自动地获取到更新。
观察者模式背后的思想等同于MVC和关注点分离原则背后的思想，即降低发布者与订阅者之间的耦合度，从而易于在运行时添加/删除订阅者。此外，发布者不关心它的订阅者是谁。它只是将通知发送给所有订阅者。

class Publisher:
    def __init__(self):
        self.observers = {}

    def add(self, observer):
        if id(observer) not in self.observers.keys():
            self.observers.update({id(observer): observer})
        else:
            print("Failed to add: {}".format(observer))

    def remove(self, observer):
        try:
            self.observers.pop(id(observer))
        except ValueError:
            print("Failed to remove: {}".format(observer))

    def notify(self, obj):
        obj.notify(self)
        # [o.notify(self) for o in self.observers]
        # 这个例子中如果一个值改变就会通知所有类，但是根据实际业务来说，我只想实现一对一的通知，那么
        # 就自己改写一下此方法，就是修改观察者的下发模式，此处我已改掉


class DefaultFormatter(Publisher):
    def __init__(self, name):
        Publisher.__init__(self)
        self.name = name
        self._data = 0

    def __str__(self):
        return "{}: '{}' has data = {}".format(type(self).__name__, self.name, self._data)

    @property
    def data(self):
        return self._data

    @data.setter
    def data(self, new_value):
        try:
            self._data, obj = new_value
        except ValueError as e:
            print("Error: {}".format(e))
        else:
            self.notify(obj)


class HexFormatter:
    def notify(self, publisher):
        print("{}: '{}' has now hex data = {}".format(type(self).__name__, publisher.name, hex(publisher.data)))


class BinaryFormatter:
    def notify(self, publisher):
        print("{}: '{}' has now binary data = {}".format(type(self).__name__, publisher.name, bin(publisher.data)))


def main():
    df = DefaultFormatter('test1')
    print(df)

    print()
    hf = HexFormatter()
    df.add(hf)
    df.data = (3, hf)
    print(df)

    print()
    bf = BinaryFormatter()
    df.add(bf)
    df.data = (21, bf)
    print(df)

    print()
    df.remove(hf)
    df.data = (13,hf)
    print(df)


if __name__ == '__main__':
    main()