Ghi nhớ python trang trí

Đối tượng hạng nhất

Trong Python, hàm là đối tượng hạng nhất. Điều này có nghĩa là các hàm có thể được truyền xung quanh và được sử dụng làm đối số, giống như bất kỳ đối tượng nào khác [chuỗi, int, float, danh sách, v.v.]. Hãy xem xét ba chức năng sau

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Ở đây,

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Lưu ý rằng

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

chức năng bên trong

Có thể định nghĩa các chức năng bên trong các chức năng khác. Các chức năng như vậy được gọi là các chức năng bên trong. Đây là một ví dụ về hàm có hai hàm bên trong

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Điều gì xảy ra khi bạn gọi hàm

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Lưu ý rằng thứ tự xác định các hàm bên trong không quan trọng. Giống như bất kỳ chức năng nào khác, quá trình in chỉ diễn ra khi các chức năng bên trong được thực thi

Hơn nữa, các hàm bên trong không được xác định cho đến khi hàm cha được gọi. Chúng nằm trong phạm vi cục bộ tới

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Bất cứ khi nào bạn gọi

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Hàm trả về từ hàm

Python cũng cho phép bạn sử dụng các hàm làm giá trị trả về. Ví dụ sau trả về một trong các hàm bên trong từ hàm

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Lưu ý rằng bạn đang trả về

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Đầu ra hơi khó hiểu chỉ đơn giản có nghĩa là biến

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Giờ đây, bạn có thể sử dụng

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Cuối cùng, lưu ý rằng trong ví dụ trước, bạn đã thực thi các hàm bên trong hàm cha, chẳng hạn như

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Cú pháp đặc biệt

Cách bạn trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Thay vào đó, Python cho phép bạn sử dụng các bộ trang trí theo cách đơn giản hơn với ký hiệu

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Vì vậy,

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Tái sử dụng đồ trang trí

Nhớ lại rằng một trình trang trí chỉ là một hàm Python thông thường. Tất cả các công cụ thông thường để tái sử dụng dễ dàng đều có sẵn. Hãy di chuyển trình trang trí sang mô-đun riêng của nó có thể được sử dụng trong nhiều chức năng khác

Tạo một tệp tên là

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Ghi chú. Bạn có thể đặt tên cho chức năng bên trong của mình bất cứ điều gì bạn muốn và một tên chung chung như

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Bây giờ bạn có thể sử dụng trình trang trí mới này trong các tệp khác bằng cách nhập thông thường

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Khi bạn chạy ví dụ này, bạn sẽ thấy rằng bản gốc

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Tiền thưởng miễn phí. Nhấp vào đây để truy cập vào hướng dẫn miễn phí "Sức mạnh của Trình trang trí Python" hiển thị cho bạn ba mẫu và kỹ thuật trang trí nâng cao mà bạn có thể sử dụng để viết các chương trình Pythonic rõ ràng hơn

Các chức năng trang trí với các đối số

Giả sử rằng bạn có một hàm chấp nhận một số đối số. Bạn vẫn có thể trang trí nó?

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Thật không may, chạy mã này gây ra lỗi

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Vấn đề là hàm bên trong

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Giải pháp là sử dụng

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Hàm bên trong

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Trả về các giá trị từ các chức năng được trang trí

Điều gì xảy ra với giá trị trả về của các chức năng được trang trí? . Giả sử bạn trang trí một chức năng đơn giản như sau

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Cố gắng sử dụng nó

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Rất tiếc, trình trang trí của bạn đã ăn giá trị trả về từ hàm

Bởi vì

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Để khắc phục điều này, bạn cần đảm bảo hàm bao bọc trả về giá trị trả về của hàm trang trí. Thay đổi tệp

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Giá trị trả về từ lần thực thi cuối cùng của hàm được trả về

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Bạn là ai, thực sự?

Một tiện lợi lớn khi làm việc với Python, đặc biệt là trong shell tương tác, là khả năng xem xét nội tâm mạnh mẽ của nó. Nội quan là khả năng của một đối tượng biết về các thuộc tính của chính nó trong thời gian chạy. Chẳng hạn, một hàm biết tên và tài liệu của chính nó

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Việc xem xét nội tâm cũng hoạt động đối với các chức năng mà bạn tự xác định

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Tuy nhiên, sau khi được trang trí,

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Để khắc phục điều này, các nhà trang trí nên sử dụng trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Bạn không cần thay đổi bất cứ điều gì về chức năng

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Tốt hơn nhiều. Bây giờ

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Chi tiết kỹ thuật. Trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

chức năng thời gian

