Tìm hiểu Python decorators

>>> def greet(word="Hello"):
...     print(word)
...
>>> greet()
Hello
>>> greet("Hello, world")
Hello, world
>>>

def shout(word="aaa"):
    return word.upper() + "!"

print(shout()) # output: AAA!

# Bởi vì hàm cũng là đối tượng nên chúng ta có thể gán nó cho các
# biến như những đối tượng khác.
scream = shout

# Như bạn đã thấy rằng, chúng ta không dùng dấu ngoặc, bởi vì
# chúng ta không gọi hàm, mà chúng ta đang gán hàm cho biến khác
# (scream).  Sau khi gán, chúng ta có thể gọi hàm shout từ biến
# scream.
print(scream()) # output: AAA!

# Không chỉ gán biến, chúng ta còn có thể xoá hàm như xoá những
# đối tượng thông thường khác.
del shout
try:
    print(shout())
except NameError as e:
    print(e)
# output: name 'shout' is not defined

# Tuy nhiên, chúng ta vẫn có thể gọi hàm thông qua biến scream.
print(scream()) # output: AAA!

def talk():

    # Bạn có thể định nghĩa các hàm bên trong hàm `talk`
    def whisper(word="aaa"):
        return word.lower() + "..."

    # Và sau đó sử dụng hàm này
    print(whisper())

# Bạn có thể gọi hàm talk, mỗi lần bạn gọi hàm này, hàm whisper
# sẽ được định nghĩa sau đó thực thi ở bên trong hàm talk.
talk() # output: aaa...

# Nhưng bạn không thể gọi hàm whisper từ bên ngoài.
try:
    print(whisper())
except NameError as e:
    print(e)
# output: name 'whisper' is not defined

def get_talk(kind="shout"):

    # Trước hết, chúng ta định nghĩa các hàm
    def shout(word="aaa"):
        return word.upper() + "!"

    def whisper(word="aaa"):
        return word.lower() + "..."

    # Bây giờ, chúng ta sẽ trả kết quả về những hàm này
    if kind == "shout":
        # Chúng ta không sử dụng dấu ngoặc (), bởi vì chúng ta
        # không gọi những hàm này, mà chúng ta return đối tượng
        # tương ứng với các hàm.
        return shout
    else:
        return whisper

# Gọi những thứ trên như thế nào?

# Chúng ta gọi hàm và gán kết quả cho một biến
talk = get_talk()

# Bạn có thể thấy talk bây giờ là một đối tượng hàm
print(talk) # output: <function get_talk.<locals>.shout at 0x101bdbae8>

# Đối tượng hàm này là một trong hai hàm con của get_talk
print(talk()) # output: AAA!

# Bạn có thể dùng cách gọi ngắn gọn hơn nếu đã thành thạo
print(get_talk("whisper")()) # output: aaa...

def do_smth_before(func):
    print("Something before calling function")
    print(func())

print(scream)
# output:
# Something before calling function
# AAA!

# Decorator là hàm nhận hàm khác làm tham số
def decorator_function(function_to_decorate):

    # Bên trong, chúng ta sẽ định nghĩa một "wrapper".  Hàm này sẽ
    # bao bọc xung quanh hàm gốc, vì thế chúng ta có thể chạy
    # code trước hoặc sau hàm gốc đó
    def wrapper_to_original_function():
        # Đây là code được thực thi TRƯỚC hàm gốc
        print("Before calling function")

        # Gọi hàm gốc, đây là gọi và thực thi hàm nên chúng ta sẽ
        # dùng dấu ngoặc
        function_to_decorate()

        # Đây là code được thực thi SAU hàm gốc
        print("After calling function")

    # Vào thời điểm này, hàm gốc vẫn CHƯA thực sự được thực thi,
    # chúng ta sẽ return hàm wrapper mà chúng ta vừa tạo.  Hàm này
    # chứa code được thực thi trước và sau hàm gốc, đặc biệt là
    # nó có thể được thực thi.
    return wrapper_to_original_function

# Giả sử bạn có một hàm mà không muốn ai thay đổi nó
def a_function():
    print("Do not modify it")

a_function() # output: Do not modify it

