programing

기능성 데코레이터를 만들고 어떻게 묶어야 하나요?

shortcode 2022. 10. 6. 22:09

기능성 데코레이터를 만들고 어떻게 묶어야 하나요?

Python에서 다음 작업을 할 수 있는 두 개의 데코레이터를 만들려면 어떻게 해야 하나요?

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

" "say()★★★★

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

긴 설명에 관심이 없다면 파올로 베르간티노의 답변을 참고하세요.

데코레이터의 기본

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

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

함수 참조

좋아, 아직 여기 있어?이제 재밌는 건...

함수는 객체라는 것을 보셨을 겁니다.따라서 기능은 다음과 같습니다.

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

즉, 함수는 다른 함수를 사용할 수 있습니다.

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"Python"으로 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.

?Function Call에서 Call을 했습니다.@ " 구문! :-)

자, 다시 데코레이터와 말다툼으로 돌아가죠.함수를 사용하여 즉시 데코레이터를 생성할 수 있다면 그 함수에 인수를 전달할 수 있습니다.

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할 때.나중에 인수를 동적으로 설정할 수 없습니다.「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에서 도입되었습니다. the이 it function function function function function function function function function라는 기능을 포함하고 있습니다.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가지 가능성이 있어요.일반적으로 외부 lib에서 함수 동작을 확장하거나(수정할 수 없음), 디버깅(일시적이므로 수정하지 않음)을 위해 사용합니다.

다음과 같이 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는 데코레이터를 사용하여 캐시를 관리하고 권한을 봅니다.
비동기 함수 호출을 가짜 인라인으로 꼬았습니다.

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

데코레이터의 동작에 대해서는, 메뉴얼을 봐 주세요.요청하신 내용은 다음과 같습니다.

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

또는 공장 함수에 전달된 태그에 장식된 함수의 반환 값을 감싸는 데코레이터를 반환하는 공장 함수를 작성할 수도 있습니다.예를 들어 다음과 같습니다.

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

데코레이터는 그냥 구문설탕일 뿐이야.

이것.

@decorator
def func():
    ...

까지 확장하다.

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

물론 람다도 데코레이터 기능에서 반품할 수 있습니다.

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

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

print say()

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"

예를 들어, 두 기능 모두 완료 후와 완료 전에 "---"로 인쇄해야 합니다.각 인쇄문 앞과 뒤에 인쇄물 "---"을 추가할 수 있습니다.하지만 나는 반복하는 것을 좋아하지 않기 때문에 데코레이터를 만들 것이다.

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를 참조하십시오.

아래 그림과 같이 원하는 것을 할 수 있는 두 개의 데코레이터를 따로 만들 수 있습니다.의 사용에 주의해 주세요.*args, **kwargs에 wrapped()(예: 한 것은 」)say()의

「」는functools.wraps데코레이터는 래핑된 함수의 메타 속성을 데코되는 함수의 메타 속성으로 변경하는 데 사용됩니다.에 의해, 의 메뉴얼 「」 , 「」 )이 됩니다.func.__doc__이 아니라 입니다.wrapped()의 discriptions

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>

개량점

보시다시피 이 두 장식가에는 많은 코드가 중복되어 있습니다.이와 같은 유사성을 고려하면, 실제로 데코레이터 공장이었던 일반적인 데코레이터, 즉 다른 데코레이터를 만드는 데코레이터 기능을 만드는 것이 좋습니다.이렇게 하면 코드 반복이 줄어들고 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 바인딩)에 따라 이 문제는 중요하지 않을 수 있습니다.

장식함수의 속도가 중요한 경우에는 모든 태그를 한 번에 추가하는 약간 다른 장식기 공장 함수를 작성하여 오버헤드를 하나의 추가 함수 호출로 유지할 수 있으므로 태그별로 별도의 장식기를 사용하여 발생하는 부가 함수 호출을 회피하는 코드를 생성할 수 있다.

이렇게 하려면 데코레이터 자체에 더 많은 코드가 필요하지만 함수 정의에 적용될 때만 실행되며 나중에 함수 정의 자체를 호출할 때는 실행되지 않습니다.은 또한 읽을 수 을 만들 됩니다.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>

