Python 設計模式：介面卡、裝飾器與橋接模式實踐

– 12 分鐘閱讀

Python 的動態特性使其在實作設計模式時更加靈活。介面卡模式可以優雅地整合不同的程式函式庫或模組，裝飾器模式則能簡潔地擴充套件現有函式的功能，而橋接模式則能分離抽象和實作，提高系統的彈性和可維護性。這些模式的應用能有效提升程式碼的可讀性、可重用性和可擴充套件性，是 Python 開發中不可或缺的工具。

介面卡模式實作

介面卡模式是一種結構性設計模式，讓你能將不相容的物件一起工作。它就像是一個轉接器，可以讓兩個不相容的插頭一起工作。

類別定義

首先，我們定義了兩個外部類別：Musician 和 Dancer。這些類別代表了不同的演藝人員，他們有不同的演出方式。

# external.py
class Musician:
    def play(self):
        return "Musician is playing music"

class Dancer:
    def dance(self):
        return "Dancer is dancing"

介面卡類別

接下來，我們定義了介面卡類別 Adapter。這個類別的作用是將 Musician 和 Dancer 物件適配為一個統一的介面。

# adapter.py
from external import Musician, Dancer

class Adapter:
    def __init__(self, obj, adapted_methods):
        self.obj = obj
        self.__dict__.update(adapted_methods)

    def organize_event(self):
        pass

主函式

在 main 函式中，我們建立了一些 Musician 和 Dancer 物件，並使用介面卡類別將它們適配為統一的介面。

# adapter.py
def main():
    objects = [Musician(), Dancer()]

    for obj in objects:
        if hasattr(obj, 'play') or hasattr(obj, 'dance'):
            if hasattr(obj, 'play'):
                adapted_methods = dict(organize_event=obj.play)
            elif hasattr(obj, 'dance'):
                adapted_methods = dict(organize_event=obj.dance)

            obj = Adapter(obj, adapted_methods)
            print(obj.organize_event())

if __name__ == "__main__":
    main()

執行結果

當我們執行 python adapter.py 命令時，輸出結果如下：

Musician is playing music
Dancer is dancing

這表明我們成功地使用介面卡模式將 Musician 和 Dancer 物件適配為統一的介面，並呼叫了它們的演出方法。

瞭解裝飾者模式

裝飾者模式是一種結構性設計模式，允許您在不修改現有物件的情況下，動態地為物件新增新的功能。這種模式可以用來實作多種功能，例如：資料驗證、快取、記錄、監控、除錯、商業規則和加密。

實際應用

在 Django 框架中，裝飾者模式被用來擴充套件檢視的功能，例如限制存取、控制快取和壓縮。Pyramid 框架和 Zope 應用伺服器也使用裝飾者模式來實作各種功能，例如註冊函式為事件訂閱者、保護方法以特定許可權和實作介面卡模式。

使用案例

裝飾者模式在以下情況下尤其有用：

  • 資料驗證：您可以使用裝飾者模式來驗證輸入資料，確保它符合特定的規則和限制。
  • 快取：您可以使用裝飾者模式來實作快取機制，減少對資料函式庫的查詢次數。
  • 記錄：您可以使用裝飾者模式來記錄應用程式的活動，例如使用者操作和系統事件。
  • 監控：您可以使用裝飾者模式來監控應用程式的效能，例如記錄執行時間和記憶體使用量。
  • 除錯：您可以使用裝飾者模式來實作除錯機制，例如記錄錯誤和例外。

實作裝飾者模式

在 Python 中，您可以使用 @ 符號來定義裝飾者。以下是一個簡單的範例：

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

在這個範例中，my_decorator 是一個裝飾者，它在 say_hello 函式之前和之後印出一些文字。@my_decorator 符號用來將 my_decorator 裝飾者套用到 say_hello 函式上。

圖表翻譯：
  classDiagram
    class Decorator {
        + decorate(func: Function)
    }
    class Function {
        + call()
    }
    Decorator --* Function : decorate
    class MyDecorator {
        + my_decorator(func: Function)
    }
    MyDecorator --|> Decorator
    class SayHello {
        + say_hello()
    }
    SayHello --|> Function
    MyDecorator --* SayHello : my_decorator

