>

매개 변수를 사용하거나 사용하지 않고 데코레이터를 만들고 싶습니다. 다음과 같은 것 :

class d(object):
    def __init__(self,msg='my default message'):
        self.msg = msg
    def __call__(self,fn):
        def newfn():
            print self.msg
            return fn()
        return newfn
@d('This is working')
def hello():
    print 'hello world !'
@d
def too_bad():
    print 'does not work'

내 코드에서는 매개 변수가있는 데코레이터 만 사용하고 있습니다 : 매개 변수가 있거나없는 작업을 계속 진행하는 방법은 무엇입니까?


  • 답변 # 1

    예를 찾았습니다. @trace 를 사용할 수 있습니다  또는 @trace('msg1','msg2') : 좋습니다!

    def trace(*args):
        def _trace(func):
            def wrapper(*args, **kwargs):
                print enter_string
                func(*args, **kwargs)
                print exit_string
            return wrapper
        if len(args) == 1 and callable(args[0]):
            # No arguments, this is the decorator
            # Set default values for the arguments
            enter_string = 'entering'
            exit_string = 'exiting'
            return _trace(args[0])
        else:
            # This is just returning the decorator
            enter_string, exit_string = args
            return _trace
    
    

  • 답변 # 2

    데코레이터로 매개 변수를 가져 오려면항상함수로 호출해야합니다 :

    @d()
    def func():
        pass
    
    

    그렇지 않으면 매개 변수의 차이를 감지해야합니다. 즉, 호출자가 의미하는 바를 마술로 추측해야합니다. 추측해야하는 API를 작성하지 마십시오. 처음부터 무슨 뜻인지 말하십시오.

    즉, 함수는 데코레이터 또는 데코레이터 팩토리 여야합니다. 둘다는 안됩니다.

    값을 저장하기 만하면 클래스를 작성할 필요가 없습니다.

    def d(msg='my default message'):
        def decorator(func):
            def newfn():
                print msg
                return func()
            return newfn
        return decorator
    @d('This is working')
    def hello():
        print 'hello world !'
    @d()
    def hello2():
        print 'also hello world'
    
    

  • 답변 # 3

    명명 된 인수를 사용하는 것이 마음에 들지 않으면 필요한 것과 비슷한 것을 만들었습니다.

    def cached_property(method=None, get_attribute=lambda a: '_%s_cached' % (a,)):
        """
        Caches an object's attribute.
        Can be used in the following forms:
        @cached_property
        @cached_property()
        @cached_property(get_attribute=lambda x: 'bla')
        @param method: the method to memoizes
        @param get_attribute: a callable that should return the cached attribute
        @return a cached method
        """
        def decorator(method):
            def wrap(self):
                private_attribute = get_attribute(method.__name__)
                try:
                    return getattr(self, private_attribute)
                except AttributeError:
                    setattr(self, private_attribute, method(self))
                    return getattr(self, private_attribute)
            return property(wrap)
        if method:
            # This was an actual decorator call, ex: @cached_property
            return decorator(method)
        else:
            # This is a factory call, ex: @cached_property()
            return decorator
    
    

    키워드가 아닌 하나의 인수 만 꾸미면 함수가 데코레이터에 전달되기 때문에 작동합니다.

    이 경우에는 'self'인 데코 레이팅 된 함수에 전달 된 인수도 사용했음을 알립니다.

  • 답변 # 4

    데코레이터에 대한 인수가 함수인지 감지하고 간단한 데코레이터를 사용해야합니다 이 경우에. 그리고 매개 변수화 된 데코레이터에게 함수 만 전달할 필요가 없기를 바랍니다.

  • 답변 # 5

    이것은 효과가 있습니다.

    def d(arg):
        if callable(arg):
            def newfn():
                print 'my default message'
                return arg()
            return newfn
        else:
            def d2(fn):
                def newfn():
                    print arg
                    return fn()
                return newfn
            return d2
    @d('This is working')
    def hello():
        print 'hello world !'
    @d
    def hello2():
        print 'hello2 world !'
    @d('Applying it twice')
    @d('Would also work')
    def hello3():
        print 'hello3 world !'
    hello()
    hello2()
    hello3()
    # output
    #
    # This is working
    # hello world !
    # my default message
    # hello2 world !
    # Applying it twice
    # Would also work
    # hello3 world !
    
    

    데코레이터 함수 @invocation에 명시 적 인수가 전달되지 않으면 다음 def 에 정의 된 함수로 호출됩니다. .에 인수를 전달한 경우, 먼저 인수와 함께 호출 된 다음예비 호출 (그 자체도 호출 가능해야 함)의 결과가 함수를 사용하여 호출됩니다. 한정된. 어느 쪽이든, 마지막 또는 유일한 호출의 반환 값은 정의 된 함수 이름에 바인딩됩니다.

관련 자료

  • 이전 node.js - nodejs에서 메모리 누수 감지
  • 다음 jquery - 입력 요소에 부트 스트랩 툴팁을 사용하는 방법은 무엇입니까?