今天看到python中的一個修飾符'@'，不瞭解它的使用，查看了下官方文件，有了一點了解。

不得不佩服老外，治學很嚴謹，在python網站相關網頁上把為什麼使用decorator（主要為了簡便一些程式碼），以及使用什麼字元，甚至語法怎麼設計寫了個詳詳細細，好長的一篇啊。

這是檢視的其中一篇，我翻譯關鍵部分的一些內容，又摘取一些有用的，有空再翻譯。

@dec2
@dec1
def func(arg1, arg2, ...):
    pass

def func(arg1, arg2, ...):
    pass
func = dec2(dec1(func))
 

Much of the discussion on comp.lang.python and the python-dev mailing list focuses on the use of decorators as a cleaner way to use the staticmethod() and classmethod() builtins. This capability is much more powerful than that. This section presents some examples of use.

在comp.lang.python

1.Define a function to be executed at exit. Note that the function isn't actually "wrapped" in the usual sense.

def onexit(f):
    import atexit
    atexit.register(f)
    return f

@onexit
def func():
    ...
 

2. Define a class with a singleton instance. Note that once the class disappears enterprising programmers would have to be more creative to create more instances. (From Shane Hathaway onpython-dev.)

def singleton(cls):
    instances = {}
    def getinstance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return getinstance

@singleton
class MyClass:
    ...

def attrs(**kwds):
    def decorate(f):
        for k in kwds:
            setattr(f, k, kwds[k])
        return f
    return decorate

@attrs(versionadded="2.2",
       author="Guido van Rossum")
def mymethod(f):
    ...

def accepts(*types):
    def check_accepts(f):
        assert len(types) == f.func_code.co_argcount
        def new_f(*args, **kwds):
            for (a, t) in zip(args, types):
                assert isinstance(a, t), \
                       "arg %r does not match %s" % (a,t)
            return f(*args, **kwds)
        new_f.func_name = f.func_name
        return new_f
    return check_accepts

def returns(rtype):
    def check_returns(f):
        def new_f(*args, **kwds):
            result = f(*args, **kwds)
            assert isinstance(result, rtype), \
                   "return value %r does not match %s" % (result,rtype)
            return result
        new_f.func_name = f.func_name
        return new_f
    return check_returns

@accepts(int, (int,float))
@returns((int,float))
def func(arg1, arg2):
    return arg1 * arg2

def provides(*interfaces):
     """
     An actual, working, implementation of provides for
     the current implementation of PyProtocols.  Not
     particularly important for the PEP text.
     """
     def provides(typ):
         declareImplementation(typ, instancesProvide=interfaces)
         return typ
     return provides

class IBar(Interface):
     """Declare something about IBar here"""

@provides(IBar)
class Foo(object):
        """Implement something here..."""