또 다른 방법은 다음과 같습니다.

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'

Python에서 다음 작업을 할 수 있는 두 개의 데코레이터를 어떻게 만들 수 있을까요?

호출 시 다음 함수가 필요합니다.

@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는 함수가 인수로 무엇을 사용하는지 정확히 알려주는 것 외에는 거의 모든 것을 래핑 함수가 수행하도록 합니다.

이 문제를 해결할 수 있는 다른 모듈이 있지만, 해결책은 아직 표준 라이브러리에 없습니다.

데코레이터는 함수 정의를 받아들여 이 함수를 실행하고 결과를 변환하는 새로운 함수를 만듭니다.

@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

데코레이터를 이해하기 위해서는 데코레이터가 기능을 실행하고 그 결과를 변형시키는 새로운 기능인 'do'를 만들었다는 점에 주목해야 한다.

이 답변은 오래전부터 답해 왔지만, 새로운 데코레이터를 쉽고 컴팩트하게 쓸 수 있는 데코레이터 클래스를 공유하고 싶다고 생각했습니다.

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)

우선, 이것은 데코레이터의 행동을 명확하게 한다고 생각하지만, 새로운 데코레이터를 매우 간결하게 정의하기 쉽다고 생각합니다.위의 예에서는 다음과 같이 해결할 수 있습니다.

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데코레이터의 인스턴스화를 입력하면 최종 인쇄문에 메소드가 목록의 요소가 아닌 목록 자체에 적용됩니다.

#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.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")

여기에 장식용 쇠사슬의 간단한 예가 있습니다.마지막 줄에 주의하세요. 커버 아래에서 무슨 일이 일어나고 있는지 보여줍니다.

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

카운터 예에 대해 말하자면, 위와 같이 카운터는 데코레이터를 사용하는 모든 기능 간에 공유됩니다.

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)카운터 변수는 각각 비공개로 유지됩니다.

다른 수의 인수를 사용하여 함수를 꾸밉니다.

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 __name__ == "__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

Paolo Bergantino의 답변은 stdlib만을 사용할 수 있다는 큰 장점이 있으며, 장식자 인수나 장식된 함수 인수가 없는 이 간단한 예에 적용됩니다.

다만, 보다 일반적인 케이스에 대처하는 경우는, 다음의 3개의 큰 제한이 있습니다.

몇 가지 답변에서 이미 언급했듯이 코드를 쉽게 수정하여 옵션인 데코레이터 인수를 추가할 수 없습니다.예를 들면,makestyle(style='bold')이치노
「보다」, 「보다」로 .@functools.wraps 시그니처를 보존하지 않기 때문에 잘못된 인수가 제공되면 실행이 시작되어 통상과는 다른 종류의 오류가 발생할 수 있습니다.TypeError.
'포장'이나 '포장'으로 작성된 .@functools.wraps이름을 기반으로 인수에 액세스합니다.실제로 그 논쟁은 에 나타날 수 있다.*args、。**kwargs또는 전혀 표시되지 않을 수 있습니다(옵션인 경우).

나는 첫 번째 문제를 해결하기 위해 글을 쓰고 나머지 두 문제를 해결하기 위해 글을 썼다.주의:makefun유명한 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 개념을 숨기거나 표시하는 다른 두 가지 개발 스타일이 있습니다.가장 컴팩트한 스타일은 다음과 같습니다.

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

상세한 것에 대하여는, 문서를 참조해 주세요.

데코레이터에 커스텀 파라미터를 추가하여 최종 기능에 전달하고 작업을 해야 할 경우 케이스를 추가합니다.

바로 그 장식가들:

def jwt_or_redirect(fn):
  @wraps(fn)
  def decorator(*args, **kwargs):
    ...
    return fn(*args, **kwargs)
  return decorator

def jwt_refresh(fn):
  @wraps(fn)
  def decorator(*args, **kwargs):
    ...
    new_kwargs = {'refreshed_jwt': 'xxxxx-xxxxxx'}
    new_kwargs.update(kwargs)
    return fn(*args, **new_kwargs)
  return decorator

