Python設計模式-行為型：策略模式,觀察者模式,命令模式,模板方法

Python設計模式-行為型：策略模式,觀察者模式,命令模式,模板方法

行為型模式會涉及到演算法和物件間的職責分配，不僅描述物件或類的模式，還描述它們之間的通信方式，刻劃了運行時難以跟蹤的復雜的控制流，它們將你的注意力從控制流轉移到物件間的關系上來，

• 策略模式定義及簡單實作案例
• 觀察者模式定義及簡單實作案例
• 命令模式定義及簡單實作案例
• 模板方法模式定義及簡單實作案例

策略模式 strategy

case:一個問題可能有多種顯示方式，如果用戶有管理權限，那么問題的詳情頁面可能會顯示編輯按鈕，如果是普通用戶則只顯示問題內容，這樣一個物件我們該怎么實作呢

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

class Question(object):
    """
    問題物件，沒有使用策略模式之前的作法
    """

    def __init__(self, admin=True):
        self._admin = admin

    def show(self):
        """
        根據是否是管理員顯示不同的資訊
        """
        if self._admin is True:
            return "show page with admin"
        else:
            return "show page with user"


if __name__ == '__main__':
    q = Question(admin=False)
    print(q.show())

以上代碼中，最重要的操作就是Question.show操作，它會根據Quesiton._admin標志的不同完成兩種顯示，

現在我們有一些新的需求，增加Question的顯示方式，怎么辦？

• 如果增加更多的顯示方式，按照以上作法，我們必然要修改Quesiton.show方法，并增加更多的標志位，
• 這樣一來Question在面對不斷增加的顯示需求時都需要修改其代碼，顯然這是一種不好的設計，

下面該輪到策略模式發揮作用的時候了，策略模式將各種操作（演算法）進行封裝，并使它們之間可以互換，互換的意思是說可以動態改變物件的操作方式（演算法），

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

import abc


class AbsShow(object):
    """
    抽象顯示物件
    """

    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def show(self):
        pass


class AdminShow(AbsShow):
    """
    管理員的顯示操作
    """

    def show(self):
        return "show with admin"


class UserShow(AbsShow):
    """
    普通用戶的顯示操作
    """

    def show(self):
        return "show with user"


class Question(object):
    """
    問題物件，使用策略模式之后的作法
    """

    def __init__(self, show_obj):
        self.show_obj = show_obj

    def show(self):
        return self.show_obj.show()



if __name__ == '__main__':
    q = Question(show_obj=AdminShow())
    print(q.show())
    # 替換原來的顯示物件，體現了策略模式的互換行為
    q.show_obj = UserShow()
    print(q.show())

將 Question 物件和顯示方法進行了解耦，增加新的顯示方法時，只需要增加新的顯示物件就可以了，同時，在代碼中還可以看到我們可以動態改變 Question 的顯示方式，這也體現了策略模式的互換行為，

觀察者模式 Observer

所謂觀察者模式，就是說當一個物件發生變化時，觀察者能及時得到通知并更新

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

import abc


class Subject(object):
    """
    被觀察物件的基類
    """

    def __init__(self):
        self._observers = []

    def attach(self, observer):
        """
        注冊一個觀察者
        """
        if observer not in self._observers:
            self._observers.append(observer)

    def detach(self, observer):
        """
        注銷一個觀察者
        """
        try:
            self._observers.remove(observer)
        except ValueError:
            pass

    def notify(self):
        """
        通知所有觀察者，執行觀察者的更新方法
        """
        for observer in self._observers:
            observer.update(self)


class Course(Subject):
    """
    課程物件，被觀察的物件
    """

    def __init__(self):
        super(Course, self).__init__()
        self._message = None

    @property
    def message(self):
        """
        message 是一個屬性
        """
        return self._message

    @message.setter
    def message(self, msg):
        """
        message 屬性設定器
        """
        self._message = msg
        self.notify()


class Observer(object):
    """
    觀察者抽象類
    """

    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def update(self, subject):
        pass


class UserObserver(Observer):
    """
    用戶觀察者
    """

    def update(self, subject):
        print("User observer: %s" % subject.message)


class OrgObserver(Observer):
    """
    機構觀察者
    """

    def update(self, subject):
        print("Organization observer: %s" % subject.message)


if __name__ == '__main__':
    # 初始化一個用戶觀察者
    user = UserObserver()
    # 初始化一個機構觀察者
    org = OrgObserver()

    # 初始化一個課程
    course = Course()
    # 注冊觀察者
    course.attach(user)
    course.attach(org)

    # 設定course.message，這時觀察者會收到通知
    course.message = "two observers"

    # 注銷一個觀察者
    course.detach(user)
    course.message = "single observer"

• Subject類，它實作了觀察者模式中大部分功能，
  • 作為一個被觀察的物件，Subject實作了注冊觀察者，注銷觀察者和通知觀察者的功能，
  • 接著我們基于Subject創建了我們的課程Course類，并且當我們設定Course.message屬性時，Course物件會通知到所有觀察者，
• 可以看出，觀察者模式使被觀察的物件（主題）和觀察者之間解耦了

命令模式 Command

命令模式就是對命令的封裝，

• 所謂封裝命令，就是將一系列操作封裝到命令類中，并且命令類只需要對外公開一個執行方法execute，呼叫此命令的物件只需要執行命令的execute方法就可以完成所有的操作，
• 這樣呼叫此命令的物件就和命令具體操作之間解耦了，
• 更進一步，通過命令模式我們可以抽象出呼叫者，接收者和命令三個物件，
  • 呼叫者就是簡單的呼叫命令，然后將命令發送給接收者，而接收者則接收并執行命令，執行命令的方式也是簡單的呼叫命令的execute方法就可以了，
  • 發送者與接收者之間沒有直接參考關系，發送請求的物件只需要知道如何發送請求，而不必知道如何完成請求

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

