関数デコレータの連鎖を作るには？

Question

Pythonで2つのデコレータを作成するにはどうすればよいですか。

@makebold
@makeitalic
def say():
   return "Hello"

返されるはずの...

"<b><i>Hello</i></b>"

実際のアプリケーションでこのようにHTMLを作成しようとはしていません - 単にデコレータとデコレータチェーンがどのように機能するかを理解しようとしています。

Answer 1

ドキュメンテーション をチェックして、デコレータがどのように動作するかを見てください。これがあなたが求めたものです：

from functools import wraps

def makebold(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<b>" + fn(*args, **kwargs) + "</b>"
    return wrapped

def makeitalic(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<i>" + fn(*args, **kwargs) + "</i>"
    return wrapped

@makebold
@makeitalic
def hello():
    return "hello world"

@makebold
@makeitalic
def log(s):
    return s

print hello()        # returns "<b><i>hello world</i></b>"
print hello.__# with functools.wraps() this returns "hello"
print log('hello')   # returns "<b><i>hello</i></b>"

Answer 2

長い説明に興味がない場合は、 Paolo Bergantinoの答え を参照してください。

デコレータの基本

Pythonの関数はオブジェクトです

デコレータを理解するには、まず関数がPythonのオブジェクトであることを理解する必要があります。これは重要な結果をもたらします。簡単な例でその理由を見てみましょう：

def shout(Word="yes"):
    return Word.capitalize()+"!"

print(shout())
# outputs : 'Yes!'

# As an object, you can assign the function to a variable like any other object 
scream = shout

# Notice we don't use parentheses: we are not calling the function,
# we are putting the function "shout" into the variable "scream".
# It means you can then call "shout" from "scream":

print(scream())
# outputs : 'Yes!'

# More than that, it means you can remove the old name 'shout',
# and the function will still be accessible from 'scream'

del shout
try:
    print(shout())
except NameError as e:
    print(e)
    #outputs: "name 'shout' is not defined"

print(scream())
# outputs: 'Yes!'

これを覚えておいてください。すぐに戻ります。

Python関数のもう1つの興味深い特性は、別の関数内で定義できることです！

def talk():

    # You can define a function on the fly in "talk" ...
    def whisper(Word="yes"):
        return Word.lower()+"..."

    # ... and use it right away!
    print(whisper())

# You call "talk", that defines "whisper" EVERY TIME you call it, then
# "whisper" is called in "talk". 
talk()
# outputs: 
# "yes..."

# But "whisper" DOES NOT EXIST outside "talk":

try:
    print(whisper())
except NameError as e:
    print(e)
    #outputs : "name 'whisper' is not defined"*
    #Python's functions are objects

関数リファレンス

さて、まだここに？今から楽しい部分...

関数はオブジェクトであることがわかりました。したがって、機能：

• 変数に割り当てることができます
• 別の関数で定義できます

つまり、 a関数はreturn別の関数を実行できます。

def getTalk(kind="shout"):

    # We define functions on the fly
    def shout(Word="yes"):
        return Word.capitalize()+"!"

    def whisper(Word="yes") :
        return Word.lower()+"...";

    # Then we return one of them
    if kind == "shout":
        # We don't use "()", we are not calling the function,
        # we are returning the function object
        return shout  
    else:
        return whisper

# How do you use this strange beast?

# Get the function and assign it to a variable
talk = getTalk()      

# You can see that "talk" is here a function object:
print(talk)
#outputs : <function shout at 0xb7ea817c>

# The object is the one returned by the function:
print(talk())
#outputs : Yes!

# And you can even use it directly if you feel wild:
print(getTalk("whisper")())
#outputs : yes...

さらにあります！

関数をreturnできる場合は、パラメーターとして渡すことができます。

def doSomethingBefore(func): 
    print("I do something before then I call the function you gave me")
    print(func())

doSomethingBefore(scream)
#outputs: 
#I do something before then I call the function you gave me
#Yes!

さて、デコレータを理解するために必要なものはすべて揃っています。デコレータは「ラッパー」です。つまり、を使用すると、関数自体を変更せずに、修飾する関数の前後にコードを実行できます。

手作りのデコレータ

手動で行う方法：

# A decorator is a function that expects ANOTHER function as parameter
def my_shiny_new_decorator(a_function_to_decorate):

    # Inside, the decorator defines a function on the fly: the wrapper.
    # This function is going to be wrapped around the original function
    # so it can execute code before and after it.
    def the_wrapper_around_the_original_function():

        # Put here the code you want to be executed BEFORE the original function is called
        print("Before the function runs")

        # Call the function here (using parentheses)
        a_function_to_decorate()

        # Put here the code you want to be executed AFTER the original function is called
        print("After the function runs")

    # At this point, "a_function_to_decorate" HAS NEVER BEEN EXECUTED.
    # We return the wrapper function we have just created.
    # The wrapper contains the function and the code to execute before and after. It’s ready to use!
    return the_wrapper_around_the_original_function

# Now imagine you create a function you don't want to ever touch again.
def a_stand_alone_function():
    print("I am a stand alone function, don't you dare modify me")

a_stand_alone_function() 
#outputs: I am a stand alone function, don't you dare modify me

# Well, you can decorate it to extend its behavior.
# Just pass it to the decorator, it will wrap it dynamically in 
# any code you want and return you a new function ready to be used:

a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function_decorated()
#outputs:
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs

これで、a_stand_alone_functionを呼び出すたびに、代わりにa_stand_alone_function_decoratedが呼び出されるようになります。それは簡単です。a_stand_alone_functionが返す関数でmy_shiny_new_decoratorを上書きするだけです：

a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function()
#outputs:
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs

# That’s EXACTLY what decorators do!

わかりやすいデコレーター

デコレータ構文を使用した前の例：

@my_shiny_new_decorator
def another_stand_alone_function():
    print("Leave me alone")

another_stand_alone_function()  
#outputs:  
#Before the function runs
#Leave me alone
#After the function runs

はい、それだけです、とても簡単です。 @decoratorは次のショートカットです：

another_stand_alone_function = my_shiny_new_decorator(another_stand_alone_function)

デコレータは デコレータデザインパターン のPython版です。 Pythonには、開発を容易にするためにいくつかの古典的なデザインパターンが組み込まれています（イテレーターなど）。

もちろん、デコレータを蓄積できます：

def bread(func):
    def wrapper():
        print("</''''''\>")
        func()
        print("<\______/>")
    return wrapper

def ingredients(func):
    def wrapper():
        print("#tomatoes#")
        func()
        print("~salad~")
    return wrapper

def sandwich(food="--ham--"):
    print(food)

sandwich()
#outputs: --ham--
sandwich = bread(ingredients(sandwich))
sandwich()
#outputs:
#</''''''\>
# #tomatoes#
# --ham--
# ~salad~
#<\______/>

Pythonデコレーター構文の使用：

@bread
@ingredients
def sandwich(food="--ham--"):
    print(food)

sandwich()
#outputs:
#</''''''\>
# #tomatoes#
# --ham--
# ~salad~
#<\______/>

デコレータを設定する順序は重要です：

@ingredients
@bread
def strange_sandwich(food="--ham--"):
    print(food)

strange_sandwich()
#outputs:
##tomatoes#
#</''''''\>
# --ham--
#<\______/>
# ~salad~

---

今：質問に答えるために...

結論として、質問に答える方法を簡単に確認できます。

# The decorator to make it bold
def makebold(fn):
    # The new function the decorator returns
    def wrapper():
        # Insertion of some code before and after
        return "<b>" + fn() + "</b>"
    return wrapper

# The decorator to make it italic
def makeitalic(fn):
    # The new function the decorator returns
    def wrapper():
        # Insertion of some code before and after
        return "<i>" + fn() + "</i>"
    return wrapper

@makebold
@makeitalic
def say():
    return "hello"

print(say())
#outputs: <b><i>hello</i></b>

# This is the exact equivalent to 
def say():
    return "hello"
say = makebold(makeitalic(say))

print(say())
#outputs: <b><i>hello</i></b>

ただ幸せなままにするか、脳をもう少し燃やしてデコレータの高度な使用方法を確認することができます。

---

デコレータを次のレベルに引き上げる

装飾された関数に引数を渡す

# It’s not black magic, you just have to let the wrapper 
# pass the argument:

def a_decorator_passing_arguments(function_to_decorate):
    def a_wrapper_accepting_arguments(arg1, arg2):
        print("I got args! Look: {0}, {1}".format(arg1, arg2))
        function_to_decorate(arg1, arg2)
    return a_wrapper_accepting_arguments

# Since when you are calling the function returned by the decorator, you are
# calling the wrapper, passing arguments to the wrapper will let it pass them to 
# the decorated function

@a_decorator_passing_arguments
def print_full_name(first_name, last_name):
    print("My name is {0} {1}".format(first_name, last_name))

print_full_name("Peter", "Venkman")
# outputs:
#I got args! Look: Peter Venkman
#My name is Peter Venkman

装飾方法

Pythonの素晴らしい点の1つは、メソッドと関数が実際に同じであるということです。唯一の違いは、メソッドは最初の引数が現在のオブジェクトへの参照（self）であることを期待することです。

つまり、同じ方法でデコレータを構築できます！ selfを考慮することを忘れないでください：

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 Lucy(object):

    def __init__(self):
        self.age = 32

    @method_friendly_decorator
    def sayYourAge(self, lie):
        print("I am {0}, what did you think?".format(self.age + lie))

l = Lucy()
l.sayYourAge(-3)
#outputs: I am 26, what did you think?

汎用のデコレータを作成する場合は、引数に関係なく、任意の関数またはメソッドに適用できます。次に、*args, **kwargsを使用します。

def a_decorator_passing_arbitrary_arguments(function_to_decorate):
    # The wrapper accepts any arguments
    def a_wrapper_accepting_arbitrary_arguments(*args, **kwargs):
        print("Do I have args?:")
        print(args)
        print(kwargs)
        # Then you unpack the arguments, here *args, **kwargs
        # If you are not familiar with unpacking, check:
        # http://www.saltycrane.com/blog/2008/01/how-to-use-args-and-kwargs-in-python/
        function_to_decorate(*args, **kwargs)
    return a_wrapper_accepting_arbitrary_arguments

@a_decorator_passing_arbitrary_arguments
def function_with_no_argument():
    print("Python is cool, no argument here.")

function_with_no_argument()
#outputs
#Do I have args?:
#()
#{}
#Python is cool, no argument here.

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

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

@a_decorator_passing_arbitrary_arguments
def function_with_named_arguments(a, b, c, platypus="Why not ?"):
    print("Do {0}, {1} and {2} like platypus? {3}".format(a, b, c, platypus))

function_with_named_arguments("Bill", "Linus", "Steve", platypus="Indeed!")
#outputs
#Do I have args ? :
#('Bill', 'Linus', 'Steve')
#{'platypus': 'Indeed!'}
#Do Bill, Linus and Steve like platypus? Indeed!

class Mary(object):

    def __init__(self):
        self.age = 31

    @a_decorator_passing_arbitrary_arguments
    def sayYourAge(self, lie=-3): # You can now add a default value
        print("I am {0}, what did you think?".format(self.age + lie))

m = Mary()
m.sayYourAge()
#outputs
# Do I have args?:
#(<__main__.Mary object at 0xb7d303ac>,)
#{}
#I am 28, what did you think?

デコレータに引数を渡す

さて、デコレータ自体に引数を渡すことについてどう思いますか？

デコレータは引数として関数を受け入れなければならないため、これは多少ねじれます。したがって、装飾された関数の引数を直接デコレータに渡すことはできません。

ソリューションに急ぐ前に、少しリマインダーを書きましょう。

# Decorators are ORDINARY functions
def my_decorator(func):
    print("I am an ordinary function")
    def wrapper():
        print("I am function returned by the decorator")
        func()
    return wrapper

# Therefore, you can call it without any "@"

def lazy_function():
    print("zzzzzzzz")

decorated_function = my_decorator(lazy_function)
#outputs: I am an ordinary function

# It outputs "I am an ordinary function", because that’s just what you do:
# calling a function. Nothing magic.

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

#outputs: I am an ordinary function

まったく同じです。 「my_decorator」が呼び出されます。したがって、@my_decoratorの場合、Pythonに「変数 "my_decorator"でラベル付けされた」関数を呼び出すように指示します。

これは重要！指定するラベルは、デコレータを直接指すことができます— またはnot 。

悪を取得しましょう。 ☺

def decorator_maker():

    print("I make decorators! I am executed only once: "
          "when you make me create a decorator.")

    def my_decorator(func):

        print("I am a decorator! I am executed only when you decorate a function.")

        def wrapped():
            print("I am the wrapper around the decorated function. "
                  "I am called when you call the decorated function. "
                  "As the wrapper, I return the RESULT of the decorated function.")
            return func()

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

        return wrapped

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

# Let’s create a decorator. It’s just a new function after all.
new_decorator = decorator_maker()       
#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator

# Then we decorate the function

def decorated_function():
    print("I am the decorated function.")

decorated_function = new_decorator(decorated_function)
#outputs:
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function

# Let’s call the function:
decorated_function()
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of the decorated function.
#I am the decorated function.

ここで驚きはありません。

まったく同じことをしましょう。ただし、厄介な中間変数はすべてスキップします。

def decorated_function():
    print("I am the decorated function.")
decorated_function = decorator_maker()(decorated_function)
#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function.

# Finally:
decorated_function()    
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of the decorated function.
#I am the decorated function.

さらに短くしましょう：

@decorator_maker()
def decorated_function():
    print("I am the decorated function.")
#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function.

#Eventually: 
decorated_function()    
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of 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: {0}, {1}".format(decorator_arg1, decorator_arg2))

    def my_decorator(func):
        # The ability to pass arguments here is a gift from closures.
        # If you are not comfortable with closures, you can assume it’s ok,
        # or read: https://stackoverflow.com/questions/13857/can-you-explain-closures-as-they-relate-to-python
        print("I am the decorator. Somehow you passed me arguments: {0}, {1}".format(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("Leonard", "Sheldon")
def decorated_function_with_arguments(function_arg1, function_arg2):
    print("I am the decorated function and only knows about my arguments: {0}"
           " {1}".format(function_arg1, function_arg2))

decorated_function_with_arguments("Rajesh", "Howard")
#outputs:
#I make decorators! And I accept arguments: Leonard Sheldon
#I am the decorator. Somehow you passed me arguments: Leonard Sheldon
#I am the wrapper around the decorated function. 
#I can access all the variables 
#   - from the decorator: Leonard Sheldon 
#   - from the function call: Rajesh Howard 
#Then I can pass them to the decorated function
#I am the decorated function and only knows about my arguments: Rajesh Howard

ここにあります：引数を持つデコレータ。引数は変数として設定できます：

c1 = "Penny"
c2 = "Leslie"

@decorator_maker_with_arguments("Leonard", c1)
def decorated_function_with_arguments(function_arg1, function_arg2):
    print("I am the decorated function and only knows about my arguments:"
           " {0} {1}".format(function_arg1, function_arg2))

decorated_function_with_arguments(c2, "Howard")
#outputs:
#I make decorators! And I accept arguments: Leonard Penny
#I am the decorator. Somehow you passed me arguments: Leonard Penny
#I am the wrapper around the decorated function. 
#I can access all the variables 
#   - from the decorator: Leonard Penny 
#   - from the function call: Leslie Howard 
#Then I can pass them to the decorated function
#I am the decorated function and only know about my arguments: Leslie Howard

ご覧のとおり、このトリックを使用する関数のように、デコレータに引数を渡すことができます。 *args, **kwargsを使用することもできます。ただし、デコレータはが1回だけと呼ばれることを忘れないでください。 Pythonがスクリプトをインポートするとき。後で引数を動的に設定することはできません。 「import x」を実行すると、関数は既に装飾されているなので、何も変更できません。

---

練習しましょう：デコレータを飾る

さて、ボーナスとして、デコレータが一般的にあらゆる引数を受け入れるようにするスニペットを提供します。結局のところ、引数を受け入れるために、別の関数を使用してデコレータを作成しました。

デコレータをラップしました。

このラップされた関数で最近見たものはありますか？

そうそう、デコレーター！

デコレータ用のデコレータを作成して楽しみましょう。

def decorator_with_args(decorator_to_enhance):
    """ 
    This function is supposed to be used as a decorator.
    It must decorate an other function, that is intended to be used as a decorator.
    Take a cup of coffee.
    It will allow any decorator to accept an arbitrary number of arguments,
    saving you the headache to remember how to do that every time.
    """

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

        # We create on the fly a decorator that accepts only a function
        # but keeps the passed arguments from the maker.
        def decorator_wrapper(func):

            # We return the result of the original decorator, which, after all, 
            # IS JUST AN ORDINARY FUNCTION (which returns a function).
            # Only pitfall: the decorator must have this specific signature or it won't work:
            return decorator_to_enhance(func, *args, **kwargs)

        return decorator_wrapper

    return decorator_maker

次のように使用できます。

# You create the function you will use as a decorator. And stick a decorator on it :-)
# Don't forget, the signature is "decorator(func, *args, **kwargs)"
@decorator_with_args 
def decorated_decorator(func, *args, **kwargs): 
    def wrapper(function_arg1, function_arg2):
        print("Decorated with {0} {1}".format(args, kwargs))
        return func(function_arg1, function_arg2)
    return wrapper

# Then you decorate the functions you wish with your brand new decorated decorator.

@decorated_decorator(42, 404, 1024)
def decorated_function(function_arg1, function_arg2):
    print("Hello {0} {1}".format(function_arg1, function_arg2))

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

# Whoooot!

前回この感覚を感じたのは、「再帰を理解する前に、最初に再帰を理解しなければならない」という男の話を聞いた後のことです。しかし、今、あなたはこれをマスターすることに満足していませんか？

---

ベストプラクティス：デコレータ

• デコレータはPython 2.4で導入されたため、コードが2.4以上で実行されることを確認してください。
• デコレータは関数呼び出しを遅くします。心に留めておきます。
• 関数の装飾を解除することはできません。（areがあり、削除可能なデコレーターを作成しますが、誰も使用しません。）関数は装飾され、すべてのコードに対して装飾されます。
• デコレータは関数をラップするため、デバッグが難しくなります。 （これはPython> = 2.5から改善されます。以下を参照してください。）

functoolsモジュールはPython 2.5で導入されました。関数functools.wraps()が含まれます。この関数は、装飾された関数の名前、モジュール、およびdocstringをラッパーにコピーします。

（面白い事実：functools.wraps()はデコレーターです！☺）

# For debugging, the stacktrace prints you the function __name__
def foo():
    print("foo")

print(foo.__name__)
#outputs: foo

# With a decorator, it gets messy    
def bar(func):
    def wrapper():
        print("bar")
        return func()
    return wrapper

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

print(foo.__name__)
#outputs: wrapper

# "functools" can help for that

import functools

def bar(func):
    # We say that "wrapper", is wrapping "func"
    # and the magic begins
    @functools.wraps(func)
    def wrapper():
        print("bar")
        return func()
    return wrapper

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

print(foo.__name__)
#outputs: foo

---

デコレータはどのように役立ちますか？

次の大きな質問：デコレータは何に使用できますか？

クールでパワフルに見えますが、実用的な例は素晴らしいでしょう。さて、1000の可能性があります。従来の使用法は、外部ライブラリから関数の動作を拡張する（変更できない）か、デバッグ用（一時的なため変更したくない）です。

これらを使用して、次のようにDRYの方法でいくつかの機能を拡張できます。

def benchmark(func):
    """
    A decorator that prints the time a function takes
    to execute.
    """
    import time
    def wrapper(*args, **kwargs):
        t = time.clock()
        res = func(*args, **kwargs)
        print("{0} {1}".format(func.__name__, time.clock()-t))
        return res
    return wrapper


def logging(func):
    """
    A decorator that logs the activity of the script.
    (it actually just prints it, but it could be logging!)
    """
    def wrapper(*args, **kwargs):
        res = func(*args, **kwargs)
        print("{0} {1} {2}".format(func.__name__, args, kwargs))
        return res
    return wrapper


def counter(func):
    """
    A decorator that counts and prints the number of times a function has been executed
    """
    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 str(reversed(string))

print(reverse_string("Able was I ere I saw Elba"))
print(reverse_string("A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!"))

#outputs:
#reverse_string ('Able was I ere I saw Elba',) {}
#wrapper 0.0
#wrapper has been used: 1x 
#ablE was I ere I saw elbA
#reverse_string ('A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!',) {}
#wrapper 0.0
#wrapper has been used: 2x
#!amanaP :lanac a ,noep a ,stah eros ,raj a ,hsac ,oloR a ,tur a ,mapS ,snip ,eperc a ,)lemac a ro( niaga gab ananab a ,gat a ,nat a ,gab ananab a ,gag a ,inoracam ,elacrep ,epins ,spam ,arutaroloc a ,shajar ,soreh ,atsap ,eonac a ,nalp a ,nam A

もちろん、デコレータの良い点は、ほとんど何でも書き直さずにデコレータを使用できることです。ドライ、私は言った：

@counter
@benchmark
@logging
def get_random_futurama_quote():
    from urllib import urlopen
    result = urlopen("http://subfusion.net/cgi-bin/quote.pl?quote=futurama").read()
    try:
        value = result.split("<br><b><hr><br>")[1].split("<br><br><hr>")[0]
        return value.strip()
    except:
        return "No, I'm ... doesn't!"


print(get_random_futurama_quote())
print(get_random_futurama_quote())

#outputs:
#get_random_futurama_quote () {}
#wrapper 0.02
#wrapper has been used: 1x
#The laws of science be a harsh mistress.
#get_random_futurama_quote () {}
#wrapper 0.01
#wrapper has been used: 2x
#Curse you, merciful Poseidon!

Python自体は、property、staticmethodなどのいくつかのデコレータを提供します。

• Djangoはデコレータを使用して、キャッシュの管理とアクセス許可の表示を行います。
• 非同期関数呼び出しのインライン化を偽造しました。

これは本当に大きな遊び場です。

Answer 3

あるいは、ファクトリ関数に渡されるタグでデコレートされた関数の戻り値をラップするデコレータを返すファクトリ関数を書くこともできます。例えば：

from functools import wraps

def wrap_in_tag(tag):
    def factory(func):
        @wraps(func)
        def decorator():
            return '<%(tag)s>%(rv)s</%(tag)s>' % (
                {'tag': tag, 'rv': func()})
        return decorator
    return factory

これにより、次のように書くことができます。

@wrap_in_tag('b')
@wrap_in_tag('i')
def say():
    return 'hello'

または

makebold = wrap_in_tag('b')
makeitalic = wrap_in_tag('i')

@makebold
@makeitalic
def say():
    return 'hello'

個人的には私はデコレータを多少異なって書いたでしょう：

from functools import wraps

def wrap_in_tag(tag):
    def factory(func):
        @wraps(func)
        def decorator(val):
            return func('<%(tag)s>%(val)s</%(tag)s>' %
                        {'tag': tag, 'val': val})
        return decorator
    return factory

これは次のようになります。

@wrap_in_tag('b')
@wrap_in_tag('i')
def say(val):
    return val
say('hello')

デコレータの構文が省略形である構成を忘れないでください。

say = wrap_in_tag('b')(wrap_in_tag('i')(say)))

Answer 4

他の人がすでに問題を解決する方法をあなたに言っているようです。これがあなたがデコレータとは何かを理解するのに役立つことを願っています。

デコレータは単なる構文糖です。

この

@decorator
def func():
    ...

に展開

def func():
    ...
func = decorator(func)

Answer 5

もちろん、デコレータ関数からもラムダを返すことができます。

def makebold(f): 
    return lambda: "<b>" + f() + "</b>"
def makeitalic(f): 
    return lambda: "<i>" + f() + "</i>"

@makebold
@makeitalic
def say():
    return "Hello"

print say()

Answer 6

Pythonデコレータは別の機能に追加の機能を追加します

イタリックデコレータは次のようになります。

def makeitalic(fn):
    def newFunc():
        return "<i>" + fn() + "</i>"
    return newFunc

関数は関数内で定義されていることに注意してください。基本的には、関数を新しく定義されたものに置き換えます。例えば、私はこのクラスがあります

class foo:
    def bar(self):
        print "hi"
    def foobar(self):
        print "hi again"

それでは、両方の関数に "---"を実行した前後に出力させたいとします。各printステートメントの前後にprint "---"を追加することができます。私は自分自身を繰り返すのが好きではないので、私はデコレータを作ります

def addDashes(fn): # notice it takes a function as an argument
    def newFunction(self): # define a new function
        print "---"
        fn(self) # call the original function
        print "---"
    return newFunction
    # Return the newly defined function - it will "replace" the original

だから今私は私のクラスをに変更することができます

class foo:
    @addDashes
    def bar(self):
        print "hi"

    @addDashes
    def foobar(self):
        print "hi again"

デコレーターの詳細については、 http://www.ibm.com/developerworks/linux/library/l-cpdecor.htmlを確認してください

Answer 7

あなたは できます 2つの別々のデコレータを作ります。複数の引数を持つ装飾された関数をサポートするwrapped()関数の宣言での*args, **kwargsの使用に注意してください（これは例のsay()関数には必ずしも必要ではありませんが、一般性のために含まれています）。

同様の理由で、functools.wrapsデコレータは、ラップされた関数のメタ属性を装飾されているもののメタ属性に変更するために使用されます。これにより、エラーメッセージと埋め込み関数のドキュメント（func.__doc__）は、wrapped()の代わりに装飾された関数のものとなります。

from functools import wraps

def makebold(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<b>" + fn(*args, **kwargs) + "</b>"
    return wrapped

def makeitalic(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<i>" + fn(*args, **kwargs) + "</i>"
    return wrapped

@makebold
@makeitalic
def say():
    return 'Hello'

print(say())  # -> <b><i>Hello</i></b>

改良点

ご覧のとおり、これら2つのデコレータには重複したコードがたくさんあります。このような類似性を考えると、代わりに実際には デコレータファクトリ - である一般的なものを作るのが良いでしょう。言い換えれば、他のデコレータを作るデコレータです。そうすれば、コードの繰り返しが少なくなり、 _ dry _ の原則に従うことができます。

def html_deco(tag):
    def decorator(fn):
        @wraps(fn)
        def wrapped(*args, **kwargs):
            return '<%s>' % tag + fn(*args, **kwargs) + '</%s>' % tag
        return wrapped
    return decorator

@html_deco('b')
@html_deco('i')
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>

コードを読みやすくするために、ファクトリ生成のデコレータにもっとわかりやすい名前を割り当てることができます。

makebold = html_deco('b')
makeitalic = html_deco('i')

@makebold
@makeitalic
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>

あるいはこのように組み合わせることもできます。

makebolditalic = lambda fn: makebold(makeitalic(fn))

@makebolditalic
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>

効率

上記の例はすべてうまくいきますが、一度に複数のデコレータが適用されると、生成されたコードは無関係な関数呼び出しの形でかなりの量のオーバーヘッドを伴います。正確な使用法（たとえば、I/Oバウンドなど）によっては、これは問題にならない可能性があります。

装飾された関数の速度が重要な場合は、すべてのタグを一度に追加して実装するわずかに異なるデコレータファクトリ関数を書くことによって、オーバーヘッドを1つの追加関数呼び出しに抑えることができます。各タグに別々のデコレータを使用することによって。

これにはデコレータ自体の中により多くのコードが必要ですが、これは関数定義に適用されているときにのみ実行され、後でそれらが呼び出されるときには実行されません。これは、前述のようにlambda関数を使用して読みやすい名前を作成するときにも適用されます。サンプル：

def multi_html_deco(*tags):
    start_tags, end_tags = [], []
    for tag in tags:
        start_tags.append('<%s>' % tag)
        end_tags.append('</%s>' % tag)
    start_tags = ''.join(start_tags)
    end_tags = ''.join(reversed(end_tags))

    def decorator(fn):
        @wraps(fn)
        def wrapped(*args, **kwargs):
            return start_tags + fn(*args, **kwargs) + end_tags
        return wrapped
    return decorator

makebolditalic = multi_html_deco('b', 'i')

@makebolditalic
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>

Answer 8

同じことをする別の方法：

class bol(object):
  def __init__(self, f):
    self.f = f
  def __call__(self):
    return "<b>{}</b>".format(self.f())

class ita(object):
  def __init__(self, f):
    self.f = f
  def __call__(self):
    return "<i>{}</i>".format(self.f())

@bol
@ita
def sayhi():
  return 'hi'

あるいは、もっと柔軟に：

class sty(object):
  def __init__(self, tag):
    self.tag = tag
  def __call__(self, f):
    def newf():
      return "<{tag}>{res}</{tag}>".format(res=f(), tag=self.tag)
    return newf

@sty('b')
@sty('i')
def sayhi():
  return 'hi'

Answer 9

Pythonで2つのデコレータを作成するにはどうすればよいですか。

呼び出されると、次の関数が欲しいです。

@makebold
@makeitalic
def say():
    return "Hello"

戻るには：

<b><i>Hello</i></b>

簡単な解決策

これを最も簡単に行うには、関数（クロージャ）を閉じるラムダ（無名関数）を返すデコレータを作成して、それを呼び出します。

def makeitalic(fn):
    return lambda: '<i>' + fn() + '</i>'

def makebold(fn):
    return lambda: '<b>' + fn() + '</b>'

必要に応じて使用してください。

@makebold
@makeitalic
def say():
    return 'Hello'

そしていま：

>>> say()
'<b><i>Hello</i></b>'

簡単な解決策の問題

しかし、元の機能をほぼ失ったようです。

>>> say
<function <lambda> at 0x4ACFA070>

それを見つけるために、それぞれのラムダのクロージャを掘り下げる必要があります。

>>> say.__closure__[0].cell_contents
<function <lambda> at 0x4ACFA030>
>>> say.__closure__[0].cell_contents.__closure__[0].cell_contents
<function say at 0x4ACFA730>

そのため、この関数にドキュメントを追加したり、複数の引数を取る関数を装飾したい場合、またはデバッグセッションでどの関数を見ていたのかを知りたいだけの場合は、もう少し行う必要があります。ラッパー。

フル機能のソリューション - これらの問題のほとんどを克服する

標準ライブラリのwrapsモジュールからデコレータfunctoolsができました！

from functools import wraps

def makeitalic(fn):
    # must assign/update attributes from wrapped function to wrapper
    # __module__, __name__, __doc__, and __dict__ by default
    @wraps(fn) # explicitly give function whose attributes it is applying
    def wrapped(*args, **kwargs):
        return '<i>' + fn(*args, **kwargs) + '</i>'
    return wrapped

def makebold(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return '<b>' + fn(*args, **kwargs) + '</b>'
    return wrapped

まだ定型文が残っているのは残念ですが、これは私たちができる限り簡単なことです。

Python 3では、デフォルトで__qualname__と__annotations__が割り当てられます。

だから今：

@makebold
@makeitalic
def say():
    """This function returns a bolded, italicized 'hello'"""
    return 'Hello'

そしていま：

>>> say
<function say at 0x14BB8F70>
>>> help(say)
Help on function say in module __main__:

say(*args, **kwargs)
    This function returns a bolded, italicized 'hello'

結論

そのため、wrapsを使用すると、ラッピング関数はほとんどすべての処理を実行しますが、関数が引数として取るものを正確に示すことができます。

問題に取り組むことを試みるかもしれない他のモジュールがありますが、解決策はまだ標準ライブラリにありません。

Answer 10

デコレータは関数定義を受け取り、この関数を実行して結果を変換する新しい関数を作成します。

@deco
def do():
    ...

次のものと同等です。

do = deco(do)

例：

def deco(func):
    def inner(letter):
        return func(letter).upper()  #upper
    return inner

この

@deco
def do(number):
    return chr(number)  # number to letter

このdef do2（number）と同値です。return chr（number）

do2 = deco(do2)

65 <=> 'a'

print(do(65))
print(do2(65))
>>> B
>>> B

デコレータを理解するには、デコレータがfuncを実行して結果を変換するinnerの新しい関数doを作成したことに注意することが重要です。

Answer 11

簡単な方法でデコレータを説明するには：

と：

@decor1
@decor2
def func(*args, **kwargs):
    pass

いつ行うのか：

func(*args, **kwargs)

あなたは本当にします：

decor1(decor2(func))(*args, **kwargs)

Answer 12

#decorator.py
def makeHtmlTag(tag, *args, **kwds):
    def real_decorator(fn):
        css_class = " class='{0}'".format(kwds["css_class"]) \
                                 if "css_class" in kwds else ""
        def wrapped(*args, **kwds):
            return "<"+tag+css_class+">" + fn(*args, **kwds) + "</"+tag+">"
        return wrapped
    # return decorator dont call it
    return real_decorator

@makeHtmlTag(tag="b", css_class="bold_css")
@makeHtmlTag(tag="i", css_class="italic_css")
def hello():
    return "hello world"

print hello()

Classでデコレータを書くこともできます

#class.py
class makeHtmlTagClass(object):
    def __init__(self, tag, css_class=""):
        self._tag = tag
        self._css_class = " class='{0}'".format(css_class) \
                                       if css_class != "" else ""

    def __call__(self, fn):
        def wrapped(*args, **kwargs):
            return "<" + self._tag + self._css_class+">"  \
                       + fn(*args, **kwargs) + "</" + self._tag + ">"
        return wrapped

@makeHtmlTagClass(tag="b", css_class="bold_css")
@makeHtmlTagClass(tag="i", css_class="italic_css")
def hello(name):
    return "Hello, {}".format(name)

print hello("Your name")

Answer 13

これがデコレータの連鎖の簡単な例です。最後の行に注意してください - それはカバーの下で何が起こっているかを示しています。

############################################################
#
#    decorators
#
############################################################

def bold(fn):
    def decorate():
        # surround with bold tags before calling original function
        return "<b>" + fn() + "</b>"
    return decorate


def uk(fn):
    def decorate():
        # swap month and day
        fields = fn().split('/')
        date = fields[1] + "/" + fields[0] + "/" + fields[2]
        return date
    return decorate

import datetime
def getDate():
    now = datetime.datetime.now()
    return "%d/%d/%d" % (now.day, now.month, now.year)

@bold
def getBoldDate(): 
    return getDate()

@uk
def getUkDate():
    return getDate()

@bold
@uk
def getBoldUkDate():
    return getDate()


print getDate()
print getBoldDate()
print getUkDate()
print getBoldUkDate()
# what is happening under the covers
print bold(uk(getDate))()

出力は以下のようになります。

17/6/2013
<b>17/6/2013</b>
6/17/2013
<b>6/17/2013</b>
<b>6/17/2013</b>

Answer 14

この答えは長い間答えられてきました、しかし、私は私が私のDecoratorクラスを共有することを考えました。

from abc import ABCMeta, abstractclassmethod

class Decorator(metaclass=ABCMeta):
    """ Acts as a base class for all decorators """

    def __init__(self):
        self.method = None

    def __call__(self, method):
        self.method = method
        return self.call

    @abstractclassmethod
    def call(self, *args, **kwargs):
        return self.method(*args, **kwargs)

1つには、これによってデコレータの動作が非常に明確になると思いますが、新しいデコレータを非常に簡潔に定義することも容易になります。上記の例では、次のように解くことができます。

class MakeBold(Decorator):
    def call():
        return "<b>" + self.method() + "</b>"

class MakeItalic(Decorator):
    def call():
        return "<i>" + self.method() + "</i>"

@MakeBold()
@MakeItalic()
def say():
   return "Hello"

また、イテレータのすべての引数に関数を自動的に再帰的に適用させるデコレータなど、より複雑なタスクを実行するためにも使用できます。

class ApplyRecursive(Decorator):
    def __init__(self, *types):
        super().__init__()
        if not len(types):
            types = (dict, list, Tuple, set)
        self._types = types

    def call(self, arg):
        if dict in self._types and isinstance(arg, dict):
            return {key: self.call(value) for key, value in arg.items()}

        if set in self._types and isinstance(arg, set):
            return set(self.call(value) for value in arg)

        if Tuple in self._types and isinstance(arg, Tuple):
            return Tuple(self.call(value) for value in arg)

        if list in self._types and isinstance(arg, list):
            return list(self.call(value) for value in arg)

        return self.method(arg)


@ApplyRecursive(Tuple, set, dict)
def double(arg):
    return 2*arg

print(double(1))
print(double({'a': 1, 'b': 2}))
print(double({1, 2, 3}))
print(double((1, 2, 3, 4)))
print(double([1, 2, 3, 4, 5]))

どの印刷物：

2
{'a': 2, 'b': 4}
{2, 4, 6}
(2, 4, 6, 8)
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

この例ではデコレータのインスタンス化にlist型が含まれていなかったので、最後のprint文ではメソッドはリスト自体に適用され、リストの要素には適用されません。

Answer 15

反例といえば、上記のように、デコレータを使用するすべての関数間でカウンターが共有されます。

def counter(func):
    def wrapped(*args, **kws):
        print 'Called #%i' % wrapped.count
        wrapped.count += 1
        return func(*args, **kws)
    wrapped.count = 0
    return wrapped

このようにして、あなたのデコレータは異なる関数のために再利用することができ（または同じ関数を複数回装飾するために使用されます：func_counter1 = counter(func); func_counter2 = counter(func)）、そしてcounter変数はそれぞれにプライベートのままになります。

Answer 16

さまざまな数の引数で関数を装飾します。

def frame_tests(fn):
    def wrapper(*args):
        print "\nStart: %s" %(fn.__name__)
        fn(*args)
        print "End: %s\n" %(fn.__name__)
    return wrapper

@frame_tests
def test_fn1():
    print "This is only a test!"

@frame_tests
def test_fn2(s1):
    print "This is only a test! %s" %(s1)

@frame_tests
def test_fn3(s1, s2):
    print "This is only a test! %s %s" %(s1, s2)

if __== "__main__":
    test_fn1()
    test_fn2('OK!')
    test_fn3('OK!', 'Just a test!')

結果：

Start: test_fn1  
This is only a test!  
End: test_fn1  


Start: test_fn2  
This is only a test! OK!  
End: test_fn2  


Start: test_fn3  
This is only a test! OK! Just a test!  
End: test_fn3  

Answer 17

Paolo Bergantinoの答え はstdlibのみを使用するという大きな利点があり、decorator argumentsやdecorated function引数が存在しないこの単純な例ではうまくいきます。

ただし、より一般的なケースに取り組むには、3つの大きな制限があります。

• すでにいくつかの回答で述べたように、コードを に変更するのは簡単ではありません - オプションのデコレータ引数 を追加します。例えばmakestyle(style='bold')デコレータを作成することは自明ではありません。
• その上、@functools.wraps で作成されたラッパーはシグネチャ を保存しないので、間違った引数が与えられるとそれらは実行を開始し、通常のTypeErrorとは異なる種類のエラーを引き起こすかもしれません。
• 最後に、@functools.wrapsで作成されたラッパーで その名前に基づいて引数にアクセスすることは非常に困難です 。実際には、引数は*args、**kwargs、またはまったく表示されないことがあります（オプションの場合）。

最初の問題を解決するために decopatch と書き、他の2つを解決するために makefun.wraps と書きました。 makefunは有名な decorator libと同じトリックを利用することに注意してください。

これは引数を持ったデコレータを作成する方法で、本当にシグネチャを保護したラッパーを返します：

from decopatch import function_decorator, DECORATED
from makefun import wraps

@function_decorator
def makestyle(st='b', fn=DECORATED):
    open_tag = "<%s>" % st
    close_tag = "</%s>" % st

    @wraps(fn)
    def wrapped(*args, **kwargs):
        return open_tag + fn(*args, **kwargs) + close_tag

    return wrapped

decopatchはあなたの好みに応じて、さまざまなpythonの概念を隠したり表示したりする他の2つの開発スタイルをあなたに提供します。最もコンパクトなスタイルは次のとおりです。

from decopatch import function_decorator, WRAPPED, F_ARGS, F_KWARGS

@function_decorator
def makestyle(st='b', fn=WRAPPED, f_args=F_ARGS, f_kwargs=F_KWARGS):
    open_tag = "<%s>" % st
    close_tag = "</%s>" % st
    return open_tag + fn(*f_args, **f_kwargs) + close_tag

どちらの場合も、デコレータが期待通りに動作することを確認できます。

@makestyle
@makestyle('i')
def hello(who):
    return "hello %s" % who

assert hello('world') == '<b><i>hello world</i></b>'    

詳細は ドキュメント を参照してください。