잡다한 이야기

Question 1

다음을 수행하는 두 개의 데코레이터를 Python에서 어떻게 만들 수 있습니까?

@make_bold
@make_italic
def say():
   return "Hello"

호출 say()은 다음을 반환해야 합니다.

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

Question 2

긴 설명이 필요하지 않은 경우 Paolo Bergantino의 답변 을 참조하십시오 .

데코레이터 기본

파이썬의 함수는 객체다

데코레이터를 이해하려면 먼저 함수가 파이썬에서 객체라는 것을 이해해야 합니다. 이것은 중요한 결과를 낳습니다. 간단한 예를 들어 그 이유를 살펴보겠습니다.

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 함수의 또 다른 흥미로운 속성은 다른 함수 내부에서 정의할 수 있다는 것입니다!

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

함수 참조

좋아, 아직 여기 있어? 이제 재미있는 부분...

함수가 객체라는 것을 보았습니다. 따라서 기능:

변수에 할당할 수 있습니다.
다른 함수에서 정의할 수 있습니다.

즉 , 함수가 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에 내장된 몇 가지 고전적인 디자인 패턴이 있습니다.

물론 데코레이터를 축적할 수 있습니다.

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의 멋진 점 중 하나는 메서드와 함수가 실제로 동일하다는 것입니다. 유일한 차이점은 메서드는 첫 번째 인수가 현재 개체( 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, 당신은 파이썬에게 '변수 " my_decorator"'로 레이블이 지정된 함수를 호출하도록 지시하는 것입니다.

이건 중요하다! 제공한 레이블은 데코레이터를 직접 가리킬 수도 있고 그렇지 않을 수도 있습니다.

악을 얻자. ☺

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. 그러나 데코레이터는 한 번만 호출된다는 것을 기억하십시오 . 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에서 실행되는지 확인하십시오.
데코레이터는 함수 호출을 느리게 합니다. 그것을 염두에 두십시오.
기능의 장식을 해제할 수 없습니다. ( 제거할 수 있는 데코레이터를 만드는 방법 이 있지만 아무도 사용하지 않습니다.) 따라서 함수가 장식되면 모든 코드에 대해 장식됩니다 .
데코레이터는 함수를 래핑하여 디버그하기 어렵게 만들 수 있습니다. (Python >= 2.5에서 더 좋아집니다. 아래를 참조하세요.)

이 functools모듈은 Python 2.5에서 도입되었습니다. 여기에는 functools.wraps()데코레이팅된 함수의 이름, 모듈 및 독스트링을 래퍼에 복사하는 함수가 포함됩니다.

(재미있는 사실: 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!

파이썬 자체는 여러 데코레이터를 제공합니다: property, staticmethod등.

Django는 데코레이터를 사용하여 캐싱 및 보기 권한을 관리합니다.
인라인 비동기 함수 호출을 가짜로 만들었습니다.

이곳은 정말 큰 놀이터입니다.

Question 3

데코레이터가 작동하는 방식을 보려면 문서 를 확인하세요 . 요청하신 내용은 다음과 같습니다.

from functools import wraps

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

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

@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.__name__ # with functools.wraps() this returns "hello"
print log('hello')   # returns "<b><i>hello</i></b>"

Question 4

또는 팩토리 함수에 전달된 태그에 데코레이팅된 함수의 반환 값을 래핑하는 데코레이터를 반환하는 팩토리 함수를 작성할 수 있습니다. 예를 들어:

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)))

[python] Python에서 파일이나 폴더를 어떻게 삭제합니까? (0)	2022.08.22
[python] __init__() 메서드로 Python super() 이해하기 [중복] (0)	2022.08.22
[python] *(이중 별표/별표) 및 (별표/별표)는 매개변수에 대해 무엇을 합니까? (0)	2022.08.22
[python] 시간 지연은 어떻게 합니까? [복제하다] (0)	2022.08.22
[python] 열 값을 기반으로 DataFrame에서 행을 어떻게 선택합니까? (0)	2022.08.22

일	월	화	수	목	금	토
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31

잡다한 이야기

[python] 함수 데코레이터를 만들고 함께 연결하려면 어떻게 해야 합니까?

데코레이터 기본

파이썬의 함수는 객체다

함수 참조

수제 데코레이터

데코레이터

지금: 질문에 답하기 위해...

데코레이터를 다음 단계로 끌어올리기

데코레이팅된 함수에 인수 전달

장식 방법

데코레이터에 인수 전달

연습하자: 데코레이터 꾸미기

모범 사례: 데코레이터

데코레이터는 어떻게 유용합니까?

'파이썬' 카테고리의 다른 글

'파이썬'의 다른글

티스토리툴바

[python] 함수 데코레이터를 만들고 함께 연결하려면 어떻게 해야 합니까?

데코레이터 기본

파이썬의 함수는 객체다

함수 참조

수제 데코레이터

데코레이터

지금: 질문에 답하기 위해...

데코레이터를 다음 단계로 끌어올리기

데코레이팅된 함수에 인수 전달

장식 방법

데코레이터에 인수 전달

연습하자: 데코레이터 꾸미기

모범 사례: 데코레이터

데코레이터는 어떻게 유용합니까?

'파이썬' 카테고리의 다른 글

'파이썬'의 다른글

관련글

티스토리툴바