五大原则

1. 单一职责原则（Single responsibility principle）
   每个类只完成一项功能，仅有一个引起它变化的原因。
   优点：
   降低类的复杂度和变更引起的风险；
   提高类的可读性，可维护性。

2. 接口隔离原则（Interface Segregation Principle）
   接口中的方法尽量少，内部的操作尽量不暴露给其他接口。
   实现低耦合高内聚。

3. 里氏替换原则（Liskov Substitution Principle）
   父类适用的地方，子类必定也可以使用。

4. 开闭原则（Open Closed Principle）
   一个软件实体（如模块、类、函数）对修改代码关闭，扩展功能开放，提高代码的复用性、可维护性。

5. 依赖倒置原则（Dependence Inversion Principle）
   高层模块不应该依赖于低层模块，二者都应该依赖于抽象；
   解耦
   继承是增加耦合性，尽量使用组合的方式解耦。

设计模式的类别

1. 行为型
   策略模式，
2. 结构型
   装饰器模式，适配器模式，
3. 创建型（5）
   单例模式，工厂模式（简单工厂、工厂方法），抽象工厂，原型模式，建造者模式

python 实现

行为型

1. 策略模式
   类可以根据不同的场景，选择不同的策略算法。

"""策略模式  行为型类可以根据不同的场景，选择不同的策略算法。数据结构：字典{场景名字: 策略函数，}注册策略，添加key-value获取策略
"""# 策略管理类
class StrategyManager:""" 策略管理类 """def __init__(self):self.strategy = {}def get_strategy(self, scene):""" 获取策略函数 """return self.strategy.get(scene)def register_strategy(self, scene, func):""" 注册场景策略 """self.strategy[scene] = func# 策略类
class Strategy:""" 策略类， 算法函数实现 """@staticmethoddef drive_car():print("驾驶小汽车...")@staticmethoddef drive_moto():print("骑摩托车...")@staticmethoddef drive_bike():print("骑自行车...")# 场景类
class Scene:""" 场景类 """def __init__(self, name):self.name = nameif __name__ == '__main__':strategy_manager = StrategyManager()# 注册策略strategy_manager.register_strategy("city", Strategy.drive_car)strategy_manager.register_strategy("country", Strategy.drive_moto)strategy_manager.register_strategy("mountain", Strategy.drive_bike)# 选择山区策略strategy_manager.get_strategy("mountain")()

结构型

1. 装饰器模式
   使用类装饰一个对象，不改变其代码的情况下，扩展其功能。

"""装饰器模式， 结构型使用类装饰一个对象，不改变其代码的情况下，扩展其功能普通类（被装饰）装饰类包裹类
"""# 普通类
class Person:def __init__(self, name):self.name = namedef intro(self):print(f"{self.name} 是普通人...")# 装饰类
class SaiWen:def __init__(self, person):self.person = persondef da_gai_shou(self):print(f"{self.person.name} 是奥特曼， 正在打怪兽...")# 包裹类
class Wrapper:def __init__(self, person, deco_class):self.person = personself.deco = deco_class(person)def __getattr__(self, attr):try:return getattr(self.person, attr)except AttributeError:return getattr(self.deco, attr)if __name__ == '__main__':person = Person("jack")person.intro()# 装饰person对象wrapper = Wrapper(person, SaiWen)wrapper.intro()wrapper.da_gai_shou()

2. 适配器模式
   将不同的接口，统一适配到同一个接口。
   

# 被适配的类
class AliPay:def ali_pay(self, sum):print("ali pay $%s" % sum)class WeichatPay:def weichat_pay(self, sum):print("weichat pay $%s" % sum)# 适配器类
class Adapter:def __init__(self, pay_mode, pay_api) -> None:self.pay_mode = pay_mode()self.pay_api = pay_apiself.check_pay()def check_pay(self):if not hasattr(self.pay_mode, self.pay_api):raise AttributeError("Unsupported payment method：%s" % self.payMethod)def pay(self, sum):method = getattr(self.pay_mode, self.pay_api)return method(sum)if __name__ == "__main__":# 对支付方案套上适配器ali_pay = Adapter(AliPay, "ali_pay")weichat_pay = Adapter(WeichatPay, "weichat_pay")# 适配到同一个pay的接口ali_pay.pay(100)weichat_pay.pay(100)

创建型

1. 单例模式
   类，只创建一个对象

class Singleton(object):def __new__(cls, *args, **kwargs):# 只创建一个对象if hasattr(cls, "_Singleton__instance"):return cls.__instancecls.__instance = object.__new__(cls)return cls.__instancedef __init__(self, *args, **kwargs):# 只初始化一次if hasattr(self, "_Singleton__init"):returnobject.__init__(self)self.__init = Truedef __eq__(self, other):if self is other:print("是同一个对象")else:print("不是同一个对象")if __name__ == '__main__':s = Singleton()s2 = Singleton()print(s == s2)

2. 工厂模式

简单工厂模式
工厂方法模式
抽象工厂模式

简单工厂