這個圖表顯示了裝飾者模式的基本結構，包括裝飾者、函式和具體的裝飾者和函式實作。

裝飾者模式的實作

裝飾者模式是一種結構型設計模式，允許您在不改變現有物件的情況下，動態地將新行為新增到物件中。這種模式常用於解決跨切面問題。

圖形使用者介面工具包的例子

在圖形使用者介面工具包中，裝飾者模式可以用來為個別元件新增邊框、陰影、顏色和捲動等功能。這使得您可以在不改變元件本身的情況下，動態地新增新功能。

實作部分

Python 裝飾器是一種通用且強大的工具。您可以在裝飾器函式庫中找到許多使用示例。在本節中，我們將實作一個記憶化裝飾器。所有遞迴函式都可以從記憶化中受益，因此讓我們試著實作一個函式 number_sum()， 它傳回前 n 個數字的總和。

記憶化裝飾器的實作

首先，讓我們看一下天真的實作（number_sum_naive.py 檔案）：

def number_sum(n):
    """傳回前 n 個數字的總和"""
    assert n >= 0, 'n 必須 >= 0'
    if n == 0:
        return 0
    else:
        return n + number_sum(n-1)

if __name__ == '__main__':
    from timeit import Timer
    t = Timer('number_sum(30)', 'from __main__ import number_sum')
    print('時間：', t.timeit())

這個實作非常慢，需要大約 3 秒才能計算前 30 個數字的總和。在下面的程式碼中，我們使用 dict 來快取已經計算的總和，並更改傳遞給 number_sum() 函式的引數。現在，我們想要計算前 300 個數字的總和，而不是隻有前 30 個。

def number_sum(n, memo={}):
    """傳回前 n 個數字的總和"""
    if n in memo:
        return memo[n]
    if n == 0:
        return 0
    else:
        result = n + number_sum(n-1, memo)
        memo[n] = result
        return result

if __name__ == '__main__':
    from timeit import Timer
    t = Timer('number_sum(300)', 'from __main__ import number_sum')
    print('時間：', t.timeit())

這個實作使用記憶化來快取已經計算的總和，從而大大提高了效能。

內容解密：

在這個例子中，我們使用了記憶化裝飾器來最佳化遞迴函式 number_sum()。記憶化是一種技術，用於快取已經計算的結果，以避免重複計算。透過使用 dict 來快取已經計算的總和，我們可以大大提高函式的效能。

圖表翻譯：

  flowchart TD
    A[開始] --> B[計算總和]
    B --> C[檢查快取]
    C -->|快取命中| D[傳回快取結果]
    C -->|快取未命中| E[計算總和]
    E --> F[快取結果]
    F --> D

這個圖表顯示了記憶化裝飾器的工作流程。首先，函式計算總和，如果結果已經被快取，則直接傳回快取結果。如果結果未被快取，則計算總和並快取結果。

最佳化計算：使用記憶化技術

在計算數學中，記憶化是一種用於最佳化計算的技術，尤其是在需要反覆計算相同結果的情況下。下面是一個使用記憶化技術最佳化計算的範例：

# 記憶化快取
sum_cache = {0: 0}

def number_sum(n):
    """
    回傳第一個 n 個數字的總和
    """
    assert n >= 0, 'n 必須 >= 0'
    
    # 檢查是否已經計算過
    if n in sum_cache:
        return sum_cache[n]
    
    # 如果沒有計算過，則計算並儲存結果
    res = n + number_sum(n-1)
    sum_cache[n] = res
    
    return res

if __name__ == '__main__':
    from timeit import Timer
    t = Timer('number_sum(300)', 'from __main__ import number_sum')
    print('時間：', t.timeit())

這段程式碼使用記憶化技術來最佳化計算，避免了重複計算相同結果的問題。然而，這種方法有一個缺點，就是程式碼不夠乾淨，如果我們想要擴充這個模組，新增更多的數學函式，例如帕斯卡三角形或費波那契數列演算法，程式碼就會變得很雜亂。

