2. 程式人生 > 其它 >讓程式碼更具 Python 範兒的裝飾器

讓程式碼更具 Python 範兒的裝飾器

阿新 • • 發佈：2021-01-25

技術標籤：pythonpython

在 Python 中，裝飾器的作用是在不改變函式或類的程式碼的前提下，改變函式或類的功能。在介紹裝飾器之前，我們先來複習下 Python 中的函式。

函式

1. 函式也是物件
def foo():
    print("Hello World!")

bar = foo

bar()

output：

Hello World!

在上面的例子中，首先定義了函式 foo() ，然後將函式 foo 賦給變數 bar ，這樣我們便可以通過 bar() 來呼叫函式。

2. 函式作為引數
def foo():
    print("I am foo"
 
)


def bar(func):
    print("I am bar")
    func()


bar(foo)

output：

I am bar
I am foo

在上面的例子中，函式 foo() 作為引數傳入到 bar() 函式，然後再 bar() 函式內部通過引數來呼叫函式 foo()。

3. 函式巢狀
def parent():
    print("I am parent")

    def foo_child():
        print("I am foo")

    def bar_child(
 
):
        print("I am bar")

    foo_child()
    bar_child()


parent()

output：

I am parent
I am foo
I am bar

在上面的例子中，函式 foo_child() 和 bar_child() 巢狀在函式 parent() 的內部。巢狀在函式內部的函式只能在函式內部呼叫，從外部呼叫會報錯。例如：

def parent():
    print("I am parent")

    def foo_child():
        print("I am foo"
 
)

    def bar_child():
        print("I am bar")

    foo_child()
    bar_child()


foo_child()

output：

Traceback (most recent call last):
  File "/Users/weisong/PycharmProjects/pythonProject/greet.py", line 14, in <module>
    foo_child()
NameError: name 'foo_child' is not defined
4. 函式作為返回值
def parent(name):
    def foo_child():
        print("I am foo")

    def bar_child():
        print("I am bar")

    if name == 'foo':
        return foo_child
    else:
        return bar_child


foo = parent("foo")
bar = parent("bar")


foo()
bar()

output：

I am foo
I am bar

在上面的例子中，parent() 函式根據傳入的引數返回函式 foo_child 或者 bar_child，得到 parent() 函式的返回值之後，我們可以使用返回值呼叫相應的函式。

裝飾器

1. 一個簡單的裝飾器

介紹完函式的各種用法後，我們來看一個簡單的裝飾器（decorator）。

def my_decorator(func):
    def wrapper():
        print("Do something before function is called")
        func()
        print("Do something after function is called")
    return wrapper


def foo():
    print("I am foo")


foo = my_decorator(foo)
foo()

output：

Do something before function is called
I am foo
Do something after function is called

在上面的例子中，語句 foo = my_decorator(foo) 將 my_decorator 函式的返回值 wrapper 函式賦給 foo ，這樣我們便可以使用 foo 來呼叫 wrapper 函式，在 wrapper 函式中包含著作為引數傳入的函式的呼叫，所以會輸出 I am foo。

2. 語法糖

上面使用裝飾器的方式有點笨重，Python 提供了一種更簡單的方式來使用裝飾器，這便是使用 @ 符號，我們稱之為語法糖。使用 @ 符號，將上面的裝飾器修改如下：

def my_decorator(func):
    def wrapper():
        print("Do something before function is called")
        func()
        print("Do something after function is called")
    return wrapper


@my_decorator
def foo():
    print("I am foo")


foo()

output：

Do something before function is called
I am foo
Do something after function is called

@my_decorator 相當於前面的 foo = my_decorator(foo)，使用方式較前面簡潔了許多。另外，如果程式中有其他的函式需要類似的裝飾，只需要在它們的上方加上 @my_decorator 就可以了，大大提高了程式的可複用性和可讀性。

3. 帶引數的裝飾器
def my_decorator(func):
    def wrapper(greet):
        print("Do something before function is called")
        func(greet)
        print("Do something after function is called")
    return wrapper


@my_decorator
def foo(greet):
    print(f"{greet}, I am foo")


foo("Hello")

output：

Do something before function is called
Hello, I am foo
Do something after function is called

在為函式 foo() 加了引數 greet 之後，呼叫函式 foo() 時便可以傳入引數。當然裝飾器也要做相應的修改，為函式 wrapper 也添加了引數 greet。但是上述加引數的方式有一個缺點，當使用這個裝飾器來裝飾一個不帶引數的函式時，呼叫便會發生錯誤。例如：

def my_decorator(func):
    def wrapper(greet):
        print("Do something before function is called")
        func(greet)
        print("Do something after function is called")
    return wrapper


@my_decorator
def foo():
    print("I am foo")


foo()

output：