"""简单工厂模式将不同的产品类，传入同一个工厂类的函数中；隐藏创建对象的细节，但违反了单一职责的原则工厂方法模式将不同的产品类，传入各自的工厂类的函数中，来生成对象。 保持单一职责原则（也可以使用一个工厂类的静态方法）
"""# 手机基类
class BasePhone:def __init__(self, model, color):self.model = modelself.color = colordef get_info(self):return "产品信息".center(20, "=") + "\n" \+ "手机品牌:%s"%self.brand + "\n" \+ "手机颜色:%s"%self.color# 华为手机
class HuaweiPhone(BasePhone):def __init__(self, model, color):super(HuaweiPhone, self).__init__(model, color)self.brand = __class__.__name__# OPPO
class OPPOPhone(BasePhone):def __init__(self, model, color):super(OPPOPhone, self).__init__(model, color)# self可以省略self.brand = self.__class__.__name__# (一个)工厂类--> 简单工厂模式
class Factory:def produce(self, phone_class, *args):"""phone_class: 产品类；model: 产品模式；color: 产品颜色"""phone = phone_class(*args)return phoneif __name__ == '__main__':factory = Factory()huawei_phone = factory.produce(HuaweiPhone, "4G", "天蓝色")print(huawei_phone.get_info())

抽象的工厂模式

"""抽象的工厂
"""# 生产奔驰轮胎的厂商
class BenzTiresFactory:def get_info(self):return "tires made by Benz"# 生产奔驰底盘的厂商
class BenzChassisFactory:def get_info(self):return "chassis made by Benz"# 生产奔驰其他零部件的厂商
class BenzOtherFactory:def get_info(self):return "other made by Benz"# 奔驰车类
class BenzCar:def __init__(self, color):self.brand = self.__class__.__name__[:-3]self.color = colorself.tires = Noneself.chassis = Noneself.other = Nonedef get_info(self):return "车辆信息".center(20, "=") + "\n" \+ "品牌：%s"%self.brand + "\n" \+ "颜色：%s"%self.color# 工厂类
class BenzFactory:def __init__(self, color):self.car = BenzCar(color)def build_car(self, tires_factory, chassis_factory, other_factory):# 由厂家内部根据指定零件厂商，开始制造零件self.make_tires(tires_factory)self.make_chassis(chassis_factory)self.make_other(other_factory)def get_car(self):return self.cardef make_tires(self, tires_factory):tires = tires_factory()self.car.tires = tiresdef make_chassis(self, chassis_factory):chassis = chassis_factory()self.car.chassis = chassisdef make_other(self, other_factory):other = other_factory()self.car.other = other# 品牌专卖店
class BenzStore:def buy_car(self, color):# 颜色self.factory = BenzFactory(color)# 轮胎、底盘、其他零件均为奔驰制造self.factory.build_car(BenzTiresFactory, BenzChassisFactory, BenzOtherFactory)#return self.factory.get_car()if __name__ == "__main__":# 实例化奔驰专卖店benz_store = BenzStore()# 去专卖店买车benz_car = benz_store.buy_car("black")print(benz_car.get_info())

3. 原型模式
   创建一个对象模板，复制出多个重复的对象，并修改其属性值。
   简化对象的创建（不受构造函数的影响），提高性能，节约内容。

注意：复制对象会执行__new__，不会执行__init__。

from copy import copy, deepcopy# 手机原型
class PhonePrototype:def __init__(self) -> None:self.cpu = Noneself.color = Nonedef get_info(self):return "cpu: %s\ncolor: %s" % (self.cpu, self.color)# 原型建造类
class Prototype:def __init__(self) -> None:self.prototype = PhonePrototype()def get_phone(self, cpu, color):phone = deepcopy(self.prototype)phone.__dict__.update({"cpu": cpu, "color": color})return phoneif __name__ == "__main__":pro = Prototype()phone1 = pro.get_phone(cpu="Intel", color="black")phone2 = pro.get_phone(cpu="AMD", color="blue")print("手机1:\n", phone1.get_info())print("手机2:\n", phone2.get_info())

4. 建造者模式
   使用简单的对象，一步一步地构建出复杂的对象。
   可以对过程进行精细化控制；产品必须有共同点，范围有限制。

# 产品类
class Product:def __init__(self) -> None:self.hamburger = Noneself.coke = Nonedef __str__(self) -> str:return "Product".center(20, "=") + \"\n" + ("hamburger : %s" % self.hamburger).center(20, " ") + \"\n" + ("coke : %s" % self.coke).center(20, " ") + \"\n" + "=" * 20# 套餐1
class BeefPackage:def __init__(self) -> None:self.product = Product()def build_hamburger(self):self.product.hamburger = "Beaf Hamburger"def build_coke(self):self.product.coke = "Coca Cola"# 套餐2
class ChickenPackage:def __init__(self) -> None:self.product = Product()def build_hamburger(self):self.product.hamburger = "Chicken Hamburger"def build_coke(self):self.product.coke = "Pepsi Cola"# 建造者类
class Store:def get_product(self):package = Nonechoice = input("Please Choice Your Package\na.Beef Package\nb.Chicken Package\n>>> ").strip()if choice == "a":package = BeefPackage()elif choice == "b":package = ChickenPackage()else:raise ValueError("don't have package choice %r" % choice)# 建造食品package.build_hamburger()package.build_coke()return package.productif __name__ == "__main__":s = Store()product = s.get_product()print(product)