#!/usr/bin/env python

# -*- coding: utf-8 -*-

# @Time : 2020/11/29 18:06

# @Author : Antenna

# @Email : lilyef2000@163.com

# @File : creationalpatterns.py

# 1.簡單工廠型模式

# 簡單工廠模式不直接向客戶端暴露對象創建

# 的細節，而是通過一個工廠類來負責創建產品類的實

# 例。簡單工程模式的角色有：工廠角色、抽象產品角

# 色、具體產品角色

from abc import ABCMeta, abstractmethod

# 抽象產品角色，以什么樣的表現去使用

class Payment(metaclass=ABCMeta):

@abstractmethod

def pay(self, money):

pass

# 產品角色

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))

# 產品角色

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)

# 客戶端調用。不直接向客戶端暴露對象創建的實現

# 細節，而是通過一個工廠類來負責創建產品類的實例

pf = PaymentFactory()

p = pf.ctreate_payment('HuabeiPay')

p.pay(100)

# 2.工廠方法模式

# 工廠模式方法模式的概念是定義了一個用于創建對

# 象的接口(工廠接口)，讓子類決定實例化那一個產品

# 類。角色有抽象工廠角色、具體工廠角色、抽象產品角

# 色和具體產品角色。

from abc import ABCMeta, abstractmethod

# 抽象產品角色

class Payment(metaclass=ABCMeta):

@abstractmethod

def pay(self, money):

pass

# 產品角色

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))

# 產品角色

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元!

# 缺點是每增加一個具體產品類，就必須增加一個相應的具體方法

# 3.抽象工廠模式

# 定義一個工廠類的接口讓工廠子

# 類來創建一系列相關或者相互依賴的對象 。相比工廠方法

# 模式，抽象工廠模式中的每一個具體工廠都生產一套產

# 品 。抽象工廠模式的角色有：抽象工廠角色、具體

# 工廠角色、抽象產品角色、具體產品角色和客戶端。抽

# 象工廠模式的優點是：將客戶端和類的具體實現相分

# 離；每個工廠創建了一個完整的產品系列 ，使得易于交

# 換產品系列；有利于產品的一致性，即產品之間的約束

# 關系。缺點是：難以支持新種類抽象產品 。

from abc import ABCMeta, abstractmethod

# ------抽象的產品------

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

# ------具體的產品------

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系統')

class AppleOS(PhoneOS):

def show_os(self):

print('安卓系統')

# ------抽象的工廠------

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.建造者模式

# 建造者模式是將一個復雜對象的構建與它的表

# 示分離，使得同樣的構建過程可以創建不同的表示。角

# 色有抽象創建者、具體創建者、指揮者和產品。建造者

# 模式與抽象工廠模式相似，也用來創建復雜的對象。主

# 要區別是 建造者模式著重一步步構造一個復雜對象(控制

# 順序)。而抽象工廠模式著重于多個系列的產品對象

from abc import ABCMeta, abstractmethod

# ------產品------

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

# ------具體建造者,隱藏了一個產品的內部結構------

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.單例模式

# 單例模式保證一個類只有一個實例，并提供一

# 個訪問它的全局訪問點。優點是對唯一實例的受控訪問

# (只有一個實例)，單例相當于全局變量，但防止了命

# 名空間被污染(變量命名不會有沖突)。

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中可以通過導入模塊實現單實例運行.

總結

以上是生活随笔為你收集整理的python创建角色_Python Design Pattern - 4.创建型模式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。