# Bây giờ, bạn muốn mở rộng hành vi của hàm này, chạy một số code
# trước và sau nó, hãy sử dụng decorator_function.  Truyền hàm này
# như là tham số của hàm decorator, nó sẽ tự động bao bọc hàm, và
# trả kết quả về là một hàm khác bạn có thể thực thi
a_decorated_function = decorator_function(a_function)

# Có thể bạn sẽ muốn chạy hàm a_decorated_function mỗi khi thực
# thi hàm a_function.  Rất đơn giản, bạn chỉ cần override nó bằng
# hàm trả về của decorator_function
a_function = decorator_function(a_function)

a_function()
# output:
# Before calling function
# Do not modify it
# After calling function

# Đây chính là những gì mà decorator có thể làm

@decorator_function
def a_function():
    print("Do not modify it")

a_function()
# output:
# Before calling function
# Do not modify it
# After calling function

a_function = decorator_function(a_function)

def decorator1(func):
    def wrapper():
        print("*" * 10)
        func()
        print("*" * 10)
    return wrapper

def decorator2(func):
    def wrapper():
        print("=" * 10)
        func()
        print("=" * 10)
    return wrapper

def some_func():
    print("hello")

some_func() # output: hello
some_func = decorator1(decorator2(some_func))
some_func()
# output:
# **********
# ==========
# hello
# ==========
# **********

@decorator1
@decorator2
def some_func():
    print("hello")

some_func()
# output giống như lúc trước
# **********
# ==========
# hello
# ==========
# **********

# Thứ tự của decorator cũng CÓ ảnh hưởng đến kết quả
@decorator2
@decorator1
def some_func():
    print("hello")
some_func()
# output lần này đã khác
# ==========
# **********
# hello
# **********
# ==========

# Không có bí mật gì ở đây.  Chúng ta chỉ cần cho hàm wrapper nhận
# tham số là được

def a_decorator_passing_arguments(function_to_decorate):
    def a_wrapper_accepting_arguments(arg1, arg2):
        print("I got args!", arg1, arg2)
        function_to_decorate(arg1, arg2)
    return a_wrapper_accepting_arguments

# Bởi vì khi chúng ta gọi hàm, thực ra là chúng ta gọi hàm được
# trả về bởi decorator (hàm wrapper), nên nếu chúng ta truyền
# tham số cho hàm này thì nó sẽ truyền cho hàm được decorate.

@a_decorator_passing_arguments
def print_full_name(first_name, last_name):
    print("My name is", first_name, last_name)

print_full_name("naa", "manhhomienbienthuy")
# outputs:
# I got args! naa manhhomienbienthuy
# My name is naa manhhomienbienthuy

def method_friendly_decorator(method_to_decorate):
    def wrapper(self, lie):
        lie = lie - 3 # very friendly, decrease age even more :-)
        return method_to_decorate(self, lie)
    return wrapper


class Wife(object):

    def __init__(self):
        self.age = 24

    @method_friendly_decorator
    def say_your_age(self, lie):
        print("I am %s, what did you think?" % (self.age + lie))

vp = Wife()
vp.say_your_age(-3)
# outputs: I am 18, what did you think?

def decorator_passing_arbitrary_arguments(function_to_decorate):
    # Wrapper nhận mọi tham số đầu vào
    def wrapper_accepting_arbitrary_arguments(*args, **kwargs):
        print("Do I have args?:")
        print(args)
        print(kwargs)
        # Bây giờ truyền những tham số này cho hàm được decorate,
        # nhớ unpack chúng.
        function_to_decorate(*args, **kwargs)
    return wrapper_accepting_arbitrary_arguments


@decorator_passing_arbitrary_arguments
def function_with_no_argument():
    print("No arguments here")

function_with_no_argument()
# output:
# Do I have args?:
# ()
# {}
# No arguments here

@decorator_passing_arbitrary_arguments
def function_with_arguments(a, b, c):
    print(a, b, c)

function_with_arguments(1, 2, 3)
# output:
# Do I have args?:
# (1, 2, 3)
# {}
# 1 2 3

@decorator_passing_arbitrary_arguments
def function_with_named_arguments(name, occupation="programmer"):
    print("%s is a %s" % (name, occupation))