Traceback (most recent call last):
  File "/Users/weisong/PycharmProjects/pythonProject/greet.py", line 14, in <module>
    foo()
TypeError: wrapper() missing 1 required positional argument: 'greet'

為了相容帶引數的呼叫和不帶引數的呼叫，可以將裝飾器函式修改如下：

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Do something before function is called")
        func(*args, **kwargs)
        print("Do something after function is called")
    return wrapper


@my_decorator
def foo():
    print("I am foo")


@my_decorator
def bar(greet):
    print(f"{greet}, I am bar")


foo()
bar("Hello")

output：

Do something before function is called
I am foo
Do something after function is called
Do something before function is called
Hello, I am bar
Do something after function is called
4. 帶自定義引數的裝飾器
def repeat(num):
    def my_decorator(func):
        def wrapper(*args, **kwargs):
            print("do something before function is called")
            for i in range(num):
                func(*args, **kwargs)
            print("do something after function is called")
        return wrapper
    return my_decorator


@repeat(2)
def foo():
    print("I am foo")


@repeat(3)
def bar(greet):
    print(f"{greet}, I am bar")


foo()
bar("Hello")

output：

Do something before function is called
I am foo
I am foo
Do something after function is called
Do something before function is called
Hello, I am bar
Hello, I am bar
Hello, I am bar
Do something after function is called

上面的例子中，使用裝飾器時傳入了引數 num ，用來表示內部函式執行的次數。

5. 被裝飾的函式還是它自己嗎？

還是使用前面的例子，我們打出函式 foo 和 bar() 的元資訊，看看被裝飾器修飾後還是不是它們自己。

def repeat(num):
    def my_decorator(func):
        def wrapper(*args, **kwargs):
            print("Do something before function is called")
            for i in range(num):
                func(*args, **kwargs)
            print("Do something after function is called")
        return wrapper
    return my_decorator


@repeat(2)
def foo():
    print("I am foo")


@repeat(3)
def bar(greet):
    print(f"{greet}, I am bar")
    

print(foo.__name__)
help(foo)
print("**************************")
print(bar.__name__)
help(bar)

output：

wrapper
Help on function wrapper in module __main__:

wrapper(*args, **kwargs)

**************************
wrapper
Help on function wrapper in module __main__:

wrapper(*args, **kwargs)

從輸出結果可以看出，在被裝飾器修飾後，被修飾函式的元資訊改變了。變成了 wrapper() 函式。可以使用內建的裝飾器@functools.wrap 來解決這個問題，它會保留被修飾函式的元資訊。

import functools


def repeat(num):
    def my_decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print("Do something before function is called")
            for i in range(num):
                func(*args, **kwargs)
            print("Do something after function is called")
        return wrapper
    return my_decorator


@repeat(2)
def foo():
    print("I am foo")


@repeat(3)
def bar(greet):
    print(f"{greet}, I am bar")


print(foo.__name__)
help(foo)
print("**************************")
print(bar.__name__)
help(bar)

output：

foo
Help on function foo in module __main__:

foo()

**************************
bar
Help on function bar in module __main__:

bar(greet)

在使用@functools.wrap 之後，被修飾函式保留了原有的元資訊。

裝飾器的應用例項

1. 記錄函式執行的時間
import functools
import time


def timer(func):
    @functools.wraps(func)
    def wrapper_timer(*args, **kwargs):
        start_time = time.perf_counter()
        func(*args, **kwargs)
        end_time = time.perf_counter()
        run_time = end_time - start_time
        print(f"Finished {func.__name__!r} in {run_time:.4f} secs")
    return wrapper_timer


@timer
def waste_some_time(num_times):
    for _ in range(num_times):
        sum([i**2 for i in range(10000)])


waste_some_time(1)
waste_some_time(1000)

output：

Finished 'waste_some_time' in 0.0037 secs
Finished 'waste_some_time' in 3.3343 secs
2. 控制函式相鄰兩次執行的時間間隔
import functools
import time


def slow_down(func):
    @functools.wraps(func)
    def wrapper_slow_down(*args, **kwargs):
        time.sleep(1)
        return func(*args, **kwargs)
    return wrapper_slow_down


@slow_down
def countdown(from_number):
    if from_number < 1:
        print("Liftoff!")
    else:
        print(from_number)
        countdown(from_number - 1)


countdown(6)

output：

6
5
4
3
2
1
Liftoff!
3. 程式碼 Debug
import functools


def debug(func):
    """Print the function signature and return value"""
    @functools.wraps(func)
    def wrapper_debug(*args, **kwargs):
        args_repr = [repr(a) for a in args]                      
        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]  
        signature = ", ".join(args_repr + kwargs_repr)           
        print(f"Calling {func.__name__}({signature})")
        value = func(*args, **kwargs)
        print(f"{func.__name__!r} returned {value!r}")           
        return value
    return wrapper_debug