Hãy bắt đầu bằng cách tạo một trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Trình trang trí này hoạt động bằng cách lưu trữ thời gian ngay trước khi chức năng bắt đầu chạy [tại dòng được đánh dấu

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Chạy nó cho mình. Làm việc thông qua từng dòng mã. Hãy chắc chắn rằng bạn hiểu nó hoạt động như thế nào. Tuy nhiên, đừng lo lắng nếu bạn không hiểu. Trang trí là những sinh vật tiên tiến. Cố gắng ngủ trên đó hoặc tạo một bản vẽ của chương trình

Ghi chú. Trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Mã gỡ lỗi

Trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Chữ ký được tạo bằng cách nối các biểu diễn chuỗi của tất cả các đối số. Các số trong danh sách sau tương ứng với các nhận xét được đánh số trong mã

1. Tạo một danh sách các đối số vị trí. Sử dụng

   def say_hello[name]:
       return f"Hello {name}"
   
   def be_awesome[name]:
       return f"Yo {name}, together we are the awesomest!"
   
   def greet_bob[greeter_func]:
       return greeter_func["Bob"]
   

   85 để có được một chuỗi đẹp đại diện cho mỗi đối số
2. Tạo một danh sách các đối số từ khóa. Chuỗi f định dạng mỗi đối số là

   def say_hello[name]:
       return f"Hello {name}"
   
   def be_awesome[name]:
       return f"Yo {name}, together we are the awesomest!"
   
   def greet_bob[greeter_func]:
       return greeter_func["Bob"]
   

   86 trong đó mã xác định

   def say_hello[name]:
       return f"Hello {name}"
   
   def be_awesome[name]:
       return f"Yo {name}, together we are the awesomest!"
   
   def greet_bob[greeter_func]:
       return greeter_func["Bob"]
   

   87 có nghĩa là

   def say_hello[name]:
       return f"Hello {name}"
   
   def be_awesome[name]:
       return f"Yo {name}, together we are the awesomest!"
   
   def greet_bob[greeter_func]:
       return greeter_func["Bob"]
   

   85 được sử dụng để biểu thị giá trị
3. Danh sách các đối số vị trí và từ khóa được nối với nhau thành một chuỗi chữ ký với mỗi đối số được phân tách bằng dấu phẩy
4. Giá trị trả về được in sau khi hàm được thực thi

Hãy xem cách trình trang trí hoạt động trong thực tế bằng cách áp dụng nó cho một hàm đơn giản với một vị trí và một đối số từ khóa

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Lưu ý cách trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Ví dụ này có vẻ không hữu ích ngay lập tức vì trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Ví dụ sau đây tính toán một giá trị gần đúng với hằng số toán học e

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Ví dụ này cũng cho thấy cách bạn có thể áp dụng một trình trang trí cho một chức năng đã được xác định. Phép tính gần đúng của e dựa trên khai triển chuỗi sau

Khi gọi hàm

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Trong ví dụ này, bạn nhận được một giá trị gần đúng với giá trị thực e = 2. 718281828, chỉ thêm 5 số hạng

Làm chậm mã

Ví dụ tiếp theo này có vẻ không hữu ích lắm. Tại sao bạn muốn làm chậm mã Python của mình? . Trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Để xem tác dụng của trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Ghi chú. Hàm

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Đăng ký plugin

Người trang trí không cần phải bao bọc chức năng mà họ đang trang trí. Họ cũng có thể chỉ cần đăng ký rằng một chức năng tồn tại và trả lại nó khi chưa mở gói. Điều này có thể được sử dụng, ví dụ, để tạo ra một kiến ​​trúc plug-in trọng lượng nhẹ

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Hàm

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Lợi ích chính của kiến ​​trúc plugin đơn giản này là bạn không cần duy trì danh sách các plugin tồn tại. Danh sách đó được tạo khi các plugin tự đăng ký. Điều này làm cho việc thêm một plugin mới trở nên tầm thường. chỉ cần xác định chức năng và trang trí nó bằng

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

Nếu bạn đã quen thuộc với

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Sử dụng trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Người dùng đã đăng nhập chưa?

Ví dụ cuối cùng trước khi chuyển sang một số trình trang trí đẹp hơn thường được sử dụng khi làm việc với khung web. Trong ví dụ này, chúng tôi đang sử dụng Flask để thiết lập trang web

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Mặc dù điều này đưa ra ý tưởng về cách thêm xác thực vào khung web của bạn, nhưng thông thường bạn không nên tự mình viết các loại trình trang trí này. Đối với Flask, bạn có thể sử dụng tiện ích mở rộng Flask-Login để bổ sung thêm tính năng và bảo mật

trang trí lớp học

Có hai cách khác nhau để bạn có thể sử dụng các công cụ trang trí trên các lớp. Cái đầu tiên rất gần với những gì bạn đã làm với các hàm. bạn có thể trang trí các phương thức của một lớp. Đây là một trong những động lực để giới thiệu những người trang trí trở lại trong ngày

Một số trình trang trí thường được sử dụng thậm chí được tích hợp sẵn trong Python là

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Ví dụ sử dụng trình trang trí lớp tích hợp sẵnHiển thị/Ẩn

Định nghĩa sau đây của một lớp

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Trong lớp học này

• >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  019 là một phương pháp thông thường

• >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  020 là một thuộc tính có thể thay đổi. nó có thể được đặt thành một giá trị khác. Tuy nhiên, bằng cách xác định một phương thức setter, chúng ta có thể thực hiện một số kiểm tra lỗi để đảm bảo rằng nó không được đặt thành một số âm vô nghĩa. Thuộc tính được truy cập dưới dạng thuộc tính không có dấu ngoặc đơn

• >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  021 là một tài sản bất biến. không thể thay đổi các thuộc tính không có phương thức

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  022. Mặc dù nó được định nghĩa là một phương thức, nhưng nó có thể được truy xuất dưới dạng một thuộc tính mà không cần dấu ngoặc đơn

• >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  023 là một phương thức lớp. Nó không bị ràng buộc với một trường hợp cụ thể của

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  015. Các phương thức lớp thường được sử dụng làm phương thức xuất xưởng có thể tạo các thể hiện cụ thể của lớp

• >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  025 là một phương thức tĩnh. Nó không thực sự phụ thuộc vào lớp

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  015, ngoại trừ việc nó là một phần của không gian tên của nó. Các phương thức tĩnh có thể được gọi trên một thể hiện hoặc lớp

Ví dụ, lớp

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Hãy định nghĩa một lớp nơi chúng ta trang trí một số phương thức của nó bằng cách sử dụng các bộ trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Sử dụng lớp này, bạn có thể thấy tác dụng của các trang trí

>>>

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Một cách khác để sử dụng các công cụ trang trí trong lớp học là trang trí cho cả lớp. Ví dụ, điều này được thực hiện trong mô-đun

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Ý nghĩa của cú pháp tương tự như các bộ trang trí chức năng. Trong ví dụ trên, bạn có thể đã trang trí bằng cách viết

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Một cách sử dụng phổ biến của các công cụ trang trí lớp là một giải pháp thay thế đơn giản hơn cho một số trường hợp sử dụng siêu dữ liệu. Trong cả hai trường hợp, bạn đang thay đổi định nghĩa của một lớp một cách linh hoạt

Viết một trình trang trí lớp rất giống với viết một trình trang trí chức năng. Sự khác biệt duy nhất là trình trang trí sẽ nhận một lớp chứ không phải một hàm làm đối số. Trên thực tế, tất cả các trình trang trí bạn thấy ở trên sẽ hoạt động như các trình trang trí lớp. Khi bạn đang sử dụng chúng trên một lớp thay vì một chức năng, tác dụng của chúng có thể không như bạn muốn. Trong ví dụ sau, trình trang trí

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Trang trí một lớp học không trang trí các phương thức của nó. Nhớ lại rằng

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Ở đây,

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Sau đó, bạn sẽ thấy một ví dụ định nghĩa một trình trang trí lớp phù hợp, cụ thể là

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Đồ trang trí làm tổ

Bạn có thể áp dụng một số trình trang trí cho một chức năng bằng cách xếp chồng chúng lên nhau

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Hãy nghĩ về điều này khi các trình trang trí được thực hiện theo thứ tự chúng được liệt kê. Nói cách khác,

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>>

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Quan sát sự khác biệt nếu chúng ta thay đổi thứ tự của

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Trong trường hợp này,

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>>

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Trang trí với các đối số

Đôi khi, thật hữu ích khi chuyển đối số cho người trang trí của bạn. Chẳng hạn,

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Điều này sẽ cho phép bạn làm một cái gì đó như thế này

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

>>>

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Hãy suy nghĩ về cách bạn có thể đạt được điều này

Cho đến nay, tên được viết sau

def say_hello[name]:
    return f"Hello {name}"

def be_awesome[name]:
    return f"Yo {name}, together we are the awesomest!"

def greet_bob[greeter_func]:
    return greeter_func["Bob"]

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Thông thường, trình trang trí tạo và trả về một hàm bao bọc bên trong, do đó, viết đầy đủ ví dụ ra sẽ cung cấp cho bạn một hàm bên trong bên trong một hàm bên trong. Mặc dù điều này nghe có vẻ giống như chương trình tương đương với bộ phim Inception, nhưng chúng tôi sẽ gỡ rối tất cả trong giây lát

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Có vẻ hơi lộn xộn, nhưng hiện tại chúng tôi chỉ đặt cùng một mẫu trang trí mà bạn đã thấy nhiều lần bên trong một

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Hàm

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Một bước ra ngoài, bạn sẽ tìm thấy chức năng trang trí

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Một lần nữa,

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Như bạn đã thấy, hàm ngoài cùng trả về một tham chiếu đến hàm trang trí

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Có một vài điều tế nhị xảy ra trong hàm

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

• Xác định

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  054 là một hàm bên trong có nghĩa là

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  055 sẽ tham chiếu đến một đối tượng hàm—

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  059. Trước đó, chúng tôi đã sử dụng

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  060 không có dấu ngoặc đơn để chỉ đối tượng chức năng. Các dấu ngoặc đơn được thêm vào là cần thiết khi xác định các trình trang trí lấy đối số
• Đối số

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  052 dường như không được sử dụng trong chính

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  055. Nhưng bằng cách chuyển

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  052, một bao đóng được tạo trong đó giá trị của

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  052 được lưu trữ cho đến khi nó được sử dụng sau bởi

  >>> def add_one[number]:
  ..     return number + 1
  
  >>> add_one[2]
  3
  

  050

Với mọi thứ đã được thiết lập, hãy xem kết quả có như mong đợi không

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

>>>

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Chỉ là kết quả mà chúng tôi đang hướng tới

Làm ơn cho cả hai, nhưng đừng bận tâm đến bánh mì

Với một chút cẩn thận, bạn cũng có thể xác định các trình trang trí có thể được sử dụng cả khi có và không có đối số. Rất có thể, bạn không cần điều này, nhưng thật tuyệt khi có sự linh hoạt

Như bạn đã thấy trong phần trước, khi một trình trang trí sử dụng các đối số, bạn cần thêm một hàm bên ngoài bổ sung. Thử thách dành cho mã của bạn là tìm hiểu xem trình trang trí đã được gọi có hay không có đối số

Vì hàm để trang trí chỉ được truyền trực tiếp nếu trình trang trí được gọi mà không có đối số, nên hàm phải là một đối số tùy chọn. Điều này có nghĩa là tất cả các đối số trang trí phải được chỉ định bởi từ khóa. Bạn có thể thực thi điều này bằng cú pháp

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Ở đây, đối số

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

1. Nếu

   >>> def add_one[number]:
   ..     return number + 1
   
   >>> add_one[2]
   3
   

   068 đã được gọi mà không có đối số, chức năng được trang trí sẽ được chuyển vào dưới dạng

   >>> def add_one[number]:
   ..     return number + 1
   
   >>> add_one[2]
   3
   

   067. Nếu nó đã được gọi với các đối số, thì

   >>> def add_one[number]:
   ..     return number + 1
   
   >>> add_one[2]
   3
   

   067 sẽ là

   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
   
   def say_whee[]:
       print["Whee!"]
   
   say_whee = my_decorator[say_whee]
   

   9 và một số đối số từ khóa có thể đã bị thay đổi so với giá trị mặc định của chúng.

   >>> def add_one[number]:
   ..     return number + 1
   
   >>> add_one[2]
   3
   

   066 trong danh sách đối số có nghĩa là các đối số còn lại không thể được gọi là đối số vị trí
2. Trong trường hợp này, trình trang trí được gọi với các đối số. Trả về hàm trang trí có thể đọc và trả về hàm
3. Trong trường hợp này, trình trang trí được gọi mà không có đối số. Áp dụng trình trang trí cho chức năng ngay lập tức

Sử dụng bản tóm tắt này trên trình trang trí

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

So sánh điều này với bản gốc

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Công thức 9. 6 của Sách dạy nấu ăn Python xuất sắc cho thấy một giải pháp thay thế bằng cách sử dụng

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

Những ví dụ này cho thấy rằng

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

Nhớ lại rằng giá trị mặc định của

>>> def add_one[number]:
..     return number + 1

>>> add_one[2]
3

>>>

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]

trang trí nhà nước

Đôi khi, thật hữu ích khi có một trình trang trí có thể theo dõi trạng thái. Ví dụ đơn giản, chúng ta sẽ tạo một decorator đếm số lần một hàm được gọi

Ghi chú. Ở phần đầu của hướng dẫn này, chúng ta đã nói về các hàm thuần túy trả về một giá trị dựa trên các đối số đã cho. Trình trang trí trạng thái hoàn toàn ngược lại, trong đó giá trị trả về sẽ phụ thuộc vào trạng thái hiện tại, cũng như các đối số đã cho

Trong phần tiếp theo, bạn sẽ thấy cách sử dụng các lớp để giữ trạng thái. Nhưng trong những trường hợp đơn giản, bạn cũng có thể sử dụng thuộc tính hàm

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

def say_whee[]:
    print["Whee!"]

say_whee = my_decorator[say_whee]