1.创建型模式
- 单例模式
- 内容：单例模式，可以确保某个类只有一个实例存在。
- 角色：
- 单例(singleton)
- demon:
from threading import Thread, Lock
class Singleton:
"""线程安全的单例模式"""
_instance_lock = Lock()
_init_lock = Lock()
def __new__(cls, *args, **kwargs):
# 确保只有一个实例
with Singleton._instance_lock:
if not hasattr(Singleton, '_instance'):
print('实例第一次被创建')
Singleton._instance = object.__new__(cls)
return Singleton._instance
def __init__(self):
# 只运行一次init
with Singleton._init_lock:
if not hasattr(Singleton, '_first_init'):
print('实例第一次被初始化')
Singleton._first_init = True # 设置类属性flag
def task(i, threadPool):
if isinstance(threadPool, list):
obj = Singleton()
if obj not in threadPool:
threadPool.append(obj)
if __name__ == "__main__":
threadPool = []
for i in range(10):
t = Thread(target=task, args=(i, threadPool))
t.start()
print(threadPool) # 长度为1相对于循环10次只创建一个实例
- 简单工厂模式
- 内容：不直接向客户端暴露对象创建的实现细节，通过一个工厂来负责创建产品类实例。
- 角色：
- 工厂角色（Creator）
- 抽象产品角色（Product）
- 具体产品角色（Concrete Product）
- demon:
from abc import ABCMeta, abstractmethod
class Payment(metaclass = ABCMeta):
"""抽象产品角色"""
@abstractmethod
def pay(self, money):
pass
class Alipay(Payment):
"""具体产品角色"""
def pay(self, money):
print(f"支付宝支付{money}元")
class WechatPay(Payment):
"""具体产品角色"""
def pay(self, money):
print(f"微信支付{money}元")
class PaymentFactory:
"""工厂角色"""
def create_payment(self, method):
if method == 'alipay':
return Alipay()
elif method == 'wechat':
return WechatPay()
else:
raise TypeError('tmd 找不到')
pf = PaymentFactory() # 工厂类实例
p = pf.create_payment('alipay') # 根据需求类型生产对应类实例，确保同一工厂多个产品
p.pay(888)
- 工厂方法模式
- 内容：在简单工厂的基础上，抽象出不同的工厂，每个工厂对应生产自己的产品，这就是工厂方法。
- 角色：
- 抽象工厂角色（Creator）
- 具体工厂角色（Concrete Creator）
- 抽象产品角色（Product）
- 具体产品角色（Concrete Product）
- demon:
from abc import ABCMeta, abstractmethod
class Payment(metaclass = ABCMeta):
"""抽象产品角色"""
@abstractmethod
def pay(self, money):
pass
class Alipay(Payment):
"""具体产品角色"""
def pay(self, money):
print(f"支付宝支付{money}元")
class WechatPay(Payment):
"""具体产品角色"""
def pay(self, money):
print(f"微信支付{money}元")
class PaymentFactory(metaclass = ABCMeta):
"""抽象工厂角色"""
def create_payment(self):
pass
class AlipayFactory(PaymentFactory):
"""具体工厂角色"""
def create_payment(self):
return Alipay()
class WechatFactory(PaymentFactory):
"""具体工厂角色"""
def create_payment(self):
return WechatPay()
pf = AlipayFactory() # 工厂方法类实例
p = pf.create_payment() # 根据需求类型调用对应方法工厂生产产品
p.pay(888)
- 抽象工厂模式
- 内容：定义一个工厂类接口，让工厂子类创建一系列相关或依赖的对象。
- 角色：
- 抽象工厂角色（Creator）
- 具体工厂角色（Concrete Creator）
- 抽象产品角色（Product）
- 具体产品角色（Concrete Product）
- demon:
from abc import ABCMeta, abstractmethod
class PhoneShell(metaclass = ABCMeta):
"""抽象产品角色"""
@abstractmethod
def show_shell(self):
pass
class CPU(metaclass = ABCMeta):
"""抽象产品角色"""
@abstractmethod
def show_cpu(self):
pass
class OS(metaclass = ABCMeta):
"""抽象产品角色"""
@abstractmethod
def show_os(self):
pass
class PhoneFactory(metaclass = ABCMeta):
"""抽象工厂角色"""
@abstractmethod
def make_shell(self):
pass
@abstractmethod
def make_cpu(self):
pass
@abstractmethod
def make_os(self):
pass
class SmallShell(PhoneShell):
"""具体产品角色"""
def show_shell(self):
return Alipay()
class SmallShell(PhoneShell):
"""具体产品角色"""
def show_shell(self):
print("普通小手机壳")
class BigShell(PhoneShell):
"""具体产品角色"""
def show_shell(self):
print("普通大手机壳")
class AppLeShell(PhoneShell):
"""具体产品角色"""
def show_shell(self):
print("苹果手机壳")
class SnapDrageon(CPU):
"""具体产品角色"""
def show_cpu(self):
print("晓龙cpu")
class MediaTekCPU(CPU):
"""具体产品角色"""
def show_cpu(self):
print("联发科cpu")
class AppleCPU(CPU):
"""具体产品角色"""
def show_cpu(self):
print("苹果cpu")
class IOS(OS):
"""具体产品角色"""
def show_os(self):
print("苹果os")
class Android(OS):
"""具体产品角色"""
def show_os(self):
print("Android os")
class MiFactory(PhoneFactory):
"""具体工厂角色"""
def make_cpu(self):
return SnapDrageon()
def make_os(self):
return Android()
def make_shell(self):
return BigShell()
class HuaweiFactory(PhoneFactory):
"""具体工厂角色"""
def make_cpu(self):
return MediaTekCPU()
def make_os(self):
return Android()
def make_shell(self):
return SmallShell()
class AppleFactory(PhoneFactory):
"""具体工厂角色"""
def make_cpu(self):
return AppleCPU()
def make_os(self):
return OS()
def make_shell(self):
return AppLeShell()
class Phone:
def __init__(self, cpu, os, shell):
self.cpu = cpu
self.os = os
self.shell = shell
def show_info(self):
print('手机信息')
self.cpu.show_cpu()
self.os.show_os()
self.shell.show_shell()
def make_phone(factory):
cpu = factory.make_cpu()
os = factory.make_os()
shell = factory.make_shell()
return Phone(cpu, os, shell)
pf = make_phone(MiFactory())
pf.show_info()
- 建造者模式:
- 内容：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
- 角色：
- 抽象建造者（Builder）
- 具体建造者（Concrete Builder）
- 指挥者（Director）
- 产品(Product）
- demon:
from abc import ABCMeta, abstractmethod
class Player:
def __init__(self, face = None, body = None, arm = None, leg = None):
self.face = face
self.body = body
self.arm = arm
self.leg = leg
def __str__(self):
return f"{self.face} - {self.body} - {self.arm} - {self.leg}"
class PlayerBuilder(metaclass = ABCMeta):
""" """
@abstractmethod
def build_face(self):
pass
@abstractmethod
def build_body(self):
pass
@abstractmethod
def build_arm(self):
pass
@abstractmethod
def build_leg(self):
pass
class SexGirlBuilder(PlayerBuilder):
def __init__(self):
self.player = Player()
def build_face(self):
self.player.face = "漂亮脸蛋"
def build_body(self):
self.player.body = "苗条"
def build_arm(self):
self.player.arm = "漂亮胳膊"
def build_leg(self):
self.player.leg = "大长腿"
class Monster(Player):
def __init__(self):
self.player = Player()
def build_face(self):
self.player.face = "怪兽脸"
def build_body(self):
self.player.body = "胖"
def build_arm(self):
self.player.arm = "长毛的胳膊"
def build_leg(self):
self.player.leg = "大长腿"
class PlayerDirector:
def build_player(self, builder):
builder.build_body()
builder.build_face()
builder.build_leg()
builder.build_arm()
return builder.player
builder = SexGirlBuilder()
director = PlayerDirector()
p = director.build_player(builder)
print(p)
2.结构型模式
- 适配器模式
- 内容：将一个类的接口转换成客户希望的另一个接口。适配器模式使得原本由于接口不兼容而不能在一起工作的那些类可以一起工作。
- 实现方式：
- 类适配器：使用多继承
- 对象适配器：使用组合
- 角色：
- 目标接口(Target)
- 待适配的类(Adaptee)
- 适配器(Adapter)
- demon:
from abc import ABCMeta, abstractmethod
class Payment(metaclass = ABCMeta):
@abstractmethod
def pay(self, money):
pass
class Alipay(Payment):
def pay(self, money):
"""目标接口"""
print(f"支付宝支付{money}元")
class WechatPay(Payment):
def pay(self, money):
"""目标接口"""
print(f"微信支付{money}元")
class BanPay:
"""待适配的类"""
def cost(self, money):
print(f'银联支付{money}')
class ApplePay:
def cost(self, money):
print(f'苹果支付{money}')
# class NewBankPay(Payment, BankPay):
# """类适配器类"""
# def pay(self, money):
# self.cost(money)
# p = NewBankPay()
# p.pay(110)
class PaymentAdapter(Payment):
"""对象适配器"""
def __init__(self, payment):
self.payment = Payment
def pay(self, money):
self.payment.cost(money)
p = PaymentAdapter(ApplePay())
p.pay(100)
- 桥模式
- 内容：将一个事物的两个维度分离，使其都可以独立地变化。
- 角色：
- 抽象(Abstraction)
- 细化抽象(RefinedAbstraction)
- 实现者(Implementor)
- 具体实现者(ConcreteImplementor)
- demon:
from abc import ABCMeta, abstractmethod
class Shape(metaclass=ABCMeta):
def __init__(self, color):
self.color = color
@abstractmethod
def draw(self):
pass
class Color(metaclass=ABCMeta):
@abstractmethod
def paint(self, shape):
pass
class Rectangle(Shape):
"""抽象"""
name = "长方形"
def draw(self):
# 长方形绘制逻辑
self.color.paint(self):
class Circle(Shape):
"""抽象"""
name = "圆形"
def draw(self):
# 圆形绘制逻辑
self.color.paint(self)
class Red(Color):
"""实现"""
def paint(self, shape):
peint(f"红色的{shape.name}")
class Green(Color):
"""实现"""
def paint(self, shape):
peint(f"绿色的{shape.name}")
shape = Rectangle(Red())
shape.draw()
- 组合模式
- 内容：将对象组合合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
- 角色：
- 抽象组件(Component)
- 叶子组件(Leaf)
- 复合组件(Composite)
- 客户端(Client)
- demon:
from abc import ABCMeta, abstractmethod
class Graphic(metaclass=ABCMeta):
"""抽象组件"""
@abstractmethod
def draw(self):
pass
def Point(Graphic):
"""叶子组件"""
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return "点({self.x},{self.y})"
def draw(self):
print(str(self))
def Line:
"""叶子组件"""
def __init__(self, p1, p2):
self.p1 = p1
self.p2 = p2
def __str__(self):
return "线段[{self.p1},{self.p2}]"
def draw(self):
print(str(self))
class Picture:
"""复合组件"""
def __init__(self, iterable):
self.children = []
for g in iterable:
self.add(g)
def add(self, graphic):
self.children.append(graphic)
def draw(self):
print("----------复合图形-----------")
for g in self.children:
g.draw()
print("----------复合图形-----------")
# 客户端
p1 = Point(2, 3)
l1 = Line(Point(3, 4), Ponit(6, 7))
l2 = Line(Point(1, 5), Ponit(2, 8))
pic1 = Picture([p1, l1, l2])
pic1.draw()
p2 = Point(4, 4)
l3 = Line(Point(1, 1), Point(0, 0))
pic2 = Picture([pic1, pic2])
pic = Picture([pic1, pic2])
pic.draw()
- 外观模式
- 内容：为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
- 角色：
- 外观(facade)
- 子系统(subsystem classes)
- demon:
class CPU:
"""子系统"""
def run(self):
print("CPU开始运行")
def stop(self):
print("CPU停止运行")
class Disk:
"""子系统"""
def run(self):
print("键盘开始运行")
def stop(self):
print("键盘停止运行")
class Memory:
"""子系统"""
def run(self):
print("内存通电")
def stop(self):
print("内存断电")
class Computer:
"""外观"""
def __init__(self):
self.cpu = CPU()
self.disk = Disk()
self.memory = Memory()
def run(self):
self.cpu.run()
self.disk.run()
self.memory.run()
def stop(self):
self.cpu.stop()
self.disk.stop()
self.memory.stop()
computer = Computer()
computer.run()
computer.stop()