@debug
def make_greeting(name, age=None):
    if age is None:
        return f"Howdy {name}!"
    else:
        return f"Whoa {name}! {age} already, you are growing up!"


make_greeting("foo")
make_greeting("foo", 18)

output：

Calling make_greeting('foo')
'make_greeting' returned 'Howdy foo!'
Calling make_greeting('foo', 18)
'make_greeting' returned 'Whoa foo! 18 already, you are growing up!'

總結

本文講述了裝飾器的原理以及用法，裝飾器的存在大大提高了程式碼的可複用性以及簡潔性。
在這裡插入圖片描述

相關推薦

讓程式碼更具 Python 範兒的裝飾器

技術標籤：pythonpython 在 Python 中，裝飾器的作用是在不改變函式或類的程式碼的前提下，改變函式或類的功能。在介紹裝飾器之前，我們先來複習下 Python 中的函式。

Python多個裝飾器的呼叫順序例項解析

一般情況下，在函式中可以使用一個裝飾器，但是有時也會有兩個或兩個以上的裝飾器。多個裝飾器裝飾的順序是從裡到外(就近原則)，而呼叫的順序是從外到裡（就遠原則）

Python新手學習裝飾器

python函數語言程式設計之裝飾器 1.開放封閉原則 簡單來說，就是對擴充套件開放，對修改封閉。

Python閉包裝飾器使用方法彙總

閉包內容： 匿名函式：能夠完成簡單的功能，傳遞這個函式的引用，只有功能

Python如何將裝飾器定義為類

問題 你想使用一個裝飾器去包裝函式，但是希望返回一個可呼叫的例項。 你需要讓你的裝飾器可以同時工作在類定義的內部和外部。

15 Python學習之裝飾器

裝飾器 裝飾器：在不改變源函式的程式碼及呼叫方式的前提下，為其增加新的功能，裝飾器就是一個函式，他的本質是閉包

Python如何建立裝飾器時保留函式元資訊

問題 你寫了一個裝飾器作用在某個函式上，但是這個函式的重要的元資訊比如名字、文件字串、註解和引數簽名都丟失了。

python 高階知識-裝飾器

1、裝飾器(類似於Java裡的註解) import time def decorator(func): def wapper(): print(time.time())

python中的裝飾器

python語言中的裝飾器應該算是這門語言中的一個難點了，作為一個初學者，好像也知道是怎麼回事，可是否真正理解了，那還得存疑。最近偶然看到老男孩的Egon老師的視訊，我才覺得真正明白裝飾器是怎麼一回事了。Egon老

Python 中的裝飾器詳解（@decorator、裝飾器函式、裝飾器類）

一切皆物件的思想 要理解裝飾器，首先需要理解 Python 中函式也是物件的思想。

python內建裝飾器@property

前言 今天來說一下@property裝飾器，這是個python內建的裝飾器，主要是作用是把類中的一個方法變為類中的一個屬性，並且使定義屬性和修改現有屬性變的更容易

python 自定義裝飾器

提醒使用者使用了廢棄的函式 def deprecated(func): \"\"\"This decorator is used to mark functions as deprecated.

Python基於staticmethod裝飾器標示靜態方法

英文文件： staticmethod(function) Return a static method for function. A static method does not receive an implicit first argument.

python學習雜記--裝飾器

裝飾器可以用來在不改變原函式的基礎上，為原函式增添功能 示例如下： 1 import time

python內建裝飾器 @property

最近看Robotframe中SeleniumLibrary 原始碼，發現原始碼中存在許多@property，因此看下python中內建的裝飾器。

python內建裝飾器---- staticmethod和classmethod

staticmethod staticmethod 只能作為函式裝飾器應用。其作用為將一個函式轉換為靜態方法。下面一段程式碼中，若不在def get(argv1)上新增裝飾器staticmethod.

五十八、python 進階 裝飾器

裝飾器總結 什麼是裝飾器？ 處理函式的函式，加一個功能，但是不影響原來函式的內部結構

python函式之裝飾器

1、什麼是裝飾器 裝飾器是一個用來為被裝飾者新增功能的工具 被裝飾者：函式

一文看懂Python系列之裝飾器(decorator)

Python裝飾器的本質 Python的裝飾器本質上是一個巢狀函式，它接受被裝飾的函式(func)作為引數，並返回一個包裝過的函式。這樣我們可以在不改變被裝飾函式的程式碼的情況下給被裝飾函式或程式新增新的功能。Python的

Python學習之裝飾器

裝飾器就是修改其他函式功能的函式。 學習裝飾器，需要一步一步來解析（涉及前面的函式知識）