import abc


class VmReceiver(object):
    """
    命令接收者，真正執行命令的地方
    """

    def start(self):
        print("Virtual machine start")

    def stop(self):
        print("Virtual machine stop")


class Command(object):
    """
    命令抽象類
    """
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def execute(self):
        """
        命令物件對外只提供 execute 方法
        """
        pass


class StartVmCommand(Command):
    """
    開啟虛擬機的命令
    """

    def __init__(self, recevier):
        """
        使用一個命令接收者初始化
        """
        self.recevier = recevier

    def execute(self):
        """
        真正執行命令的時候命令接收者開啟虛擬機
        """
        self.recevier.start()


class StopVmCommand(Command):
    """
    停止虛擬機的命令
    """

    def __init__(self, recevier):
        """
        使用一個命令接收者初始化
        """
        self.recevier = recevier

    def execute(self):
        """
        真正執行命令的時候命令接收者關閉虛擬機
        """
        self.recevier.stop()


class ClientInvoker(object):
    """
    命令呼叫者
    """

    def __init__(self, command):
        self.command = command

    def do(self):
        self.command.execute()


if __name__ == '__main__':
    recevier = VmReceiver()
    start_command = StartVmCommand(recevier)
    # 命令呼叫者同時也是客戶端，通過命令實體也執行真正的操作
    client = ClientInvoker(start_command)
    client.do()

    # 能告訴命令接收者執行不同的操作
    stop_command = StopVmCommand(recevier)
    client.command = stop_command
    client.do()

命令模式的封裝性很好：每個命令都被封裝起來，對于客戶端來說，需要什么功能就去呼叫相應的命令，而無需知道命令具體是怎么執行的，同時命令模式的擴展性很好，在命令模式中，在接收者類中一般會對操作進行最基本的封裝，命令類則通過對這些基本的操作進行二次封裝，當增加新命令的時候，對命令類的撰寫一般不是從零開始的，有大量的接收者類可供呼叫，也有大量的命令類可供呼叫，代碼的復用性很好

模板方法模式 template method

在模板方法模式中，我們先定義一個類模板，在這個類中，我們定義了各種操作的順序（輪轂或者說是骨架），但是并不實作這些操作，這些操作由子類來操作，

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

import abc


class Fishing(object):
    """
    釣魚模板基類
    """
    __metaclass__ = abc.ABCMeta

    def finishing(self):
        """
        釣魚方法中，確定了要執行哪些操作才能釣魚
        """
        self.prepare_bait()
        self.go_to_riverbank()
        self.find_location()
        print("start fishing")

    @abc.abstractmethod
    def prepare_bait(self):
        pass

    @abc.abstractmethod
    def go_to_riverbank(self):
        pass

    @abc.abstractmethod
    def find_location(self):
        pass


class JohnFishing(Fishing):
    """
    John 也想去釣魚，它必須實作釣魚三步驟
    """

    def prepare_bait(self):
        """
        從淘寶購買魚餌
        """
        print("John: buy bait from Taobao")

    def go_to_riverbank(self):
        """
        開車去釣魚
        """
        print("John: to river by driving")

    def find_location(self):
        """
        在島上選擇釣點
        """
        print("John: select location on the island")


class SimonFishing(Fishing):
    """
    Simon 也想去釣魚，它也必須實作釣魚三步驟
    """

    def prepare_bait(self):
        """
        從京東購買魚餌
        """
        print("Simon: buy bait from JD")

    def go_to_riverbank(self):
        """
        騎自行車去釣魚
        """
        print("Simon: to river by biking")

    def find_location(self):
        """
        在河邊選擇釣點
        """
        print("Simon: select location on the riverbank")


if __name__ == '__main__':
    # John 去釣魚
    f = JohnFishing()
    f.finishing()

    # Simon 去釣魚
    f = SimonFishing()
    f.finishing()

模板方法模式是結構最簡單的行為型設計模式，在其結構中只存在父類與子類之間的繼承關系，

• 通過使用模板方法模式，可以將一些復雜流程的實作步驟封裝在一系列基本方法中，在抽象父類中提供一個稱之為模板方法的方法來定義這些基本方法的執行次序，而通過其子類來覆寫某些步驟，從而使得相同的演算法框架可以有不同的執行結果，
• 模板方法模式提供了一個模板方法來定義演算法框架，而某些具體步驟的實作可以在其子類中完成

本文來自博客園，作者：OCEANEYES.GZY，轉載請注明原文鏈接：https://www.cnblogs.com/oceaneyes-gzy/p/16462978.html

關于作者

?? 讀書城南，?? 在未來面前，我們都是孩子～

• ?? 一個熱衷于探索學習新方向、新事物的智能產品經理，閑暇時間喜歡coding??、畫圖??、音樂??、學習ing~

?? Social Media

• ??? Blog: http://oceaneyes.top

• ? PM導航: https://pmhub.oceangzy.top

• ?? CNBLOG: https://www.cnblogs.com/oceaneyes-gzy/

• ?? AI PRJ自己部署的一些演算法demo: http://ai.oceangzy.top/

• ?? Email: [email protected]

• ?? WeChat: OCEANGZY

• ?? 公眾號: UncleJoker-GZY

?? 感謝打賞~

標籤：其他

上一篇：程式分析與優化 - 10 指令級并行

下一篇：Python設計模式-結構型：配接器模式,裝飾者模式,代理模式,組合模式,外觀模式