設計模式簡介
設計模式
什麼是設計模式
o Christopher Alexander:「每個模式描述了一個在咱們周圍不斷重複發生的問題，以及該問題的解決方案的核心。這樣你就能一次又一次地使用該方案而沒必要作重複勞動。」
o 每個設計模式系統地命名、解釋和評價了面向對象系統中一個重要的和重複出現的設計。
o GoF（Gang of Four）
o 設計模式四個基本要素：模式名稱、問題、解決方案、效果
講在設計模式以前
o 對象/類
n 封裝
n 繼承
n 多態
o 接口：一種特殊的類，聲明瞭若干方法，要求繼承該接口的類必須實現這些方法。
n 做用：限制繼承接口的類的方法的名稱及調用方式；隱藏了類的內部實現。
n 接口就是一種抽象的基類（父類），限制繼承它的類必須實現接口中定義的某些方法
Python中接口的兩種寫法
設計模式六大原則
o 開閉原則：一個軟件實體如類、模塊和函數應該對擴展開放，對修改關閉。即軟件實體應儘可能在不修改原有代碼的狀況下進行擴展。
o 里氏（Liskov）替換原則：全部引用基類（父類）的地方必須能透明地使用其子類的對象。
o 依賴倒置原則：高層模塊不該該依賴低層模塊，兩者都應該依賴其抽象；抽象不該該依賴細節；細節應該依賴抽象。換言之，要針對接口編程，而不是針對實現編程。
o 接口隔離原則：使用多個專門的接口，而不使用單一的總接口，即客戶端不該該依賴那些它不須要的接口。
o 迪米特法則：一個軟件實體應當儘量少地與其餘實體發生相互做用。
o 單一職責原則：不要存在多於一個致使類變動的緣由。通俗的說，即一個類只負責一項職責。
設計模式分類
o 建立型模式：
n 工廠方法模式
n 抽象工廠模式
n 建立者模式
n 原型模式
n 單例模式
o 結構型模式
n 適配器模式
n 橋模式
n 組合模式
n 裝飾模式
n 外觀模式
n 享元模式
n 代理模式
o 行爲型模式
n 解釋器模式
n 責任鏈模式
n 命令模式
n 迭代器模式
n 中介者模式
n 備忘錄模式
n 觀察者模式
n 狀態模式
n 策略模式
n 訪問者模式
n 模板方法模式
簡單工廠模式
o 內容：不直接向客戶端暴露對象建立的實現細節，而是經過一個工廠類來負責建立產品類的實例。
o 角色：
n 工廠角色（Factory）
n 抽象產品角色（Product）
n 具體產品角色（Concrete Product）
o 優勢：
n 隱藏了對象建立的實現細節
n 客戶端不須要修改代碼
o 缺點：
n 違反了單一職責原則，將建立邏輯幾種到一個工廠類裏
n 當添加新產品時，須要修改工廠類代碼，違反了開閉原則
工廠方法模式
o 內容：定義一個用於建立對象的接口（工廠接口），讓子類決定實例化哪個產品類。
o 角色：
n 抽象工廠角色（Creator）
n 具體工廠角色（Concrete Creator）
n 抽象產品角色（Product）
n 具體產品角色（Concrete Product）
o 工廠方法模式相比簡單工廠模式將每一個具體產品都對應了一個具體工廠。
工廠方法模式
工廠方法模式
o 適用場景：
n 須要生產多種、大量複雜對象的時候
n 須要下降耦合度的時候
n 當系統中的產品種類須要常常擴展的時候
o 優勢：
n 每一個具體產品都對應一個具體工廠類，不須要修改工廠類代碼
n 工廠類能夠不知道它所建立的對象的類
n 隱藏了對象建立的實現細節
o 缺點
n 每增長一個具體產品類，就必須增長一個相應的具體工廠類
抽象工廠模式
o 內容：定義一個工廠類接口，讓工廠子類來建立一系列相關或相互依賴的對象。
o 例：生產一部手機，須要手機殼、CPU、操做系統三類對象進行組裝，其中每類對象都有不一樣的種類。對每一個具體工廠，分別生產一部手機所須要的三個對象。
o 角色：
n 抽象工廠角色（Creator）
n 具體工廠角色（Concrete Creator）
n 抽象產品角色（Product）
n 具體產品角色（Concrete Product）
n 客戶端（Client）
o 相比工廠方法模式，抽象工廠模式中的每一個具體工廠都生產一套產品。
抽象工廠模式
抽象工廠模式
o 適用場景：
n 系統要獨立於產品的建立與組合時
n 強調一系列相關的產品對象的設計以便進行聯合使用時
n 提供一個產品類庫，想隱藏產品的具體實現時
o 優勢：
n 將客戶端與類的具體實現相分離
n 每一個工廠建立了一個完整的產品系列，使得易於交換產品系列
n 有利於產品的一致性（即產品之間的約束關係）
o 缺點：
n 難以支持新種類的（抽象）產品
建造者模式
o 內容：將一個複雜對象的構建與它的表示分離，使得一樣的構建過程能夠建立不一樣的表示。
o 角色：
n 抽象建造者（Builder）
n 具體建造者（Concrete Builder）
n 指揮者（Director）
n 產品（Product）
o 建造者模式與抽象工廠模式類似，也用來建立複雜對象。主要區別是建造者模式着重一步步構造一個複雜對象，而抽象工廠模式着重於多個系列的產品對象。
建造者模式
建造者模式
o 適用場景：
n 當建立複雜對象的算法（Director）應該獨立於該對象的組成部分以及它們的裝配方式（Builder）時
n 當構造過程容許被構造的對象有不一樣的表示時（不一樣Builder）。
o 優勢：
n 隱藏了一個產品的內部結構和裝配過程
n 將構造代碼與表示代碼分開
n 能夠對構造過程進行更精細的控制
單例模式
o 內容：保證一個類只有一個實例，並提供一個訪問它的全局訪問點。
o 角色：
n 單例（Singleton）
o 適用場景
n 當類只能有一個實例並且客戶能夠從一個衆所周知的訪問點訪問它時
o 優勢：
n 對惟一實例的受控訪問
n 單例至關於全局變量，但防止了命名空間被污染
o 與單例模式功能類似的概念：全局變量、靜態變量（方法）
建立型模式小結
o 依賴於繼承的建立型模式：工廠方法模式
o 依賴於組合的建立性模式：抽象工廠模式、建立者模式
適配器模式
o 內容：將一個類的接口轉換成客戶但願的另外一個接口。適配器模式使得本來因爲接口不兼容而不能一塊兒工做的那些類能夠一塊兒工做。
o 角色：
n 目標接口（Target）
n 待適配的類（Adaptee）
n 適配器（Adapter）
o 兩種實現方式：
n 類適配器：使用多繼承
n 對象適配器：使用組合
適配器模式
適配器模式
o 適用場景：
n 想使用一個已經存在的類，而它的接口不符合你的要求
n （對象適配器）想使用一些已經存在的子類，但不可能對每個都進行子類化以匹配它們的接口。對象適配器能夠適配它的父類接口。
組合模式
o 內容：將對象組合成樹形結構以表示「部分-總體」的層次結構。組合模式使得用戶對單個對象和組合對象的使用具備一致性。
o 角色：
n 抽象組件（Component）
n 葉子組件（Leaf）
n 複合組件（Composite）
n 客戶端（Client）
組合模式
組合模式
o 適用場景：
n 表示對象的「部分-總體」層次結構（特別是結構是遞歸的）
n 但願用戶忽略組合對象與單個對象的不一樣，用戶統一地使用組合結構中的全部對象
o 優勢：
n 定義了包含基本對象和組合對象的類層次結構
n 簡化客戶端代碼，即客戶端能夠一致地使用組合對象和單個對象
n 更容易增長新類型的組件
o 缺點：
n 很難限制組合中的組件
代理模式
o 內容：爲其餘對象提供一種代理以控制對這個對象的訪問。
o 角色：
n 抽象實體（Subject）
n 實體（RealSubject）
n 代理（Proxy）
o 適用場景：
n 遠程代理：爲遠程的對象提供代理
n 虛代理：根據須要建立很大的對象
n 保護代理：控制對原始對象的訪問，用於對象有不一樣訪問權限時
o 優勢：
n 遠程代理：能夠隱藏對象位於遠程地址空間的事實
n 虛代理：能夠進行優化，例如根據要求建立對象
n 保護代理：容許在訪問一個對象時有一些附加的內務處理
代理模式
責任鏈模式
o 內容：使多個對象都有機會處理請求，從而避免請求的發送者和接收者之間的耦合關係。將這些對象連成一條鏈，並沿着這條鏈傳遞該請求，直到有一個對象處理它爲止。
o 角色：
n 抽象處理者（Handler）
n 具體處理者（ConcreteHandler）
n 客戶端（Client）
o 例：
n 請假部門批准：leaderà部門經理總經理
n Javascript事件浮升機制
責任鏈模式
責任鏈模式
o 適用場景：
n 有多個對象能夠處理一個請求，哪一個對象處理由運行時決定
n 在不明確接收者的狀況下，向多個對象中的一個提交一個請求
o 優勢：
n 下降耦合度：一個對象無需知道是其餘哪個對象處理其請求
o 缺點：
n 請求不保證被接收：鏈的末端沒有處理或鏈配置錯誤
迭代器模式
o 內容：提供一種方法順序訪問一個聚合對象中的各個元素，而又不須要暴露該對象的內部表示
o 實現方法：__iter__、__next__
觀察者模式
o 內容：定義對象間的一種一對多的依賴關係,當一個對象的狀態發生改變時, 全部依賴於它的對象都獲得通知並被自動更新。觀察者模式又稱「發佈-訂閱」模式
o 角色：
n 抽象主題（Subject）
n 具體主題（ConcreteSubject）——發佈者
n 抽象觀察者（Observer）
n 具體觀察者（ConcreteObserver）——訂閱者
觀察者模式
觀察者模式
o 適用場景：
n 當一個抽象模型有兩方面，其中一個方面依賴於另外一個方面。將這二者封裝在獨立對象中以使它們能夠各自獨立地改變和複用。
n 當對一個對象的改變須要同時改變其它對象，而不知道具體有多少對象有待改變。
n 當一個對象必須通知其它對象，而它又不能假定其它對象是誰。換言之，你不但願這些對象是緊密耦合的。
o 優勢：
n 目標和觀察者之間的抽象耦合最小
n 支持廣播通訊
o 缺點：
n 多個觀察者之間互不知道對方存在，所以一個觀察者對主題的修改可能形成錯誤的更新。
策略模式
o 內容：定義一系列的算法，把它們一個個封裝起來，而且使它們可相互替換。本模式使得算法可獨立於使用它的客戶而變化。
o 角色：
n 抽象策略（Strategy）
n 具體策略（ConcreteStrategy）
n 上下文（Context）
o 適用場景：
n 許多相關的類僅僅是行爲有異
n 須要使用一個算法的不一樣變體
n 算法使用了客戶端無需知道的數據
n 一個類中的多種行爲以多個條件語句的形式存在，能夠將這些行爲封裝如不一樣的策略類中。
策略模式
策略模式
o 優勢：
n 定義了一系列可重用的算法和行爲
n 消除了一些條件語句
n 能夠提供相同行爲的不一樣實現
o 缺點：
n 客戶必須瞭解不一樣的策略
n 策略與上下文之間的通訊開銷
n 增長了對象的數目
模板方法模式
o 內容：定義一個操做中的算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類能夠不改變一個算法的結構便可重定義該算法的某些特定步驟。
o 角色：
n 抽象類（AbstractClass）：定義抽象的原子操做（鉤子操做）；實現一個模板方法做爲算法的骨架。
n 具體類（ConcreteClass）：實現原子操做
o 適用場景：
n 一次性實現一個算法的不變的部分
n 各個子類中的公共行爲應該被提取出來並集中到一個公共父類中以免代碼重複
n 控制子類擴展
模板方法模式
代碼以下：0_interface.pynode
# coding : utf-8 # create by ztypl on 2017/5/24 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(Payment): def pay(self, money): print("微信支付%s元"%money)
1_factory.py算法
# coding : utf-8 # create by ztypl on 2017/5/24 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: def create_payment(self, method): if method == "alipay": return Alipay() elif method == "applepay": return ApplePay() else: raise NameError(method)
2_factory_method.pyshell
# coding : utf-8 # create by ztypl on 2017/5/25 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: def create_payment(self): raise NotImplementedError 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)
3_abstract_factory.py編程
# coding : utf-8 # create by ztypl on 2017/5/25 from abc import abstractmethod, ABCMeta # ------抽象產品------ 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): print("普通手機小手機殼") class BigShell(PhoneShell): def show_shell(self): print("普通手機大手機殼") class AppleShell(PhoneShell): def show_shell(self): print("蘋果手機殼") class SnapDragonCPU(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 Android(OS): def show_os(self): print("Android系統") class IOS(OS): def show_os(self): print("iOS系統") # ------具體工廠------ class MiFactory(PhoneFactory): 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): 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(MiFactory()) p1.show_info()
4_builder.py設計模式
# coding : utf-8 # create by ztypl on 2017/5/25 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 PlayerDirector: def build_player(self, builder): builder.build_face() builder.build_arm() builder.build_leg() builder.build_body() return builder.get_player() pd = PlayerDirector() pb = BeautifulWomanBuilder() p = pd.build_player(pb) print(p)
5_singleton.py微信
# coding : utf-8 # create by ztypl on 2017/5/25 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)
6_adapter.pyapp
# coding : utf-8 # create by ztypl on 2017/5/25 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, money): print("微信支付%s元"%money) #------類適配器------ class RealWeChatPay(Payment, WechatPay): def pay(self, money): return self.huaqian(money) #------對象適配器------ class PayAdapter(Payment): def __init__(self, payment): self.payment = payment def pay(self, money): return self.payment.huaqian(money) RealWeChatPay().pay(100) #PayAdapter(WechatPay()).pay(1000)
7_compositedom
# coding : utf-8 # create by ztypl on 2017/5/25 from abc import abstractmethod, ABCMeta class Graphic(metaclass=ABCMeta): @abstractmethod def draw(self): pass @abstractmethod def add(self, graphic): pass 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()
8_proxy.py函數
# coding : utf-8 # create by ztypl on 2017/5/26 from abc import ABCMeta, abstractmethod class Subject(metaclass=ABCMeta): @abstractmethod def get_content(self): pass class RealSubject(Subject): def __init__(self, filename): print("讀取%s文件內容"%filename) f = open("filename") self.content = f.read() f.close() def get_content(self): return self.content 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 "???"
9_chain_of_responsibility.py微信支付
# coding : utf-8 # create by ztypl on 2017/5/27 from abc import ABCMeta, abstractmethod class Handler(metaclass=ABCMeta): @abstractmethod def handle_leave(self, day): pass class GeneralManagerliHandler(Handler): def handle_leave(self, day): if day < 10: print("總經理批准%d天假"%day) else: print("呵呵") class DepartmentManagerHandler(Handler): def __init__(self): self.successor = GeneralManagerliHandler() 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 = 10 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()
10_iterator.py
# coding : utf-8 # create by ztypl on 2017/5/27 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) print(lk) print(len(lk))
11_observer.py
# coding : utf-8 # create by ztypl on 2017/5/27 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): 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)
12_strategy.py
# coding : utf-8 # create by ztypl on 2017/5/27 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()
13_template_method.py
# coding : utf-8 # create by ztypl on 2017/5/27 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()
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 【設計模式】設計模式簡介
- 2. 設計模式（零）簡介
- 3. 設計模式簡介
- 4. DAO設計模式簡介
- 5. 設計模式簡介（一）
- 6. Java設計模式簡介
- 7. 設計模式的簡介
- 8. 設計模式簡介（1）
- 9. C++設計模式簡介
- 10. 01設計模式簡介