单例模式
只允许一个类只有一个实例。
先了解一下下python 的 init()方法和 new()方法
init不是实例化一个类第一个调用的方法,
第一个调用的方法是new方法,new方法返回一个实例对象,
然后实例对象调用init方法。
new是类级别的方法。
init是实例级别的方法。
class Single:
_instance = None
def __new__(cls, *args, **kwargs):
if not cls._instance:
# instance未实例化
# object.__new__(cls)
cls._instance = super().__new__(cls)
return cls._instance
s1 = Single()
s2 = Single()
print(id(s1), id(s2))
简单工厂
隐藏了创建对象的实现细节。哭护短不需要修改代码。
新增对象,需要修改工厂代码。
class Payment(metaclass=ABCMeta):
@abstractmethod
def pay(self, money):
pass
class WechatPayment(Payment):
def pay(self, money):
print("微信支付")
class AliPayment(Payment):
def pay(self, money):
print("阿里支付")
class PaymentFactory:
def create_payment(self, method):
if method == "ali":
return AliPayment()
elif method == "wechat":
return WechatPayment()
pf = PaymentFactory()
pay = pf.create_payment('ali')
pay.pay(1)
工厂方法模式
一个工厂生产一个产品。 不需要修改工厂类代码。
每增加一个产品,需要增加一个工厂。
class PaymentFactory(metaclass=ABCMeta):
@abstractmethod
def create_payment(self):
pass
class WechatFactory(PaymentFactory):
def create_payment(self):
return WechatPayment()
抽象工厂模式
定义一个工厂类接口,让工厂类子类创建一系列相关或者相互依赖的对象。
抽象工厂模式中,每个具体工厂都生产一套产品。
# 抽象产品
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 AppleShell(PhoneShell):
def show_shell(self):
print("苹果手机壳")
class SanShell(PhoneShell):
def show_shell(self):
print("三星手机壳")
class DragonCPU(CPU):
def show_cpu(self):
print("梦龙CPU")
class AppleCPU(CPU):
def show_cpu(self):
print("苹果CPU")
class LinuxOS(OS):
def show_os(self):
print("linux os")
class WindowOS(OS):
def show_os(self):
print("window os")
# 具体工厂
class LLFactory(PhoneFactory):
def make_shell(self):
return AppleShell()
def make_cpu(self):
return DragonCPU()
def make_os(self):
return WindowOS()
class MMFactory(PhoneFactory):
def make_shell(self):
return SanShell()
def make_cpu(self):
return DragonCPU()
def make_os(self):
return LinuxOS()
# 客户端
class Phone:
def __init__(self, cpu, os, shell):
self.cpu = cpu
self.os = os
self.shell = shell
def show_info(self):
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)
p1 = make_phone(LLFactory())
p1.show_info()
建造者模式
将一个复杂对象的构建与它的表示分离。使得同样的构建过程可以创建不同的表示。
和抽象工厂有点像。着重于 顺序, 抽象工厂着重于 系列产品。
- 抽象建造者
- 具体建造者
- 指挥者
- 产品
# 产品
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 self.face + self.body + self.leg + self.arm
# 抽象建造者
class PlayBuilder(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 GirlBuilder(PlayBuilder):
def __init__(self):
self.player = Player()
def build_face(self):
self.player.face = "女"
def build_body(self):
self.player.body = "170"
def build_arm(self):
self.player.arm = "俩个胳膊"
def build_leg(self):
self.player.leg = "大长腿"
# 指挥者
class PlayerDirector:
def build_player(self, builder: PlayBuilder):
builder.build_body()
builder.build_arm()
builder.build_face()
builder.build_leg()
return builder.player
builder = GirlBuilder()
director = PlayerDirector()
player = director.build_player(builder)
print(player)
标签:show,python,创建,self,设计模式,os,class,def,make
From: https://www.cnblogs.com/clllll/p/16841040.html