91超碰碰碰碰久久久久久综合_超碰av人澡人澡人澡人澡人掠_国产黄大片在线观看画质优化_txt小说免费全本

溫馨提示×

溫馨提示×

您好,登錄后才能下訂單哦!

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

Python中的裝飾器是什么以及運作方法介紹

發布時間:2021-03-08 14:13:44 來源:億速云 閱讀:248 作者:TREX 欄目:編程語言

這篇文章主要介紹“Python中的裝飾器是什么以及運作方法介紹”,在日常操作中,相信很多人在Python中的裝飾器是什么以及運作方法介紹問題上存在疑惑,小編查閱了各式資料,整理出簡單好用的操作方法,希望對大家解答”Python中的裝飾器是什么以及運作方法介紹”的疑惑有所幫助!接下來,請跟著小編一起來學習吧!

Python中的裝飾器是什么以及運作方法介紹

Python很早就引入了裝飾器——在PEP-318中,作為一種簡化函數和方法定義方式的機制,這些函數和方法在初始定義之后必須進行修改。

這樣做的最初動機之一是,使用classmethod和staticmethod等函數來轉換方法的原始定義,但是它們需要額外的一行代碼來修改函數的初始定義。

一般來說,每次必須對函數應用轉換時,我們必須使用modifier函數調用它,然后將它重新分配到函數初始定義時的名稱中。

例如,假設有一個叫作original的函數,在它上面有一個改變original行為的函數(叫作modifier),那么我們必須這樣寫:

def original(...):
    ...
original = modifier(original)

(相關免費學習推薦:python視頻教程)

請注意我們是如何更改函數并將其重新分配到相同的名稱中去的。這是令人困惑的,很容易出錯(假設有人忘記重新分配函數,或者重新分配了函數,但不在函數定義之后的行中,而是在更遠的地方),而且很麻煩。出于這個原因,Python語言增加了一些語法支持。

前面的示例可以改寫為如下樣式:

@modifier
def original(...):
   ...

這意味著裝飾器只是語法糖,用于調用裝飾器之后的內容作為裝飾器本身的第一個參數,結果將是裝飾器返回的內容。

為了與Python的術語一致,在我們的示例中modifier稱為裝飾器,original是裝飾函數,通常也被稱為包裝對象。

雖然該功能最初被認為是用于方法和函數的,但實際的語法允許它修飾任何類型的對象,因此我們將研究應用于函數、方法、生成器和類的裝飾器。

最后一點需要注意的是,雖然裝飾器的名稱是正確的(畢竟,裝飾器實際上是在對包裝函數進行更改、擴展或處理),但不要將它與裝飾器設計模式混淆。

5.1.1 裝飾器函數

函數可能是對可以裝飾的Python對象的最簡單的表示形式。我們可以在函數上使用裝飾器來應用各種邏輯——我們可以驗證參數、檢查前置條件、完全改變行為、修改其簽名、緩存結果(創建原始函數的內存版本)等。

例如,我們將創建一個實現retry機制的基本裝飾器,控制一個特定的域級異常并重試一定的次數:

# decorator_function_1.py
class ControlledException(Exception):
    """A generic exception on the program's domain."""

def retry(operation):
    @wraps(operation)
    def wrapped(*args, **kwargs):
        last_raised = None
        RETRIES_LIMIT = 3
        for _ in range(RETRIES_LIMIT):
            try:
                return operation(*args, **kwargs)
            except ControlledException as e:
                logger.info("retrying %s", operation.__qualname__)
                last_raised = e
        raise last_raised

    return wrapped

現在可以忽略@wrap的使用,因為它將在另一節中討論。在for循環中使用“_”,意味著這個數字被分配給一個我們目前不感興趣的變量,因為它不在for循環中使用(在Python中,將被忽略的值命名為“_”是一個常見的習慣用法)。

retry裝飾器不接收任何參數,所以它可以很容易地應用于任何函數,如下所示:

@retry
def run_operation(task):
    """Run a particular task, simulating some failures on its execution."""
    return task.run()