그리고 마지막 기능:

@app.route('/')
@jwt_or_redirect
@jwt_refresh
def home_page(*args, **kwargs):
  return kwargs['refreched_jwt']

이미지를 그리기 위한 중첩된 데코레이터의 또 다른 예는 다음과 같습니다.

import matplotlib.pylab as plt

def remove_axis(func):
    def inner(img, alpha):
        plt.axis('off')
        func(img, alpha)
    return inner

def plot_gray(func):
    def inner(img, alpha):
        plt.gray()
        func(img, alpha)
    return inner

@remove_axis
@plot_gray
def plot_image(img, alpha):
    plt.imshow(img, alpha=alpha)
    plt.show()

먼저 중첩된 장식기를 사용하여 축 레이블이 없는 컬러 이미지를 표시해 보겠습니다.

plot_image(plt.imread('lena_color.jpg'), 0.4)

장식자를 remove_axis ★★★★★★★★★★★★★★★★★」plot_gray.)cmap='gray'의 경우 은 "colormap" 입니다viridis따라서 그레이스케일 이미지는 명시적으로 지정되지 않는 한 기본적으로 흑백 음영으로 표시되지 않습니다.)

plot_image(plt.imread('lena_bw.jpg'), 0.8)

위의 함수 콜은 다음과 같은 네스트된 콜로 감소합니다.

remove_axis(plot_gray(plot_image))(img, alpha)

언급URL : https://stackoverflow.com/questions/739654/how-do-i-make-function-decorators-and-chain-them-together

저작자표시

'programing' 카테고리의 다른 글

한 자바스크립트로 작성된 함수를 다른 JS파일로 호출할 수 있습니까? (0)	2022.10.06
HTML5/JavaScript를 사용하여 파일 생성 및 저장 (0)	2022.10.06
로컬 호스트에서의 XAMPP에서의 MySQL 루트 패스워드 리셋 (0)	2022.10.06
지난달의 첫날과 마지막 날을 얻는 가장 좋은 방법은? (0)	2022.10.06
C#의 DateTime을 yyy-MM-dd 형식으로 변환하여 MySql DateTime 필드에 저장합니다. (0)	2022.10.06

현재글기능성 데코레이터를 만들고 어떻게 묶어야 하나요?

각종 프로그래밍 정보를 다루는 블로그입니다.

Javascript, c#, spring, JQuery, c++, Spring3, java,

Today :
Yesterday :

shortcode

기능성 데코레이터를 만들고 어떻게 묶어야 하나요?

기능성 데코레이터를 만들고 어떻게 묶어야 하나요?

데코레이터의 기본

Python의 함수는 객체입니다.

함수 참조

수공예 장식가

데코레이터의 신분이 낮다.

자, 질문에 대답하자면...

데코레이터를 한 단계 끌어올리다

장식된 함수에 인수 전달

장식 방법

데코레이터에게 인수 전달

연습합시다: 데코레이터를 꾸미기

베스트 프랙티스: 데코레이터

장식가들이 어떻게 유용할 수 있을까요?

개량점

효율성.

Python에서 다음 작업을 할 수 있는 두 개의 데코레이터를 어떻게 만들 수 있을까요?

심플한 솔루션

심플한 솔루션의 문제

풀기능솔루션 -이러한문제의대부분의해결

결론

예제:

다른 수의 인수를 사용하여 함수를 꾸밉니다.

'programing' 카테고리의 다른 글

'programing'의 다른글

티스토리툴바

« 2025/01 »
일	월	화	수	목	금	토
			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에서 다음 작업을 할 수 있는 두 개의 데코레이터를 어떻게 만들 수 있을까요?

심플한 솔루션

심플한 솔루션의 문제

풀기능솔루션 -이러한문제의대부분의해결

결론

예제:

다른 수의 인수를 사용하여 함수를 꾸밉니다.

'programing' 카테고리의 다른 글

'programing'의 다른글

관련글

티스토리툴바