python创建角色_Python Design Pattern - 4.创建型模式
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/11/29 18:06
# @Author : Antenna
# @Email : lilyef2000@163.com
# @File : creationalpatterns.py
# 1.簡單工廠型模式
# 簡單工廠模式不直接向客戶端暴露對象創(chuàng)建
# 的細節(jié)，而是通過一個工廠類來負責創(chuàng)建產(chǎn)品類的實
# 例。簡單工程模式的角色有：工廠角色、抽象產(chǎn)品角
# 色、具體產(chǎn)品角色
from abc import ABCMeta, abstractmethod
# 抽象產(chǎn)品角色，以什么樣的表現(xiàn)去使用
class Payment(metaclass=ABCMeta):
@abstractmethod
def pay(self, money):
pass
# 產(chǎn)品角色
class Alipay(Payment):
def __init__(self,use_huabei=False):
self.use_huabei = use_huabei
def pay(self, money):
if self.use_huabei == True:
print("花唄支付了{0}元!".format(money))
else:
print("支付寶余額支付了{0}元!".format(money))
# 產(chǎn)品角色
class WechatPay(Payment):
def pay(self, money):
print("微信支付了%d元!" % (money))
# 工廠類角色
class PaymentFactory:
def ctreate_payment(self, method):
if method == 'Alipay':
return Alipay()
elif method == 'WechatPay':
return WechatPay()
elif method == 'HuabeiPay':
return Alipay(use_huabei=True)
else:
raise TypeError('No such payment named% s' % method)
# 客戶端調(diào)用。不直接向客戶端暴露對象創(chuàng)建的實現(xiàn)
# 細節(jié)，而是通過一個工廠類來負責創(chuàng)建產(chǎn)品類的實例
pf = PaymentFactory()
p = pf.ctreate_payment('HuabeiPay')
p.pay(100)
# 2.工廠方法模式
# 工廠模式方法模式的概念是定義了一個用于創(chuàng)建對
# 象的接口(工廠接口)，讓子類決定實例化那一個產(chǎn)品
# 類。角色有抽象工廠角色、具體工廠角色、抽象產(chǎn)品角
# 色和具體產(chǎn)品角色。
from abc import ABCMeta, abstractmethod
# 抽象產(chǎn)品角色
class Payment(metaclass=ABCMeta):
@abstractmethod
def pay(self, money):
pass
# 產(chǎn)品角色
class Alipay(Payment):
def __init__(self, use_huabei=False):
self.use_huabei = use_huabei
def pay(self, money):
if self.use_huabei == True:
print("花唄支付了{0}元！".format(money))
else:
print("支付寶支付了{0}元！".format(money))
# 產(chǎn)品角色
class WechatPay(Payment):
def pay(self, money):
print("微信支付了{0}元！".format(money))
# 抽象工廠角色
class PaymentFactory(metaclass=ABCMeta):
@abstractmethod
def create_payment(self):
pass
# 具體工廠角色
class AlipayFactory(PaymentFactory):
def create_payment(self):
return Alipay()
class WechatPayFactory(PaymentFactory):
def create_payment(self):
return Alipay()
class HuabeiFactory(PaymentFactory):
def create_payment(self):
return Alipay(use_huabei=True)
hfp = HuabeiFactory().create_payment()
hfp.pay(100) # 花唄支付了100元!
# 缺點是每增加一個具體產(chǎn)品類，就必須增加一個相應的具體方法
# 3.抽象工廠模式
# 定義一個工廠類的接口讓工廠子
# 類來創(chuàng)建一系列相關或者相互依賴的對象 。相比工廠方法
# 模式，抽象工廠模式中的每一個具體工廠都生產(chǎn)一套產(chǎn)
# 品 。抽象工廠模式的角色有：抽象工廠角色、具體
# 工廠角色、抽象產(chǎn)品角色、具體產(chǎn)品角色和客戶端。抽
# 象工廠模式的優(yōu)點是：將客戶端和類的具體實現(xiàn)相分
# 離；每個工廠創(chuàng)建了一個完整的產(chǎn)品系列 ，使得易于交
# 換產(chǎn)品系列；有利于產(chǎn)品的一致性，即產(chǎn)品之間的約束
# 關系。缺點是：難以支持新種類抽象產(chǎn)品 。
from abc import ABCMeta, abstractmethod
# ------抽象的產(chǎn)品------
class PhoneShell(metaclass=ABCMeta):
@abstractmethod
def show_shell(self):
pass
class PhoneCPU(metaclass=ABCMeta):
@abstractmethod
def show_cpu(self):
pass
class PhoneOS(metaclass=ABCMeta):
@abstractmethod
def show_os(self):
pass
# ------具體的產(chǎn)品------
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 SnapDragonCPU(PhoneCPU):
def show_cpu(self):
print('驍龍CPU')
class HuaweiCPU(PhoneCPU):
def show_cpu(self):
print('化為CPU')
class AppleCPU(PhoneCPU):
def show_cpu(self):
print('蘋果CPU')
class AndroidOS(PhoneOS):
def show_os(self):
print('IOS系統(tǒng)')
class AppleOS(PhoneOS):
def show_os(self):
print('安卓系統(tǒng)')
# ------抽象的工廠------
class PhoneFactory(metaclass=ABCMeta):
@abstractmethod
def make_shell(self):
pass
@abstractmethod
def make_cpu(self):
pass
@abstractmethod
def make_os(self):
pass
# ------具體的工廠------
class HuaweiFactory(PhoneFactory):
def make_shell(self):
return SmallShell()
def make_cpu(self):
return HuaweiCPU()
def make_os(self):
return AndroidOS()
class AppleFactory(PhoneFactory):
def make_shell(self):
return AppleShell()
def make_cpu(self):
return AppleCPU()
def make_os(self):
return AppleOS()
# ------客戶端------
class Phone:
def __init__(self, shell, cpu, os):
self.shell = shell
self.cpu = cpu
self.os = os
def show_info(self):
print('手機信息：')
self.shell.show_shell()
self.cpu.show_cpu()
self.os.show_os()
def make_phone(factory):
shell = factory.make_shell()
cpu = factory.make_cpu()
os = factory.make_os()
return Phone(shell, cpu, os)
p = make_phone(HuaweiFactory())
p.show_info()
# 4.建造者模式
# 建造者模式是將一個復雜對象的構建與它的表
# 示分離，使得同樣的構建過程可以創(chuàng)建不同的表示。角
# 色有抽象創(chuàng)建者、具體創(chuàng)建者、指揮者和產(chǎn)品。建造者
# 模式與抽象工廠模式相似，也用來創(chuàng)建復雜的對象。主
# 要區(qū)別是 建造者模式著重一步步構造一個復雜對象(控制
# 順序)。而抽象工廠模式著重于多個系列的產(chǎn)品對象
from abc import ABCMeta, abstractmethod
# ------產(chǎn)品------
class Player:
def __init__(self, face=None, body=None, arms=None, legs=None):
self.face = face
self.body = body
self.arms = arms
self.legs = legs
def __str__(self):
return '%s,%s,%s,%s' % (self.face, self.body, self.arms, self.legs)
# ------抽象建造者------
class PlayerBuilder(metaclass=ABCMeta):
@abstractmethod
def build_face(self):
pass
@abstractmethod
def build_body(self):
pass
@abstractmethod
def build_arms(self):
pass
@abstractmethod
def build_legs(self):
pass
# ------具體建造者,隱藏了一個產(chǎn)品的內(nèi)部結構------
class GirlBuilder(PlayerBuilder):
def __init__(self):
self.player = Player()
def build_face(self):
self.player.face = '漂亮的臉蛋'
def build_body(self):
self.player.body = '苗條的身材'
def build_arms(self):
self.player.arms = '細細的胳膊'
def build_legs(self):
self.player.legs = '大長腿'
# ------具體建造者，表示代碼------
class MonsterBuilder(PlayerBuilder):
def __init__(self):
self.player = Player()
def build_face(self):
self.player.face = '綠臉'
def build_body(self):
self.player.body = '魁梧的身體'
def build_arms(self):
self.player.arms = '粗壯的胳膊'
def build_legs(self):
self.player.legs = '粗壯的大腿'
# ------指揮者，構造代碼(構造代碼和表示代碼分開)，可以對構造過程進行更加精細地控制 ------
class PlayerDirectory():
def builder_player(self, builder):
"""隱藏了裝配過程:param builder::return:"""
builder.build_face()
builder.build_body()
builder.build_arms()
builder.build_legs()
return builder.player
# ------客戶端------
builder = GirlBuilder()
director = PlayerDirectory()
p = director.builder_player(builder)
print(p)
# 5.單例模式
# 單例模式保證一個類只有一個實例，并提供一
# 個訪問它的全局訪問點。優(yōu)點是對唯一實例的受控訪問
# (只有一個實例)，單例相當于全局變量，但防止了命
# 名空間被污染(變量命名不會有沖突)。
class Singleton:
def __new__(cls, *args, **kwargs):
if not hasattr(cls, "_instance"):
cls._instance = super(Singleton, cls).__new__(cls)
return cls._instance
class MyClass(Singleton):
def __init__(self, a):
self.a = a
ms1 = MyClass(1)
ms2 = MyClass(2)
# print(ms1.a)
# print(id(ms1), id(ms2))
# 該例子在python3.6中不能成功運行,其實python中可以通過導入模塊實現(xiàn)單實例運行.
總結
以上是生活随笔為你收集整理的python创建角色_Python Design Pattern - 4.创建型模式的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： linux查看电脑耗电量,命令行 - 在
- 下一篇： 空气传导和骨传导耳机哪个好？这两种耳机有