Python设计小技巧

1、类与约束，抽象类设计

（1）第一种，约束不严格，只有调用到未实现方法时才会报异常

class Payment(object):
    def pay(self):
        raise NotImplementedError("%s未实现pay方法" % self.__class__.__name__)


class WechatPay(Payment):
    def pay(self):
        print("微信支付")

（2）第二种，python3引入abc模块，实现了严格约束

import abc

class Payment(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def pay(self):
        pass


class WechatPay(Payment):
    def pay(self):
        print("微信支付")

2、单例模式

（1）利用python天然的特性

class Singleton(object):
    def foo(self):
        pass
singleton = Singleton()

在其他文件中调用 from . import singleton 就行了

（2）利用__new__（）创建对象只调用一次的特性

import threading


class Singleton(object):

    __instance = None
    __lock = threading.RLock()

    def __init__(self):
        pass
        # print("调用 __init__")

    def __new__(cls, *args, **kwargs):
        if cls.__instance:
            return cls.__instance
        with cls.__lock:
            if not cls.__instance:
                # 创建对象
                cls.__instance = super().__new__(cls, *args, **kwargs)
            return cls.__instance

    def func(self):
        print("调用 __func__")


def task():
    a = Singleton()
    print(a)


if __name__ == '__main__':

    for i in range(100):
        t = threading.Thread(target=task)
        t.start()

（3）装饰器+闭包实现单例模式

装饰器的本质就是闭包函数

"""
闭包：1.函数嵌套
      2.内部函数使用外部函数变量
      3.外部函数返回内部函数
作用：
    闭包可以保存外部函数的变量，不会随着外部函数调用完就销毁
"""
# 做累加
def add(a):
    def inner(b):
        # nonlocal a  # 告诉解释器使用的是外部变量（但是如果修改外部变量的值，就不算是闭包了）
        # a = a + b
        # return a
        return a + b
    return inner


if __name__ == '__main__':

    # for i in range(100):
    #     t = threading.Thread(target=task)
    #     t.start()
    #     # task()
    sum = add(1)
    for i in range(10):
        print(sum(i))

def singleton(cls, *args, **kwargs):
    __instance = {}

    def __singleton(*args, **kargs):
        if cls not in __instance:
            __instance[cls] = cls(*args, **kargs)
        return __instance[cls]
    return __singleton


@singleton
class A():
    i = 1
    def func(self):
        self.i += 1
        print(self.i)


def task():
    # a = Singleton()
    a = A()
    print(a)


if __name__ == '__main__':

    for i in range(100):
        t = threading.Thread(target=task)
        t.start()

3、工厂模式

（1）利用反射

先声明两个类

class Tiger(object):
    def info(self):
        return "森林之王"

class Lion(object):
    def info(self):
        return "草原之王"

然后写一个settings.py的配置类，类似于Django的配置文件原理

# 对应的动物类的 package 全路径
INFO_CLASS_DICT = {
    "lion": "animal.info.lion.Lion",
    "tiger": "animal.info.tiger.Tiger"
}

最后实现工厂方法

import importlib
import settings


def factory():
    for key, path in settings.INFO_CLASS_DICT.items():
        module_path, class_name = path.rsplit(".", 1)
        module = importlib.import_module(module_path)
        cls = getattr(module, class_name)
        animal_object = cls()
        info = animal_object.info()
        print(key, info)


if __name__ == '__main__':
    factory()

（2）其他工厂模式

工厂方法或者抽象工厂也是可实现，但第一种实现可以更好的配合实现多态或者配合抽象类使用