裝飾器模式

為瞭解決這個問題，我們可以使用裝飾器模式。裝飾器模式是一種設計模式，允許我們在不修改原始程式碼的情況下，新增新的功能。下面是一個使用裝飾器模式最佳化計算的範例：

# 記憶化裝飾器
def memoize(func):
    cache = dict()
    
    def memoized_func(*args):
        if args in cache:
            return cache[args]
        else:
            result = func(*args)
            cache[args] = result
            return result
    
    return memoized_func

# 使用記憶化裝飾器最佳化計算
@memoize
def number_sum(n):
    """
    回傳第一個 n 個數字的總和
    """
    assert n >= 0, 'n 必須 >= 0'
    
    if n == 0:
        return 0
    else:
        return n + number_sum(n-1)

if __name__ == '__main__':
    from timeit import Timer
    t = Timer('number_sum(300)', 'from __main__ import number_sum')
    print('時間：', t.timeit())

這段程式碼使用裝飾器模式最佳化計算，避免了重複計算相同結果的問題，並且程式碼更加乾淨和易於維護。同時，我們也可以使用這種方法最佳化其他的數學函式，例如費波那契數列演算法。

# 使用記憶化裝飾器最佳化費波那契數列演算法
@memoize
def fibonacci(n):
    """
    回傳費波那契數列的第 n 個數字
    """
    assert n >= 0, 'n 必須 >= 0'
    
    if n == 0 or n == 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

if __name__ == '__main__':
    from timeit import Timer
    t = Timer('fibonacci(30)', 'from __main__ import fibonacci')
    print('時間：', t.timeit())

這種方法可以大大最佳化計算的效率，並且程式碼更加乾淨和易於維護。

使用 Python 的裝飾器模式實作備忘錄化

在上一節中，我們討論瞭如何使用備忘錄化（memoization）來最佳化遞迴函式的效能。然而，這種方法會使得程式碼變得複雜。為了保持程式碼的簡潔和可讀性，我們可以使用 Python 的裝飾器模式來實作備忘錄化。

建立備忘錄化裝飾器

首先，我們需要建立一個備忘錄化裝飾器。這個裝飾器接受一個函式作為輸入，並傳回一個新的函式，該函式使用備忘錄化來最佳化效能。

import functools

def memoize(fn):
    cache = dict()

    @functools.wraps(fn)
    def memoizer(*args):
        if args not in cache:
            cache[args] = fn(*args)
        return cache[args]

    return memoizer

在這個例子中，memoize 裝飾器使用一個字典 cache 來儲存已經計算過的結果。當函式被呼叫時，裝飾器會先檢查是否已經計算過結果，如果有，則直接傳回儲存的結果；如果沒有，則計算結果並儲存到 cache 中。

使用備忘錄化裝飾器

現在，我們可以使用 memoize 裝飾器來最佳化遞迴函式的效能。例如，我們可以使用它來最佳化 fibonacci 函式：

@memoize
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

這樣，fibonacci 函式就會使用備忘錄化來最佳化效能，而不需要修改原有的程式碼。

使用備忘錄化裝飾器的好處

使用備忘錄化裝飾器有以下好處：

  • 程式碼簡潔：使用備忘錄化裝飾器可以保持程式碼的簡潔和可讀性。
  • 效能最佳化：備忘錄化裝飾器可以最佳化遞迴函式的效能。
  • 靈活性：備忘錄化裝飾器可以用於任何遞迴函式。

關於函式裝飾器和記憶化的技術探討

在軟體開發中，函式裝飾器是一種強大的工具，能夠在不修改原始函式的情況下，為其新增額外的功能。記憶化（memoization）是一種常見的最佳化技術，透過儲存函式的傳回值，避免重複計算，從而提高效率。

函式裝飾器的應用

函式裝飾器是一種特殊的函式，能夠接收另一個函式作為引數，並傳回一個新的函式。這個新的函式通常會包含原始函式的邏輯，同時新增一些額外的功能。例如，以下是一個簡單的函式裝飾器，用於記錄函式的執行時間：