function_with_named_arguments("Ngoc Anh", occupation="developer")
# output:
# Do I have args?:
# ('Ngoc Anh',)
# {'occupation': 'developer'}
# Ngoc Anh is a developer

class Husband(object):

    def __init__(self):
        self.age = 25

    @decorator_passing_arbitrary_arguments
    def say_your_age(self, lie=-3):
        print("I am %s, what did you think ?" % (self.age + lie))

na = Husband()
na.say_your_age()
# output:
# Do I have args?:
# (<__main__.Husband object at 0x7f1244b65278>,)
# {}
# I am 22, what did you think ?

# Decorator cũng là hàm THÔNG THƯỜNG
def my_decorator(func):
    print("This is an ordinary function")

    def wrapper():
        print("This is function return by decorator")
        func()
    return wrapper

# Do đó, bạn có thể gọi chúng là không cần dùng cú pháp `@`
def lazy_function():
    print("lllllaaaaazzzzzyyyyy")

decorated_function = my_decorator(lazy_function)
# outputs: This is an ordinary function

# Output của đoạn code trên là "This is an ordinary function" bởi
# vì đơn giản là bạn vừa gọi hàm nên nó có kết quả như vậy.  Không
# có gì khó hiểu ở đây cả.

@my_decorator
def lazy_function():
    print("lllllaaaaazzzzzyyyyy")

# outputs: This is an ordinary function

def decorator_maker():

    print("Make decorator and execute only once")

    def my_decorator(func):
        print("I am a decorator!")

        def wrapped():
            print ("I am the wrapper around the decorated function.")
            func()

        print("As the decorator, I return the wrapped function.")

        return wrapped

    print("As a decorator maker, I return a decorator")
    return my_decorator

# Bây giờ, chúng ta sẽ tạo ra một decorator, đơn giản chỉ là gọi
# các hàm
new_decorator = decorator_maker()
# output:
# Make decorator and execute only once
# As a decorator maker, I return a decorator

# Sau đó là decorate hàm mà chúng ta muốn
def decorated_function():
    print("I am the decorated function.")

decorated_function = new_decorator(decorated_function)
# output:
# I am a decorator!
# As the decorator, I return the wrapped function.

# Thử gọi hàm được decorate xem sao
decorated_function()
# output:
# I am the wrapper around the decorated function.
# I am the decorated function.

def decorated_function():
    print("I am the decorated function.")
decorated_function = decorator_maker()(decorated_function)
# output:
# Make decorator and execute only once
# As a decorator maker, I return a decorator
# I am a decorator!
# As the decorator, I return the wrapped function.

# Gọi hàm được decorate
decorated_function()
# output:
# I am the wrapper around the decorated function.
# I am the decorated function.

@decorator_maker()
def decorated_function():
    print("I am the decorated function.")
# output:
# Make decorator and execute only once
# As a decorator maker, I return a decorator
# I am a decorator!
# As the decorator, I return the wrapped function

# Thử gọi hàm xem sao
decorated_function()
# output:
# I am the wrapper around the decorated function.
# I am the decorated function.

def decorator_maker_with_arguments(decorator_arg1, decorator_arg2):

    print("I make decorators! And I accept arguments:",
          decorator_arg1, decorator_arg2)

    def my_decorator(func):
        print("I am the decorator.  You passed me arguments:",
              decorator_arg1, decorator_arg2)

        # Don't confuse decorator arguments and function arguments!
        def wrapped(function_arg1, function_arg2):
            print("I am the wrapper around the decorated function.\n"
                  "I can access all the variables\n"
                  "\t- from the decorator: {0} {1}\n"
                  "\t- from the function call: {2} {3}\n"
                  "Then I can pass them to the decorated function"
                  .format(decorator_arg1, decorator_arg2,
                          function_arg1, function_arg2))
            return func(function_arg1, function_arg2)

        return wrapped

    return my_decorator


@decorator_maker_with_arguments("foo", "bar")
def decorated_function_with_arguments(function_arg1, function_arg2):
    print("I am the decorated function with arguments",
          function_arg1, function_arg2)