正如一開始所解釋的,在run_operation之上@retry的定義只是Python提供的語法糖,用于實際執行run_operation = retry(run_operation)。

在這個有限的示例中,我們可以看到如何用裝飾器創建一個通用的retry操作,在某些確定的條件下(在本示例中,表示為可能與超時相關的異常),該操作將允許多次調用裝飾后的代碼。

5.1.2 裝飾類

類也可以被裝飾(PEP-3129),其裝飾方法與語法函數的裝飾方法相同。唯一的區別是,在為裝飾器編寫代碼時,我們必須考慮到所接收的是一個類,而不是一個函數。

一些實踐者可能會認為裝飾類是相當復雜的事情,這樣的場景可能會損害可讀性,因為我們將在類中聲明一些屬性和方法,但是在幕后,裝飾器可能會應用一些變化,從而呈現一個完全不同的類。

這種評定是正確的,但只有在裝飾類技術被嚴重濫用的情況下成立。客觀上,這與裝飾功能沒有什么不同;畢竟,類和函數一樣,都只是Python生態系統中的一種類型的對象而已。在5.4節中,我們將再次審視這個問題的優缺點,但是這里只探索裝飾器的優點,尤其是適用于類的裝飾器的優點。

(1)重用代碼和DRY原則的所有好處。類裝飾器的一個有效情況是,強制多個類符合特定的接口或標準(通過只在將應用于多個類的裝飾器中進行一次檢查)。

(2)可以創建更小或更簡單的類——這些類稍后將由裝飾器進行增強。

(3)如果使用裝飾器,那么需要應用到特定類上的轉換邏輯將更容易維護,而不會使用更復雜的(通常是不鼓勵使用的)方法,如元類。

在裝飾器的所有可能應用程序中,我們將探索一個簡單的示例,以了解裝飾器可以用于哪些方面。記住,這不是類裝飾器的唯一應用程序類型,而且給出的代碼還可以有許多其他解決方案。所有這些解決方案都有優缺點,之所以選擇裝飾器,是為了說明它們的用處。

回顧用于監視平臺的事件系統,現在需要轉換每個事件的數據并將其發送到外部系統。然而,在選擇如何發送數據時,每種類型的事件可能都有自己的特殊性。

特別是,登錄事件可能包含敏感信息,例如我們希望隱藏的憑據。時間戳等其他領域的字段可能也需要一些轉換,因為我們希望以特定的格式顯示它們。符合這些要求的第一次嘗試很簡單,就像有一個映射到每個特定事件的類,并知道如何序列化它那樣:

class LoginEventSerializer:
    def __init__(self, event):
        self.event = event

    def serialize(self) -> dict:
        return {
            "username": self.event.username,
            "password": "**redacted**",
            "ip": self.event.ip,
            "timestamp": self.event.timestamp.strftime("%Y-%m-%d
             %H:%M"),
        }

class LoginEvent:
    SERIALIZER = LoginEventSerializer

    def __init__(self, username, password, ip, timestamp):
        self.username = username
        self.password = password
        self.ip = ip
        self.timestamp = timestamp

    def serialize(self) -> dict:
        return self.SERIALIZER(self).serialize()

在這里,我們聲明一個類。該類將直接映射到登錄事件,其中包含它的一些邏輯——隱藏密碼字段,并根據需要格式化時間戳。

雖然這是可行的,可能開始看起來是一個不錯的選擇,但隨著時間的推移,若要擴展系統,就會發現一些問題。

(1)類太多。隨著事件數量的增多,序列化類的數量將以相同的量級增長,因為它們是一一映射的。

(2)解決方案不夠靈活。如果我們需要重用部分組件(例如,需要把密碼藏在也有類似需求的另一個類型的事件中),就不得不將其提取到一個函數,但也要從多個類中調用它,這意味著我們沒有重用那么多代碼。

(3)樣板文件。serialize()方法必須出現在所有事件類中,同時調用相同的代碼。盡管我們可以將其提取到另一個類中(創建mixin),但這似乎沒有很好地使用繼承。

另一種解決方案是能夠動態構造一個對象:給定一組過濾器(轉換函數)和一個事件實例,該對象能夠通過將過濾器應用于其字段的方式序列化它。然后,我們只需要定義轉換每種字段類型的函數,并通過組合這些函數創建序列化器。

一旦有了這個對象,我們就可以裝飾類以添加serialize()方法。該方法只會調用這些序列化對象本身:

def hide_field(field) -> str:
    return "**redacted**"

def format_time(field_timestamp: datetime) -> str:
    return field_timestamp.strftime("%Y-%m-%d %H:%M")

def show_original(event_field):
    return event_field

class EventSerializer:
    def __init__(self, serialization_fields: dict) -> None:
        self.serialization_fields = serialization_fields

    def serialize(self, event) -> dict:
        return {
            field: transformation(getattr(event, field))
            for field, transformation in
            self.serialization_fields.items()
        }

class Serialization:
    def __init__(self, **transformations):
        self.serializer = EventSerializer(transformations)

    def __call__(self, event_class):
        def serialize_method(event_instance):
                return self.serializer.serialize(event_instance)
            event_class.serialize = serialize_method
            return event_class

@Serialization(
    username=show_original,
    password=hide_field,
    ip=show_original,
    timestamp=format_time,
)
class LoginEvent:

    def __init__(self, username, password, ip, timestamp):
        self.username = username
        self.password = password
        self.ip = ip
        self.timestamp = timestamp

注意,裝飾器讓你更容易知道如何處理每個字段,而不必查看另一個類的代碼。僅通過讀取傳遞給類裝飾器的參數,我們就知道用戶名和IP地址將保持不變,密碼將被隱藏,時間戳將被格式化。

現在,類的代碼不需要定義serialize()方法,也不需要從實現它的mixin類進行擴展,因為這些都將由裝飾器添加。實際上,這可能是創建類裝飾器的唯一理由,因為如果不是這樣的話,序列化對象可能是LoginEvent的一個類屬性,但是它通過向該類添加一個新方法來更改類,這使得創建該類裝飾器變得不可能。

我們還可以使用另一個類裝飾器,通過定義類的屬性來實現init方法的邏輯,但這超出了本例的范圍。

通過使用Python 3.7+ 中的這個類裝飾器(PEP-557),可以按更簡潔的方式重寫前面的示例,而不使用init的樣板代碼,如下所示:

from dataclasses import dataclass
from datetime import datetime

@Serialization(
    username=show_original,
    password=hide_field,
    ip=show_original,
    timestamp=format_time,
)
@dataclass
class LoginEvent:
    username: str
    password: str
    ip: str
    timestamp: datetime

5.1.3 其他類型的裝飾器

既然我們已經知道了裝飾器的@語法的實際含義,就可以得出這樣的結論:可以裝飾的不僅是函數、方法或類;實際上,任何可以定義的東西(如生成器、協同程序甚至是裝飾過的對象)都可以裝飾,這意味著裝飾器可以堆疊起來。

前面的示例展示了如何鏈接裝飾器。我們先定義類,然后將@dataclass應用于該類——它將該類轉換為數據類,充當這些屬性的容器。之后,通過@Serialization把邏輯應用到該類上,從而生成一個新類,其中添加了新的serialize()方法。

裝飾器另一個好的用法是用于應該用作協同程序的生成器。我們將在第7章中探討生成器和協同程序的細節,其主要思想是,在向新創建的生成器發送任何數據之前,必須通過調用next()將后者推進到下一個yield語句。這是每個用戶都必須記住的手動過程,因此很容易出錯。我們可以輕松創建一個裝飾器,使其接收生成器作為參數,調用next(),然后返回生成器。

5.1.4 將參數傳遞給裝飾器

至此,我們已經將裝飾器看作Python中的一個強大工具。如果我們可以將參數傳遞給裝飾器,使其邏輯更加抽象,那么其功能可能會更加強大。

有幾種實現裝飾器的方法可以接收參數,但是接下來我們只討論最常見的方法。第一種方法是將裝飾器創建為帶有新的間接層的嵌套函數,使裝飾器中的所有內容深入一層。第二種方法是為裝飾器使用一個類。

通常,第二種方法更傾向于可讀性,因為從對象的角度考慮,其要比3個或3個以上使用閉包的嵌套函數更容易。但是,為了完整起見,我們將對這兩種方法進行探討,以便你可以選擇使用最適合當前問題的方法。

1.帶有嵌套函數的裝飾器

粗略地說,裝飾器的基本思想是創建一個返回函數的函數(通常稱為高階函數)。在裝飾器主體中定義的內部函數將是實際被調用的函數。

現在,如果希望將參數傳遞給它,就需要另一間接層。第一個函數將接收參數,在該函數中,我們將定義一個新函數(它將是裝飾器),而這個新函數又將定義另一個新函數,即裝飾過程返回的函數。這意味著我們將至少有3層嵌套函數。

如果你到目前為止還不明白上述內容的含義,也不用擔心,待查看下面給出的示例之后,就會明白了。

第一個示例是,裝飾器在一些函數上實現重試功能。這是個好主意,只是有個問題:實現不允許指定重試次數,只允許在裝飾器中指定一個固定的次數。

現在,我們希望能夠指出每個示例有多少次重試,也許甚至可以為這個參數添加一個默認值。為了實現這個功能,我們需要用到另一層嵌套函數——先用于參數,然后用于裝飾器本身。

這是因為如下代碼:

@retry(arg1, arg2,... )

必須返回裝飾器,因為@語法將把計算結果應用到要裝飾的對象上。從語義上講,它可以翻譯成如下內容:

<original_function> = retry(arg1, arg2, ....)(<original_function>)

除了所需的重試次數,我們還可以指明希望控制的異常類型。支持新需求的新版本代碼可能是這樣的:

RETRIES_LIMIT = 3

def with_retry(retries_limit=RETRIES_LIMIT, allowed_exceptions=None):
    allowed_exceptions = allowed_exceptions or (ControlledException,)

    def retry(operation):

        @wraps(operation)
        def wrapped(*args, **kwargs):
            last_raised = None
            for _ in range(retries_limit):
                try:
                    return operation(*args, **kwargs)
                except allowed_exceptions as e:
                    logger.info("retrying %s due to %s", operation, e)
                    last_raised = e
            raise last_raised

        return wrapped

    return retry

下面是這個裝飾器如何應用于函數的一些示例,其中顯示了它接收的不同選項:

# decorator_parametrized_1.py
@with_retry()
def run_operation(task):
    return task.run()

@with_retry(retries_limit=5)
def run_with_custom_retries_limit(task):
    return task.run()

@with_retry(allowed_exceptions=(AttributeError,))
def run_with_custom_exceptions(task):
    return task.run()

@with_retry(
    retries_limit=4, allowed_exceptions=(ZeropisionError, AttributeError)
)
def run_with_custom_parameters(task):
    return task.run()

2.裝飾器對象

前面的示例需要用到3層嵌套函數。首先,這將是一個用于接收我們想要使用的裝飾器的參數。在這個函數中,其余的函數是使用這些參數和裝飾器邏輯的閉包。

更簡潔的實現方法是用一個類定義裝飾器。在這種情況下,我們可以在__init__方法中傳遞參數,然后在名為__call__的魔法方法上實現裝飾器的邏輯。

裝飾器的代碼如下所示:

class WithRetry:

    def __init__(self, retries_limit=RETRIES_LIMIT,
allowed_exceptions=None):
        self.retries_limit = retries_limit
        self.allowed_exceptions = allowed_exceptions or
(ControlledException,)

    def __call__(self, operation):

        @wraps(operation)
        def wrapped(*args, **kwargs):
            last_raised = None

            for _ in range(self.retries_limit):
                try:
                    return operation(*args, **kwargs)
                except self.allowed_exceptions as e:
                    logger.info("retrying %s due to %s", operation, e)
                    last_raised = e
            raise last_raised

        return wrapped

這個裝飾器可以像之前的一樣應用,就像這樣:

@WithRetry(retries_limit=5)
def run_with_custom_retries_limit(task):
    return task.run()

注意Python語法在這里是如何起作用的,這一點很重要。首先,我們創建對象,這樣在應用@操作之前,對象已經創建好了,并且其參數傳遞給它了,用這些參數初始化這個對象,如init方法中定義的那樣。在此之后,我們將調用@操作,這樣該對象將包裝名為run_with_custom_reries_limit的函數,而這意味著它將被傳遞給call這個魔法方法。

在call這個魔法方法中,我們定義了裝飾器的邏輯,就像通常所做的那樣——包裝了原始函數,返回一個新的函數,其中包含所要的邏輯。

5.1.5 充分利用裝飾器

本節介紹一些充分利用裝飾器的常見模式。在有些常見的場景中使用裝飾器是個非常好的選擇。

可用于應用程序的裝飾器數不勝數,下面僅列舉幾個最常見或相關的。

(1)轉換參數。更改函數的簽名以公開更好的API,同時封裝關于如何處理和轉換參數的詳細信息。

(2)跟蹤代碼。記錄函數及其參數的執行情況。

(3)驗證參數

(4)實現重試操作

(5)通過把一些(重復的)邏輯移到裝飾器中來簡化類

接下來詳細討論前兩個應用程序。

1.轉換參數

前文提到,裝飾器可以用來驗證參數(甚至在DbC的概念下強制一些前置條件或后置條件),因此你可能已經了解到,這是一些處理或者操控參數時使用裝飾器的常用方法。

特別是,在某些情況下,我們會發現自己反復創建類似的對象,或者應用類似的轉換,而我們希望將這些轉換抽象掉。大多數時候,我們可以通過簡單地用裝飾器實現這一點。

2.跟蹤代碼

在本節中討論跟蹤時,我們將提到一些更通用的內容,這些內容與處理所要監控的函數的執行有關,具體是指:

(1)實際跟蹤函數的執行(例如,通過記錄函數執行的行);

(2)監控函數的一些指標(如CPU使用量或內存占用);

(3)測量函數的運行時間;

(4)函數被調用時的日志,以及傳遞給它的參數。

我們將在5.2節剖析一個簡單的裝飾器示例,該示例記錄了函數的執行情況,包括函數名和運行時間。

本文摘自《編寫整潔的Python代碼》

本書介紹Python軟件工程的主要實踐和原則,旨在幫助讀者編寫更易于維護和更整潔的代碼。全書共10章:第1章介紹Python語言的基礎知識和搭建Python開發環境所需的主要工具;第2章描述Python風格代碼,介紹Python中的第一個習慣用法;第3章總結好代碼的一般特征,回顧軟件工程中的一般原則;第4章介紹一套面向對象軟件設計的原則,即SOLID原則;第5章介紹裝飾器,它是Python的**特性之一;第6章探討描述符,介紹如何通過描述符從對象中獲取更多的信息;第7章和第8章介紹生成器以及單元測試和重構的相關內容;第9章回顧Python中最常見的設計模式;第10章再次強調代碼整潔是實現良好架構的基礎。

本書適合所有Python編程愛好者、對程序設計感興趣的人,以及其他想學習更多Python知識的軟件工程的從業人員。


到此,關于“Python中的裝飾器是什么以及運作方法介紹”的學習就結束了,希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習,快去試試吧!若想繼續學習更多相關知識,請繼續關注億速云網站,小編會繼續努力為大家帶來更多實用的文章!

向AI問一下細節

免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。

AI

甘南县| 潼南县| 巴青县| 黑龙江省| 马公市| 新安县| 娱乐| 休宁县| 遂溪县| 宾川县| 伊吾县| 安溪县| 响水县| 郧西县| 梁山县| 沾化县| 丹阳市| 迁安市| 昌平区| 富宁县| 韶关市| 兴城市| 米脂县| 岑溪市| 公主岭市| 精河县| 儋州市| 盐城市| 沙湾县| 沾化县| 申扎县| 迁安市| 孟州市| 宣汉县| 新绛县| 云霄县| 枝江市| 商南县| 镇安县| 罗平县| 陆良县|