Python 裝飾器進階用法與實務案例

– 12 分鐘閱讀

Python 裝飾器提供一種優雅的方式來擴充套件函式功能，而無需修改原始碼。除了基本用法外，裝飾器還能應用於更複雜的場景，例如錯誤處理、快取機制、存取控制等。透過裝飾器鏈和巢狀結構，更能組合不同功能，實作高度模組化和可重用的程式碼。理解裝飾器的執行順序和後設資料保留機制，對於正確使用裝飾器至關重要。此外，條件式裝飾器和類別基礎的裝飾器，則能應對更具彈性的需求，例如依據環境變數執行特定邏輯，或實作限速等功能。

錯誤處理裝飾器

def 安全執行(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            print(f"發生錯誤：{e}")
            raise
    return wrapper

@安全執行
def 風險操作(x, y):
    # 模擬風險操作
    if x < 0 or y < 0:
        raise ValueError("x 和 y 必須為非負數")
    return x + y

圖表翻譯：

  flowchart TD
    A[開始] --> B[執行函式]
    B --> C[捕捉異常]
    C --> D[處理異常]
    D --> E[繼續執行]

圖表翻譯：

  • 圖表展示了錯誤處理裝飾器的流程，從開始到執行函式，然後捕捉異常，處理異常，最後繼續執行。

3.2 建立和應用自定義裝飾器

自定義裝飾器提供了一種強大的方法來抽象跨越關注點和重用控制邏輯。高階開發人員利用這些結構來封裝行為，例如快取、身份驗證、日誌記錄和效能監控。當構建自定義裝飾器時，必須解決後設資料儲存、錯誤處理和修改函式行為可能引起的副作用等問題。

基本裝飾器結構

自定義裝飾器的基礎是函式包裝的概念。一個裝飾器基本上是一個高階函式，它接受一個函式作為輸入並傳回一個函式作為輸出。最簡單的情況下，自定義裝飾器具有以下形式：

def 自定義裝飾器(函式):
    def 包裝函式(*引數, **關鍵字引數):
        # 函式執行前自定義行為
        結果 = 函式(*引數, **關鍵字引數)
        # 函式執行後自定義行為
        return 結果
    return 包裝函式

這種模式雖然簡單，但必須透過新增額外的做法來確保生產程式碼中的嚴格行為。

保留後設資料

其中一個構建自定義裝飾器的主要問題是保留原始函式的後設資料。這可以透過 functools.wraps 來優雅地處理，它從原始函式複製基本屬性到包裝函式：

import functools

def 自定義裝飾器(函式):
    @functools.wraps(函式)
    def 包裝函式(*引數, **關鍵字引數):
        # 函式執行前邏輯
        結果 = 函式(*引數, **關鍵字引數)
        # 函式執行後邏輯
        return 結果
    return 包裝函式

實作快取機制

自定義裝飾器的一個常見使用案例是實作快取機制。對於計算密集型操作，快取給定引數的函式呼叫結果可以顯著提高效能。高階實作必須考慮快取失效和執行緒安全等問題。以下示例展示了一個將函式結果快取在字典中的裝飾器：

import functools

def 快取結果(函式):
    快取結果 = {}
    @functools.wraps(函式)
    def 包裝函式(*引數, **關鍵字引數):
        #...
        return 結果
    return 包裝函式

圖表翻譯：

  flowchart TD
    A[開始] --> B[定義自定義裝飾器]
    B --> C[實作函式包裝]
    C --> D[保留後設資料]
    D --> E[實作快取機制]
    E --> F[應用自定義裝飾器]
    F --> G[結束]

內容解密：

上述程式碼示例展示瞭如何建立和應用自定義裝飾器，以抽象跨越關注點和重用控制邏輯。透過使用 functools.wraps 來保留後設資料，並實作快取機制，可以提高效能和簡化程式碼。這些技術在大型系統中尤其有用，因為它們允許開發人員以模組化和可重用的方式封裝複雜行為。

瞭解裝飾器的強大應用：快取和存取控制

快取機制的實作

在軟體開發中，為了提高效能，減少不必要的計算，快取機制是一種常見的最佳化手段。以下是使用 Python 實作的一個簡單的快取裝飾器：

def cache_results(func):
    cached_results = {}
    def wrapper(*args, **kwargs):
        key = (args, tuple(sorted(kwargs.items())))
        if key in cached_results:
            return cached_results[key]
        result = func(*args, **kwargs)
        cached_results[key] = result
        return result
    return wrapper

@cache_results
def fibonacci(n):
    if n in (0, 1):
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

這個例子展示瞭如何使用裝飾器來實作快取機制。cache_results裝飾器會記錄函式呼叫的結果，以便下次呼叫時直接傳回快取的結果，避免重複計算。

進階實作

在實際應用中，可能需要考慮更多因素，例如快取大小、過期策略、多執行緒環境下的同步等。這些進階功能可以透過修改裝飾器來實作。

存取控制和安全強化

另一個裝飾器的重要應用場景是存取控制和安全強化。透過建立一個驗證使用者許可權的裝飾器，可以簡化安全程式碼的維護，確保敏感功能只有授權使用者才能存取：

import functools

def require_role(required_role):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(user, *args, **kwargs):
            if user.role!= required_role:
                raise PermissionError(f"User does not have {required_role} role")
            return func(user, *args, **kwargs)
        return wrapper
    return decorator

class User:
    def __init__(self, role):
        self.role = role

# 示例用法
@require_role('admin')
def sensitive_function(user, *args, **kwargs):
    # 敏感操作
    pass

這個例子展示瞭如何使用裝飾器來實作存取控制。require_role裝飾器會檢查使用者是否具有指定的角色，如果沒有，則丟擲許可權錯誤。

圖表翻譯：裝飾器工作流程

  flowchart TD
    A[函式呼叫] --> B[檢查快取]
    B -->|快取命中| C[傳回快取結果]
    B -->|快取未命中| D[執行函式]
    D --> E[儲存結果到快取]
    E --> C

這個圖表展示了裝飾器如何工作：當函式被呼叫時，先檢查是否有快取結果，如果有，直接傳回快取結果；如果沒有，則執行函式，儲存結果到快取，並傳回結果。

自訂裝飾器的設計與應用

在軟體開發中，裝飾器（Decorator）是一種強大的工具，能夠在不修改原始程式碼的情況下，為函式或方法新增新的功能。這使得程式碼更具彈性和可維護性。在本文中，我們將探討自訂裝飾器的設計和應用，包括如何建立和使用它們，以滿足不同的需求。

基本概念

首先，讓我們瞭解一下裝飾器的基本概念。一個裝飾器是一個函式，它接受另一個函式作為引數，並傳回一個新的函式，該函式「包裝」了原始函式。這個新函式通常會在呼叫原始函式之前或之後執行一些額外的動作。

自訂裝飾器的設計

設計自訂裝飾器時，我們需要考慮到它的功能和用途。例如，如果我們想要建立一個裝飾器來驗證使用者的角色，則需要定義一個函式，它接受角色作為引數，並傳回一個新的函式，該函式會檢查使用者的角色是否符合要求。

def require_role(role):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(user, *args, **kwargs):
            if user.role == role:
                return func(user, *args, **kwargs)
            else:
                raise Exception("使用者角色不符")
        return wrapper
    return decorator

條件式記錄裝飾器

另一個例子是條件式記錄裝飾器，它可以根據環境變數來決定是否記錄函式的執行細節。

import functools
import os

def conditional_logging(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if os.getenv("DEBUG", "False") == "True":
            print(f"DEBUG: Calling {func.__name__} with args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        if os.getenv("DEBUG", "False") == "True":
            print(f"DEBUG: {func.__name__} returned {result}")
        return result
    return wrapper

數值驗證裝飾器

如果需要驗證函式引數的數值型別，可以設計一個裝飾器來實作這一功能。

import functools

def validate_numbers(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        new_args = [float(arg) if isinstance(arg, (int, str)) and str(arg).replace('.', '', 1).isdigit() else arg for arg in args]
        new_kwargs = {k: float(v) if isinstance(v, (int, str)) and str(v).replace('.', '', 1).isdigit() else v for k, v in kwargs.items()}
        return func(*new_args, **new_kwargs)
    return wrapper

類別基礎的裝飾器

對於更複雜的需求，例如限速或資源節流，可能需要使用類別基礎的裝飾器，它們可以維護狀態。

import functools
import time

class RateLimit:
    def __init__(self, max_calls, period):
        self.max_calls = max_calls
        self.period = period
        self.calls = []

    def __call__(self, func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            now = time.time()
            self.calls = [timestamp for timestamp in self.calls if now - timestamp < self.period]
            if len(self.calls) >= self.max_calls:
                raise Exception("超過呼叫次數限制")
            self.calls.append(now)
            return func(*args, **kwargs)
        return wrapper

圖表翻譯：

  flowchart TD
    A[開始] --> B[定義裝飾器]
    B --> C[實作裝飾器邏輯]
    C --> D[應用裝飾器]
    D --> E[執行被裝飾的函式]
    E --> F[傳回結果]

這個流程圖描述了從定義一個裝飾器到應用它並執行被裝飾的函式的整個過程。每一步驟都對應到上述程式碼中的特定部分，展示瞭如何設計和使用自訂裝飾器來增強函式的功能。

瞭解 Python 中的裝飾器（Decorators）

Python 的裝飾器是一種強大的工具，能夠在不修改原始函式的情況下擴充套件其功能。它們允許你包裝另一個函式，以擴充套件其行為，同時不改變原始函式的介面和實作。

基本概念

裝飾器是一種特殊的函式，它可以接受另一個函式作為引數，並傳回一個新的函式。這個新的函式「包裝」了原始函式，能夠在呼叫原始函式之前和之後執行任意的程式碼。

實作速率限制的裝飾器

以下是一個簡單的速率限制裝飾器的實作：

import time
from functools import wraps

def rate_limit(max_calls, period):
    def decorator(func):
        calls = []
        @wraps(func)
        def wrapper(*args, **kwargs):
            current_time = time.time()
            calls[:] = [timestamp for timestamp in calls if current_time - timestamp < period]
            if len(calls) >= max_calls:
                raise RuntimeError("Rate limit exceeded")
            calls.append(current_time)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@rate_limit(max_calls=3, period=5)
def perform_action():
    return "Action performed"

這個裝飾器會追蹤在給定的時間段內被呼叫的次數，如果超過最大允許的次數，就會引發一個 RuntimeError。

取得原始函式

當使用多個裝飾器時，除錯可能會變得複雜。為了簡化這個過程，你可以使用 __wrapped__ 屬性來存取原始函式：

def get_original_function(func):
    while hasattr(func, "__wrapped__"):
        func = func.__wrapped__
    return func

這個函式會遞迴地解封裝裝飾器，直到找到原始函式。

強大的例外處理裝飾器

你也可以使用裝飾器來簡化例外處理。以下是一個簡單的例外處理裝飾器的實作：

import logging
from functools import wraps

def robust_execution(fallback_value=None):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except Exception as e:
                logging.error(f"Error occurred: {e}")
                if fallback_value is not None:
                    return fallback_value
                else:
                    raise
        return wrapper
    return decorator

這個裝飾器會捕捉任何異常，記錄錯誤訊息，並傳回一個預設值或重新引發異常。

3.3 Decorator Chaining and Nesting

在 Python 中，裝飾器（Decorator）是一種強大的工具，能夠用於修改或擴充套件函式的行為。當多個裝飾器被應用到同一個函式時，就會形成裝飾器鏈（Decorator Chaining）或巢狀（Nesting）。這種技術可以用於建構模組化、可組合的修改，每個裝飾器封裝著不同的橫切關注點（Cross-Cutting Concerns），例如快取、日誌記錄、身份驗證和例外處理。

3.3.1 Decorator Chaining

當多個裝飾器被應用到同一個函式時，Python 會從下往上應用它們。也就是說，離函式定義最近的裝飾器先被應用，然後是下一個，依此類別推。每個裝飾器都會將前一個裝飾器的結果作為輸入，然後再包裝一次。

以下是一個示例：

import functools

def decorator_one(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Decorator One: Entering")
        result = func(*args, **kwargs)
        print("Decorator One: Exiting")
        return result
    return wrapper

def decorator_two(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Decorator Two: Entering")
        result = func(*args, **kwargs)
        print("Decorator Two: Exiting")
        return result
    return wrapper

def decorator_three(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Decorator Three: Entering")
        result = func(*args, **kwargs)
        print("Decorator Three: Exiting")
        return result
    return wrapper

@decorator_one
@decorator_two
@decorator_three
def example_function():
    print("Example Function: Executing")

example_function()

輸出結果：

Decorator One: Entering
Decorator Two: Entering
Decorator Three: Entering
Example Function: Executing
Decorator Three: Exiting
Decorator Two: Exiting
Decorator One: Exiting

3.3.2 Decorator Nesting

裝飾器巢狀是指在一個裝飾器中又定義了另一個裝飾器。這種技術可以用於建構更複雜的修改。

以下是一個示例：

import functools

def outer_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Outer Decorator: Entering")
        result = func(*args, **kwargs)
        print("Outer Decorator: Exiting")
        return result
    return wrapper

def inner_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Inner Decorator: Entering")
        result = func(*args, **kwargs)
        print("Inner Decorator: Exiting")
        return result
    return wrapper

@outer_decorator
@inner_decorator
def example_function():
    print("Example Function: Executing")

example_function()

輸出結果：

Outer Decorator: Entering
Inner Decorator: Entering
Example Function: Executing
Inner Decorator: Exiting
Outer Decorator: Exiting

Decorator 的巢狀結構與應用

在 Python 中，Decorator 是一種強大的工具，允許開發者在不修改原始函式的情況下新增額外的功能。當多個 Decorator 被應用到同一個函式上時，它們的執行順序就變得非常重要。

Decorator 的執行順序

當我們將多個 Decorator 應用到同一個函式上時，它們的執行順序是由它們的定義順序決定。具體來說，最後定義的 Decorator 最先被執行。例如：

@decorator_one
@decorator_two
@decorator_three
def process_data(value):
    print(f"Processing value: {value}")
    return value * 2

在這個例子中，decorator_three 最先被執行，然後是 decorator_two，最後是 decorator_one。

Decorator 的巢狀結構

Decorator 的巢狀結構允許我們在一個 Decorator 中巢狀另一個 Decorator。這種結構可以用來實作複雜的邏輯和功能。例如：

def decorator_one(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Decorator One: Entering")
        result = func(*args, **kwargs)
        print("Decorator One: Exiting")
        return result
    return wrapper

def decorator_two(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Decorator Two: Entering")
        result = func(*args, **kwargs)
        print("Decorator Two: Exiting")
        return result
    return wrapper

def decorator_three(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Decorator Three: Entering")
        result = func(*args, **kwargs)
        print("Decorator Three: Exiting")
        return result
    return wrapper

@decorator_one
@decorator_two
@decorator_three
def process_data(value):
    print(f"Processing value: {value}")
    return value * 2

在這個例子中，decorator_one、decorator_two 和 decorator_three 都是獨立的 Decorator，但它們可以被巢狀地應用到同一個函式上。

函式的後設資料

當我們使用 Decorator 時，函式的後設資料（如 __name__、__doc__ 等）可能會被改變。為了避免這種情況，我們可以使用 functools.wraps 來保留原始函式的後設資料。

條件性 Decorator

我們也可以根據特定的條件來應用 Decorator。例如：

import functools

def conditional_decorator(predicate, decorator):
    def wrapper(func):
        if predicate():
            return decorator(func)
        else:
            return func
    return wrapper

在這個例子中，conditional_decorator 是一個工廠函式，它根據 predicate 的傳回值來決定是否應用 Decorator。

使用 Python 裝飾器實作函式增強

裝飾器是一種強大的工具，能夠在不修改原始函式的情況下，為其新增額外的功能。以下是使用 Python 裝飾器實作函式增強的範例。

簡單記錄裝飾器

首先，我們定義一個簡單的記錄裝飾器，該裝飾器會在函式被呼叫時，記錄函式名稱、引數和關鍵字引數。

import functools

def simple_logger(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"LOG: {func.__name__} called with {args} and {kwargs}")
        return func(*args, **kwargs)
    return wrapper

簡單快取裝飾器

接下來，我們定義一個簡單的快取裝飾器，該裝飾器會將函式的結果快取起來，以便下次呼叫時直接傳回快取的結果。

def simple_cache(func):
    cache = {}
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        key = (args, tuple(sorted(kwargs.items())))
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]
    return wrapper

條件裝飾器

然後，我們定義一個條件裝飾器，該裝飾器會根據指定的條件決定是否應用裝飾器。

def conditional_decorator(condition, decorator):
    def wrapper(func):
        if condition():
            return decorator(func)
        else:
            return func
    return wrapper

錯誤處理裝飾器

最後，我們定義一個錯誤處理裝飾器，該裝飾器會捕捉函式呼叫中的異常，並將其重新丟擲或透明地傳遞給上層例外處理器。

def error_handler(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            # 處理異常或重新丟擲異常
            raise
    return wrapper

範例使用

現在，我們可以使用這些裝飾器來增強我們的函式。例如：

@conditional_decorator(lambda: os.getenv("DEBUG", "False") == "True", simple_logger)
@simple_cache
def compute(value):
    return value ** 2

在這個範例中，compute 函式會根據 DEBUG 環境變數決定是否應用記錄裝飾器。同時，compute 函式也會被簡單快取裝飾器所增強。

瞭解裝飾器的運作機制

裝飾器（Decorator）是一種特殊的設計模式，能夠在不修改原有程式碼結構的情況下，動態地擴充或修改函式的行為。它們常被用於日誌記錄、錯誤處理、授權檢查等方面。

錯誤處理裝飾器

以下是一個基本的錯誤處理裝飾器範例：

def error_handler(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            print(f"Error in {func.__name__}: {e}")
    return wrapper

這個裝飾器會捕捉被裝飾函式中發生的任何異常，並列印預出錯誤資訊。

多個裝飾器的使用

當多個裝飾器被應用到同一個函式上時，它們的執行順序是從下往上，也就是說，最靠近函式定義的裝飾器先被執行。例如：

@error_handler
@decorator_two
@decorator_one
def risky_operation(x, y):
    return x / y

在這個例子中，decorator_one 先被執行，然後是 decorator_two，最後是 error_handler。

裝飾器鏈的效能考慮

鏈式裝飾器可能會導致效能問題，因為每個裝飾器都會引入額外的函式呼叫開銷。為了減輕這種影響，可以使用快取或有條件地短路裝飾器邏輯等技術。

在深入探討 Python 裝飾器之後，我們可以清楚地看到其在簡化程式碼、提升程式碼可讀性和可維護性方面的顯著優勢。從基本的函式包裝到更進階的應用，如快取、存取控制、錯誤處理和速率限制，裝飾器提供了一種優雅且有效的方式來管理程式碼中的橫切關注點。

透過使用裝飾器，開發者可以避免重複的程式碼，並將複雜的邏輯封裝到可重複使用的單元中。這不僅提高了程式碼的模組化程度，也降低了維護成本。尤其是在大型專案中，裝飾器的使用可以顯著提升程式碼的可管理性和可擴充套件性。

然而，裝飾器也並非沒有缺點。過度使用裝飾器可能會導致程式碼難以理解和除錯。因此，在使用裝飾器時，務必謹慎考慮其必要性和複雜度，並確保程式碼保持清晰易懂。

隨著 Python 語言的發展，裝飾器的應用場景將會更加廣泛。開發者需要深入理解裝飾器的運作機制，才能更好地利用其優勢，並避免潛在的陷阱。持續學習和探索裝飾器的最佳實踐，將有助於開發者編寫更優雅、更有效率的 Python 程式碼。對於追求程式碼品質和效率的開發者而言，掌握裝飾器的使用無疑是一項重要的技能。

玄貓

玄貓

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