decorated_function_with_arguments("wife", "husband")
# output:
# I make decorators! And I accept arguments: foo bar
# I am the decorator.  You passed me arguments: foo bar
# I am the wrapper around the decorated function.
# I can access all the variables
#   - from the decorator: foo bar
#   - from the function call: wife husband
# Then I can pass them to the decorated function
# I am the decorated function with arguments wife husband

var1 = "foo"
var2 = "bar"

@decorator_maker_with_arguments(var1, var2)
def decorated_function_with_arguments(function_arg1, function_arg2):
    print ("I am the decorated function with arguments:"
           function_arg1, function_arg2)

var3 = "wife"
var4 = "husband"
decorated_function_with_arguments(var3, var4)
# output:
# I make decorators! And I accept arguments: foo bar
# I am the decorator.  You passed me arguments: foo bar
# I am the wrapper around the decorated function.
# I can access all the variables
#   - from the decorator: foo bar
#   - from the function call: wife husband
# Then I can pass them to the decorated function
# I am the decorated function with arguments wife husband

def decorator_with_args(decorator_to_enhance):
    """
    Hàm này sẽ được dùng làm decorator.  Nó sẽ decorate một hàm mà
    hàm đó cũng sẽ trở thành decorator.  Decorator này cho phép
    bạn xây dựng decorator có thể nhận bất kỳ tham số nào, mà
    không cần nhớ cách thực hiện chúng.
    """

    # We use the same trick we did to pass arguments
    def decorator_maker(*args, **kwargs):

        # Chúng ta tạo ra một decorator nhận đầu vào là một hàm,
        # nhưng có thể truyền tham số từ maker.
        def decorator_wrapper(func):

            # Chúng ta return kết quả của decorator gốc, thực ra
            # nó cũng là hàm THÔNG THƯỜNG (nhưng return một hàm
            # khác).  Lưu ý rằng, decorator phải sử dụng đúng
            # nguyên mẫu mới có thể chạy được.
            return decorator_to_enhance(func, *args, **kwargs)

        return decorator_wrapper

    return decorator_maker

# Chúng ta sẽ tạo ra một hàm dùng làm decorator.  Và dùng
# decorator đã tạo ra ở trên cho hàm này.  Nguyên mẫu hàm phải là
# decorator(func, *args, **kwargs) thì mới hoạt động được.
@decorator_with_args
def decorated_decorator(func, *args, **kwargs):
    def wrapper(function_arg1, function_arg2):
        print("Decorated with", args, kwargs)
        return func(function_arg1, function_arg2)
    return wrapper

# Sau đó chúng ta có thể dùng decorator này với các hàm chúng a
# muốn và có thể truyền tham số tùy ý.

@decorated_decorator(42, 404, 1024)
def decorated_function(function_arg1, function_arg2):
    print("Hello", function_arg1, function_arg2)

decorated_function("Universe and", "everything")
# output:
# Decorated with (42, 404, 1024) {}
# Hello Universe and everything

# Để debug, chúng a in ra tên của hàm
def foo():
    print("foo")

print(foo.__name__) # output: foo

# Nếu dùng decorator, mọi thứ khác đi nhiều.
def bar(func):
    def wrapper():
        print("bar")
        return func()
    return wrapper

@bar
def foo():
    print("foo")

print(foo.__name__) # output: wrapper

# "functools" có thể giúp chúng ta

import functools

def bar(func):
    # Đây là wrapper bao bọc hàm được decorator.  Tuy nhiên, sự kỳ
    # diệu ở đây là nhờ functools.
    @functools.wraps(func)
    def wrapper():
        print("bar")
        return func()
    return wrapper

@bar
def foo():
    print("foo")

print(foo.__name__) # output: foo

def benchmark(func):
    """
    Decorator in ra thời gian thực thi hàm
    """
    import time

    def wrapper(*args, **kwargs):
        t = time.clock()
        res = func(*args, **kwargs)
        print(func.__name__, time.clock() - t)
        return res
    return wrapper


def logging(func):
    """
    Decorator ghi log về hoạt động của code. Ở đây chỉ đơn giản
    là in ra tên hàm nào đang được gọi.
    """
    def wrapper(*args, **kwargs):
        res = func(*args, **kwargs)
        print(func.__name__, args, kwargs)
        return res
    return wrapper