import time
from functools import wraps

def timer_decorator(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = fn(*args, **kwargs)
        end_time = time.time()
        print(f"Function {fn.__name__} executed in {end_time - start_time} seconds")
        return result
    return wrapper

@timer_decorator
def example_function():
    time.sleep(1)
    print("Example function executed")

example_function()

在這個例子中，timer_decorator 函式接收 example_function 作為引數，並傳回一個新的函式 wrapper。這個 wrapper 函式包含原始 example_function 的邏輯，同時增加了記錄執行時間的功能。

記憶化技術

記憶化是一種最佳化技術，透過儲存函式的傳回值，避免重複計算，從而提高效率。以下是一個簡單的記憶化函式裝飾器：

def memoize(fn):
    cache = {}
    @wraps(fn)
    def wrapper(*args, **kwargs):
        key = str(args) + str(kwargs)
        if key in cache:
            return cache[key]
        result = fn(*args, **kwargs)
        cache[key] = result
        return result
    return wrapper

@memoize
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))

在這個例子中，memoize 函式接收 fibonacci 作為引數，並傳回一個新的函式 wrapper。這個 wrapper 函式包含原始 fibonacci 的邏輯，同時增加了記憶化功能。當 fibonacci 函式被呼叫時，wrapper 函式會先檢查是否已經計算過相同的引數，如果有，則直接傳回儲存的結果，否則，會計算結果並儲存它。

結合裝飾器和記憶化

以下是一個結合裝飾器和記憶化的例子：

def timer_decorator(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = fn(*args, **kwargs)
        end_time = time.time()
        print(f"Function {fn.__name__} executed in {end_time - start_time} seconds")
        return result
    return wrapper

def memoize(fn):
    cache = {}
    @wraps(fn)
    def wrapper(*args, **kwargs):
        key = str(args) + str(kwargs)
        if key in cache:
            return cache[key]
        result = fn(*args, **kwargs)
        cache[key] = result
        return result
    return wrapper

@timer_decorator
@memoize
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))

在這個例子中，fibonacci 函式被同時裝飾了 timer_decorator 和 memoize。這意味著，當 fibonacci 函式被呼叫時，會先記錄執行時間，然後檢查是否已經計算過相同的引數，如果有，則直接傳回儲存的結果，否則，會計算結果並儲存它。

內容解密：

在這個例子中，我們使用了兩個裝飾器，timer_decorator 和 memoize，來裝飾 fibonacci 函式。timer_decorator 用於記錄執行時間，memoize 用於記憶化結果。這樣可以避免重複計算，提高效率。

圖表翻譯：

以下是一個簡單的流程圖，描述了裝飾器和記憶化的過程：

  flowchart TD
    A[呼叫函式] --> B[記錄執行時間]
    B --> C[檢查是否已經計算過]
    C -->|是| D[直接傳回儲存的結果]
    C -->|否| E[計算結果並儲存]
    E --> D

這個流程圖描述了當函式被呼叫時，會先記錄執行時間，然後檢查是否已經計算過相同的引數，如果有，則直接傳回儲存的結果，否則，會計算結果並儲存它。

數學模組實作

模組概述

本節將介紹如何實作一個基本的數學模組，包括函式的記憶化和斐波那契數列的計算。

函式記憶化

為了提高函式的效率，尤其是那些計算成本較高的函式，我們可以使用記憶化技術。記憶化是一種最佳化技術，透過儲存函式的輸入和輸出結果，以避免重複計算。

import functools

