1、接口類
接口類的實現主要爲了接口化，歸一化，統一化，就是每一個類的方法都是固定的名稱
from abc import abstractmethod, ABCMeta class Payment(metaclass=ABCMeta):
"""父類實現的方法加入子類繼承了必須實現，不然報錯""" @abstractmethod def pay(self, money): pass
class Alipay(Payment): def pay(self, money): print("支付寶支付%s元"%money) class ApplePay(Payment): def pay(self, money): print("蘋果支付%s元"%money) class WechatPay(Payment): def pay(self, money): print("微信支付%s元"%money) payment = Alipay() payment.pay(100)
2、工廠類
from abc import abstractmethod, ABCMeta class Payment(metaclass=ABCMeta): @abstractmethod def pay(self, money): raise NotImplementedError class Alipay(Payment): def __init__(self, enable_yuebao=False): #一個支付軟件能夠有多種的支付方式 self.enable_yuebao = enable_yuebao def pay(self, money): if self.enable_yuebao: print("餘額寶支付%s元" % money) else: print("支付寶支付%s元" % money) class ApplePay(Payment): def pay(self, money): print("蘋果支付%s元" % money) class PaymentFactory: # 工廠類 封裝了對象建立的細節，封裝了全部的支付方式，只是提供給用戶一個接口
def create_payment(self, method): if method == "alipay": return Alipay() #調用Alipay() #模式使用支付寶 elif method == "applepay": return ApplePay() elif method == "yuebao": return Alipay(True) #調用Alipay() 採用餘額寶功能 else: raise NameError(method) factory = PaymentFactory() #實例化工廠函數 payment = factory.create_payment("yuebao") #調用工廠函數的方法 payment.pay(100) #根據用戶的選擇進行支付
3、工廠類的另外一種實現方式
from abc import abstractmethod, ABCMeta class Payment(metaclass=ABCMeta): @abstractmethod def pay(self, money): raise NotImplementedError class Alipay(Payment): def pay(self, money): print("支付寶支付%s元" % money) class ApplePay(Payment): def pay(self, money): print("蘋果支付%s元"%money) class PaymentFactory(metaclass=ABCMeta): @abstractmethod def create_payment(self): pass
class AlipayFactory(PaymentFactory): def create_payment(self): return Alipay() class ApplePayFactory(PaymentFactory): def create_payment(self): return ApplePay() # 用戶輸入 # 支付寶，120
af = AlipayFactory() ali = af.create_payment() ali.pay(120)
4、抽象工廠
from abc import abstractmethod, ABCMeta # ------抽象產品------
class PhoneShell(metaclass=ABCMeta): #生產手機殼的類 @abstractmethod def show_shell(self): pass
class CPU(metaclass=ABCMeta): #生產CPU的類 @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): print("普通手機小手機殼") class BigShell(PhoneShell): #生產大的手機殼 def show_shell(self): print("普通手機大手機殼") class AppleShell(PhoneShell): #生產蘋果手機殼 def show_shell(self): print("蘋果手機殼") class SnapDragonCPU(CPU): #生產驍龍cpu def show_cpu(self): print("驍龍CPU") class MediaTekCPU(CPU): #生產聯發科cpu def show_cpu(self): print("聯發科CPU") class AppleCPU(CPU): #生產蘋果cpu def show_cpu(self): print("蘋果CPU") class Android(OS): #生產Android系統 def show_os(self): print("Android系統") class IOS(OS): def show_os(self): #生產ios系統 print("iOS系統") # ------具體工廠------
class MiFactory(PhoneFactory): #這個工廠生產驍龍cpu def make_cpu(self): return SnapDragonCPU() 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 IPhoneFactory(PhoneFactory): #iPhone工廠 def make_cpu(self): return AppleCPU() def make_os(self): return IOS() 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) p1 = make_phone(IPhoneFactory()) #生產手機（iPhone製造工廠） p1.show_info() #展現製造好的手機
5、建造者模式
import random from abc import abstractmethod, ABCMeta #------產品------
class Player:
"""生產一個玩具，這個玩具備頭，胳膊，身體，腿""" def __init__(self, face=None, body=None, arm=None, leg=None): self.face = face self.arm = arm self.leg = leg self.body = body def __str__(self): #打印生產出來的人看效果 return "%s, %s, %s, %s" % (self.face, self.arm, self.body, self.leg) #------建造者------
class PlayerBuilder(metaclass=ABCMeta):
"""負責生產人身體上的每一個部件"""
@abstractmethod def build_face(self): pass @abstractmethod def build_arm(self): pass @abstractmethod def build_leg(self): pass @abstractmethod def build_body(self): pass @abstractmethod def get_player(self): pass
class BeautifulWomanBuilder(PlayerBuilder):
"""生產一個漂亮的小女孩""" def __init__(self): self.player = Player() #首先實例化工廠類，以後實現裏面的每個功能 def build_face(self): self.player.face = "漂亮臉蛋"
def build_arm(self): self.player.arm="細胳膊"
def build_body(self): self.player.body="細腰"
def build_leg(self): self.player.leg="長腿"
def get_player(self): return self.player class RandomPlayerBuilder(PlayerBuilder):
"""生產一個即漂亮又難看的人""" def __init__(self): self.player = Player() def build_face(self): self.player.face = random.choice(["瓜子臉","西瓜子臉"]) def build_arm(self): self.player.arm=random.choice(["長胳膊","短胳膊"]) def build_body(self): self.player.body=random.choice(["苗條","胖"]) def build_leg(self): self.player.leg=random.choice(["長腿","短腿"]) def get_player(self): return self.player class PlayerDirector: def __init__(self, builder): self.builder = builder # 控制組裝順序
def build_player(self): self.builder.build_body() self.builder.build_face() self.builder.build_arm() self.builder.build_leg() return self.builder.get_player() pd = PlayerDirector(RandomPlayerBuilder())#隨機生產一我的並組裝好零件 p = pd.build_player() print(p) #能夠看到你已經造好了一個玩具人了
6、單例模式
from abc import abstractmethod, ABCMeta class Singleton(object): 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, name=None): if name is not None: self.name = name a = MyClass("a") print(a) print(a.name) b = MyClass("b") print(b) print(b.name) print(a) print(a.name)
7、適配器模式
#適配器主要採用加殼的方式實現
from abc import abstractmethod, ABCMeta class Payment(metaclass=ABCMeta): @abstractmethod def pay(self, money): raise NotImplementedError class Alipay(Payment): def pay(self, money): print("支付寶支付%s元"%money) class ApplePay(Payment): def pay(self, money): print("蘋果支付%s元"%money) #------待適配類------
class WechatPay: def huaqian(self, a, b): print("微信支付%s元"%(a+b)) #------類適配器------
class RealWeChatPay(Payment, WechatPay): def pay(self, money): return self.huaqian(money, 0) #------對象適配器------
class PayAdapter(Payment): def __init__(self, payment): self.payment = payment def pay(self, money): return self.payment.huaqian(money, 0) #RealWeChatPay().pay(100)
PayAdapter(WechatPay()).pay(1000)
8、混合模式
from abc import abstractmethod, ABCMeta class Graphic(metaclass=ABCMeta): @abstractmethod def draw(self): pass @abstractmethod def add(self, graphic): pass @abstractmethod def getchildren(self): pass
class Point(Graphic): def __init__(self, x, y): self.x = x self.y = y def draw(self): print(self) def add(self, graphic): raise TypeError def getchildren(self): raise TypeError def __str__(self): return "點(%s, %s)" % (self.x, self.y) class Line(Graphic): def __init__(self, p1, p2): self.p1 = p1 self.p2 = p2 def draw(self): print(self) def add(self, graphic): raise TypeError def getchildren(self): raise TypeError def __str__(self): return "線段[%s, %s]" % (self.p1, self.p2) class Picture(Graphic): def __init__(self): self.children = [] def add(self, graphic): self.children.append(graphic) def getchildren(self): return self.children def draw(self): print("------複合圖形------") for g in self.children: g.draw() print("------END------") pic1 = Picture() pic1.add(Point(2,3)) pic1.add(Line(Point(1,2), Point(4,5))) pic1.add(Line(Point(0,1), Point(2,1))) pic2 = Picture() pic2.add(Point(-2,-1)) pic2.add(Line(Point(0,0), Point(1,1))) pic = Picture() pic.add(pic1) pic.add(pic2) pic.draw()
9、代理模式
from abc import ABCMeta, abstractmethod class Subject(metaclass=ABCMeta): @abstractmethod def get_content(self): pass
class RealSubject(Subject): def __init__(self, filename): self.filename = filename print("讀取%s文件內容"%filename) f = open(filename) self.content = f.read() f.close() def get_content(self): return self.content def set_content(self, content): f = open(self.filename, 'w') f.write(content) f.close() class ProxyA(Subject): def __init__(self, filename): self.subj = RealSubject(filename) def get_content(self): return self.subj.get_content() class ProxyB(Subject): def __init__(self, filename): self.filename = filename self.subj = None def get_content(self): if not self.subj: self.subj = RealSubject(self.filename) return self.subj.get_content() class ProxyC(Subject): def __init__(self, filename): self.subj = RealSubject(filename) def get_content(self): return self.get_content() def set_content(self): raise PermissionError # 寫一個set_content
b = ProxyB("abc.txt") #print(b.get_content())
10、責任鏈模式
from abc import ABCMeta, abstractmethod # # class Handler(metaclass=ABCMeta): # @abstractmethod # def handle_leave(self, day): # pass # # # class GeneralManagerHandler(Handler): # def handle_leave(self, day): # if day < 10: # print("總經理批准%d天假"%day) # else: # print("呵呵") # # # class DepartmentManagerHandler(Handler): # def __init__(self): # self.successor = GeneralManagerHandler() # def handle_leave(self, day): # if day < 7: # print("部門經理批准%d天假"%day) # else: # print("部門經理無權准假") # self.successor.handle_leave(day) # # # class ProjectDirectorHandler(Handler): # def __init__(self): # self.successor = DepartmentManagerHandler() # def handle_leave(self, day): # if day < 3: # print("項目主管批准%d天假") # else: # print("項目主管無權准假") # self.successor.handle_leave(day) # # # day = 4 # h = ProjectDirectorHandler() # h.handle_leave(day) #
#--高級例子--模仿js事件處理
class Handler(metaclass=ABCMeta): @abstractmethod def add_event(self, func): pass @abstractmethod def handle(self): pass
class BodyHandler(Handler): def __init__(self): self.func = None def add_event(self, func): self.func = func def handle(self): if self.func: return self.func() else: print("已到最後一級，沒法處理") class ElementHandler(Handler): def __init__(self, successor): self.func = None self.successor = successor def add_event(self, func): self.func = func def handle(self): if self.func: return self.func() else: return self.successor.handle() # 客戶端
# <body><div><a>
body = {'type': 'body', 'name': 'body', 'children': [], 'father': None} div = {'type': 'div', 'name': 'div', 'children': [], 'father': body} a = {'type': 'a', 'name': 'a', 'children': [], 'father': div} body['children'].append(div) div['children'].append(a) body['event_handler'] = BodyHandler() div['event_handler'] = ElementHandler(div['father']['event_handler']) a['event_handler'] = ElementHandler(a['father']['event_handler']) def attach_event(element, func): element['event_handler'].add_event(func) #test
def func_div(): print("這是給div的函數") def func_a(): print("這是給a的函數") def func_body(): print("這是給body的函數") #attach_event(div, func_div) #attach_event(a, func_a) #attach_event(body, func_body)
a['event_handler'].handle()
11、迭代器模式
class LinkList: """鏈表 頭結點保存鏈表的長度"""
class Node: def __init__(self, item=None): self.item = item self.next = None class LinkListIterator: def __init__(self, node): self.node = node def __next__(self): if self.node: cur_node = self.node self.node = cur_node.next return cur_node.item else: raise StopIteration def __iter__(self): return self def __init__(self, iterable=None): self.head = LinkList.Node(0) self.tail = self.head self.extend(iterable) def append(self, obj): s = LinkList.Node(obj) self.tail.next = s self.tail = s def extend(self, iterable): for obj in iterable: self.append(obj) self.head.item += len(iterable) def __iter__(self): return self.LinkListIterator(self.head.next) def __len__(self): return self.head.item def __str__(self): return "<<"+", ".join(map(str, self))+">>" li = [i for i in range(100)] print(li) lk = LinkList(li) # for i in lk: # print(i)
print(lk) # print(len(lk))
12、觀察者模式（發佈者訂閱者模式）
from abc import ABCMeta, abstractmethod class Observer(metaclass=ABCMeta): @abstractmethod def update(self, notice): pass
class Notice: def __init__(self): self.observers = [] # 記錄該主體的觀察者（訂閱者）
def attach(self, obs): self.observers.append(obs) def detach(self, obs): obs.company_info = None self.observers.remove(obs) def notify(self): for obj in self.observers: obj.update(self) class ManagerNotice(Notice): def __init__(self, company_info=None): super().__init__() self.__company_info = company_info @property def company_info(self): return self.__company_info @company_info.setter def company_info(self, info): self.__company_info = info self.notify() class Manager(Observer): def __init__(self): self.company_info = None def update(self, noti): self.company_info = noti.company_info notice = ManagerNotice() alex = Manager() wusir = Manager() # print(alex.company_info) # print(wusir.company_info)
notice.attach(alex) notice.attach(wusir) # notice.company_info="公司運行良好"
# print(alex.company_info) print(wusir.company_info) # notice.detach(wusir) # notice.company_info="公司要破產了"
print(alex.company_info) print(wusir.company_info)
十3、策略模式（代碼參照前邊的算法NB三人組）
from abc import ABCMeta, abstractmethod import random class Sort(metaclass=ABCMeta): @abstractmethod def sort(self, data): pass
class QuickSort(Sort): def quick_sort(self, data, left, right): if left < right: mid = self.partition(data, left, right) self.quick_sort(data, left, mid - 1) self.quick_sort(data, mid + 1, right) def partition(self, data, left, right): tmp = data[left] while left < right: while left < right and data[right] >= tmp: right -= 1 data[left] = data[right] while left < right and data[left] <= tmp: left += 1 data[right] = data[left] data[left] = tmp return left def sort(self, data): print("快速排序") return self.quick_sort(data, 0, len(data) - 1) class MergeSort(Sort): def merge(self, data, low, mid, high): i = low j = mid + 1 ltmp = [] while i <= mid and j <= high: if data[i] <= data[j]: ltmp.append(data[i]) i += 1
else: ltmp.append(data[j]) j += 1
while i <= mid: ltmp.append(data[i]) i += 1
while j <= high: ltmp.append(data[j]) j += 1 data[low:high + 1] = ltmp def merge_sort(self, data, low, high): if low < high: mid = (low + high) // 2 self.merge_sort(data, low, mid) self.merge_sort(data, mid + 1, high) self.merge(data, low, mid, high) def sort(self, data): print("歸併排序") return self.merge_sort(data, 0, len(data) - 1) class Context: def __init__(self, data, strategy=None): self.data = data self.strategy = strategy def set_strategy(self, strategy): self.strategy = strategy def do_strategy(self): if self.strategy: self.strategy.sort(self.data) else: raise TypeError li = list(range(100000)) random.shuffle(li) context = Context(li, MergeSort()) context.do_strategy() #print(context.data)
random.shuffle(context.data) context.set_strategy(QuickSort()) context.do_strategy()
十5、模板模式
from abc import ABCMeta, abstractmethod class IOHandler(metaclass=ABCMeta): @abstractmethod def open(self, name): pass @abstractmethod def deal(self, change): pass @abstractmethod def close(self): pass
def process(self, name, change): self.open(name) self.deal(change) self.close() class FileHandler(IOHandler):
接口隔離原則：
# 有些東西我有你沒有，你有我麼有，這是就須要用到接口隔離
# from abc import abstractmethod, ABCMeta # # class AnimalOnLand(metaclass=ABCMeta): # @abstractmethod # def walk(self): # pass # # class AnimalInSky(metaclass=ABCMeta): # @abstractmethod # def fly(self): # pass # # class AnimalInWater(metaclass=ABCMeta): # @abstractmethod # def swim(self): # pass # # class Tiger(AnimalOnLand): # pass # # class Frog(AnimalInWater, AnimalOnLand): # pass
class A: def test(self): pass
class B(A): pass
class C: def __init__(self): self.a = A() self.a.test()