def counter(func):
    """
    Decorator đếm và in ra số lần hàm được gọi trong chương
    trình.
    """
    def wrapper(*args, **kwargs):
        wrapper.count = wrapper.count + 1
        res = func(*args, **kwargs)
        print("{0} has been used: {1}x".format(
            func.__name__, wrapper.count))
        return res
    wrapper.count = 0
    return wrapper


@counter
@benchmark
@logging
def reverse_string(string):
    return string[::-1]

print(reverse_string("Able was I ere I saw Elba"))
print(reverse_string("Lorem ipsum dolor sit amet, et cetero complectitur "
                     "mel, sea mundi delectus gubergren et.  In pro postea "
                     "ullamcorper, per dissentias vituperatoribus et.  Sed "
                     "saepe quaeque voluptaria et, et quod dolores "
                     "voluptaria vel.  An cum causae mediocritatem "
                     "vituperatoribus.  Est an nobis adversarium.  Probo "
                     "scripta omnesque ne sed, delicata volutpat no per."))

# output:
# reverse_string ('Able was I ere I saw Elba',) {}
# wrapper 2.6999999999999247e-05
# wrapper has been used: 1x
# ablE was I ere I saw elbA
# reverse_string ('Lorem ipsum dolor sit amet, et cetero complectitur mel, sea mundi delectus gubergren et.  In pro postea ullamcorper, per dissentias vituperatoribus et.  Sed saepe quaeque voluptaria et, et quod dolores voluptaria vel.  An cum causae mediocritatem vituperatoribus.  Est an nobis adversarium.  Probo scripta omnesque ne sed, delicata volutpat no per.',) {}
# wrapper 1.2999999999999123e-05
# wrapper has been used: 2x
# .rep on taptulov ataciled ,des en euqsenmo atpircs oborP .muirasrevda sibon na tsE .subirotareputiv metatircoidem easuac muc nA .lev airatpulov serolod douq te ,te airatpulov euqeauq epeas deS .te subirotareputiv saitnessid rep ,reprocmallu aetsop orp nI .te nergrebug sutceled idnum aes ,lem rutitcelpmoc oretec te ,tema tis rolod muspi meroL

@counter
@benchmark
@logging
def get_an_excuse():
    import urllib.request
    import re
    handle = urllib.request.urlopen("http://programmingexcuses.com/")
    response = handle.read().decode()
    return re.search("\n.+>([,'.?!\w\s]+)</a>", response).group(1)

print(get_an_excuse())
print(get_an_excuse())
# output:
# get_an_excuse () {}
# wrapper 0.07300399999999999
# wrapper has been used: 1x
# Our internet connection must not be working
# get_an_excuse () {}
# wrapper 0.0027760000000000007
# wrapper has been used: 2x
# That process requires human oversight that nobody was providing

def decorator_keep_original_function(function_to_decorate):

    def wrapper(*args, **kwargs):
        print("This is decorated function")
        function_to_decorate(*args, **kwargs)

    # Chúng ta sẽ lưu hàm gốc chưa được decorate như là một
    # thuộc tính của hàm mới.
    wrapper._original_function = function_to_decorate
    return wrapper


@decorator_keep_original_function
def some_function():
    print("This is original function")

# Gọi hàm đã được decorate
some_function()
# output:
# This is decorated function
# This is original function

# Chúng ta vẫn có thể gọi hàm gốc chứa decorate
some_function._original_function()
# output:
# This is original function

def undecorator(decorated_function):
    # Python < 2.6 sử dụng `func_closure` thay thế cho
    # `__closure__`
    return decorated_function.__closure__[0].cell_contents


def decorator_to_undo(function_to_decorate):

    def wrapper(*args, **kwargs):
        print("This is decorated function")
        function_to_decorate(*args, **kwargs)

    return wrapper


@decorator_to_undo
def some_function():
    print("This is original function")

# Hàm đã được decorate
some_function()
# output:
# This is decorated function
# This is original function

# Thử undecorate xem sao
undecorator(some_function)()
# output:
# This is original function
# => Đây chính là điều chúng ta mong đợi.