def memoize(func):
    """記憶化裝飾器"""
    cache = dict()
    @functools.wraps(func)
    def memoized_func(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return memoized_func

數字和

接下來，我們定義一個計算數字和的函式 number_sum，並使用 memoize 裝飾器進行記憶化。

@memoize
def number_sum(n):
    """計算數字和"""
    if n <= 1:
        return n
    return n + number_sum(n-1)

斐波那契數列

斐波那契數列是一個經典的數學問題，定義為：每個數字都是前兩個數字的和，從 0 和 1 開始。

@memoize
def fibonacci(n):
    """計算斐波那契數列"""
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

主函式

最後，我們定義一個主函式 main，用於測試我們的數學模組。

def main():
    functions = [
        (number_sum, 10),
        (fibonacci, 10)
    ]
    for func, arg in functions:
        print(f"Function {func.__name__}: {func.__doc__}")
        print(f"Result: {func(arg)}")
        print()

if __name__ == "__main__":
    main()

執行結果

當我們執行 python mymath.py 命令時，會輸出以下結果：

Function number_sum: 計算數字和
Result: 55

Function fibonacci: 計算斐波那契數列
Result: 55

這表明我們的數學模組已經成功實作，並且可以正確地計算數字和和斐波那契數列。

結合設計模式與實務應用

在軟體開發中，結合不同的設計模式和實務應用可以帶來更好的解決方案。例如，使用裝飾器模式（Decorator Pattern）可以動態地新增或刪除物件的行為，而橋接模式（Bridge Pattern）可以將實作與抽象分離，提高系統的靈活性和可擴充套件性。

結合設計模式

在前面的章節中，我們討論了裝飾器模式和橋接模式。現在，讓我們來看看如何結合這兩個模式。

from abc import ABC, abstractmethod

# 抽象類
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# 實作類
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

# 橋接模式
class ShapeDecorator:
    def __init__(self, shape):
        self.shape = shape

    def area(self):
        return self.shape.area()

# 裝飾器模式
class ColorDecorator(ShapeDecorator):
    def __init__(self, shape, color):
        super().__init__(shape)
        self.color = color

    def area(self):
        return f"{self.color} {self.shape.area()}"

# 使用
circle = Circle(5)
decorated_circle = ColorDecorator(circle, "red")
print(decorated_circle.area())

在這個例子中，我們使用橋接模式將實作與抽象分離，然後使用裝飾器模式動態地新增物件的行為。

實務應用

在實務應用中，結合設計模式可以帶來更好的解決方案。例如，在電子商務系統中，使用橋接模式可以將支付方式與訂單處理分離，提高系統的靈活性和可擴充套件性。

from abc import ABC, abstractmethod

# 抽象類
class PaymentMethod(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

# 實作類
class CreditCardPayment(PaymentMethod):
    def pay(self, amount):
        return f"信用卡支付 {amount} 元"

class PayPalPayment(PaymentMethod):
    def pay(self, amount):
        return f"PayPal 支付 {amount} 元"

# 橋接模式
class Order:
    def __init__(self, payment_method):
        self.payment_method = payment_method

    def pay(self, amount):
        return self.payment_method.pay(amount)

# 使用
order = Order(CreditCardPayment())
print(order.pay(100))

order = Order(PayPalPayment())
print(order.pay(100))

在這個例子中，我們使用橋接模式將支付方式與訂單處理分離，提高系統的靈活性和可擴充套件性。

實作橋接模式

橋接模式是一種結構型設計模式，允許你將物件的抽象化與其實作解耦，使得兩者可以獨立變化。這種模式可以幫助你減少程式碼的複雜度和提高其可擴充套件性。

從技術架構視角來看，本文深入淺出地介紹了介面卡模式、裝飾器模式和橋接模式，並佐以程式碼範例說明其應用場景和優勢。透過Python的實作，我們清楚地看到裝飾器模式如何不修改原始碼即可新增新功能，例如記憶化技術在最佳化遞迴函式效能上的應用。此外，橋接模式的引入則有效地分離了抽象與實作，提升了系統的彈性和可維護性。然而，設計模式並非銀彈，選擇哪種模式取決於具體的應用場景和需求。對於規模較小的專案，過度使用設計模式反而可能增加程式碼的複雜度。技術團隊應根據專案的實際情況，權衡利弊後再決定是否採用。展望未來，隨著軟體系統日趨複雜，設計模式的重要性將更加凸顯。掌握並靈活運用這些模式，將有助於構建更穩健、更具擴充套件性的軟體系統。玄貓認為，深入理解並實踐設計模式，是每位軟體工程師的必修課。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。