1、带参数的装饰器
装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(condition)。为装饰器的编写和使用提供了更大的灵活性。比如，我们可以在装饰器中指定日志的等级，因为不同业务函数可能需要不同的日志级别。
def logging_tool(level):
def decorator(func):
def wrapper(*arg, **kwargs):
if level == 'error':
logging.error('%s is running...' % func.__name__)
elif level == 'warn':
logging.warn('%s is running...' % func.__name__)
else:
logging.info('%s is running...' % func.__name__)
func()
return wrapper
return decorator
@logging_tool(level='warn')
def today(name='devin'):
print('Hello, %s! Today is 208-05-25' % name)
today()
2、让装饰器同时支持带参数或不带参数
def new_logging_tool(obj):
if isinstanc(obj, str): # 带参数的情况，参数类型为str
def decorator(func):
@functools.wraps(func)
def wrapper(*arg, **kwargs):
if obj == 'error':
logging.error('%s is running...' % func.__name__)
elif obj == 'warn':
logging.warn('%s is running...' % func.__name__)
else:
logging.info('%s is running...' % func.__name__)
func()
return wrapper
return decorator
else: # 不带参数的情况，参数类型为函数类型，即被装饰的函数
@functools.wraps(obj)
def wrapper(*args, **kwargs):
logging.info('%s is running...' % obj.__name__)
obj()
return wrapper
@new_logging_tool
def yesterday():
print('2018-05-24')
yesterday()
@new_logging_tool('warn')
def today(name='devin'):
print('Hello, %s! Today is 208-05-25' % name)
today()
如上所示，参数有两种类型，一种是字符串，另一种是可调用的函数类型。因此，通过对参数类型的判断即可实现支持带参数和不带参数的两种情况。
3、类装饰器
装饰器不仅可以是函数，还可以是类，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器主要依靠类的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。
（1）示例一、被装饰函数不带参数
class Foo(object):
def __init__(self, func):
self._func = func # 初始化装饰的函数
def __call__(self):
print ('class decorator runing')
self._func() # 调用装饰的函数
print ('class decorator ending')
@Foo
def bar(): # 被装饰函数不带参数的情况
print ('bar')
bar()
（2）示例二、被装饰函数带参数
class Counter:
def __init__(self, func):
self.func = func
self.count = 0 # 记录函数被调用的次数
def __call__(self, *args, **kwargs):
self.count += 1
return self.func(*args, **kwargs)
@Counter
def today(name='devin'):
print('Hello, %s! Today is 208-05-25' % name) # 被装饰的函数带参数的情况
for i in range(10):
today()
print(today.count) # 10
（3）示例三、不依赖初始化函数，单独使用__call__函数实现（体现类装饰器灵活性大、高内聚、封装性高的特点）实现当一些重要函数执行时，打印日志到一个文件中，同时发送一个通知给用户
class LogTool(object):
def __init__(self, logfile='out.log'):
self.logfile = logfile # 指定日志记录文件
def __call__(self, func): # __call__作为装饰器函数
@functools.wraps(func)
def wrapper(*args, **kwargs):
log_string = func.__name__ + " was called"
print(log_string) # 输出日志
with open(self.logfile, 'a') as fw:
fw.write(log_string + '\n') # 保存日志
self.notify() # 发送通知
return func(*args, **kwargs)
return wrapper
# 在类中实现通知功能的封装
def notify(self):
pass
@LogTool() # 单独使用__call__函数实现时，别忘了添加括号，进行类的初始化
def bill_func():
pass
进一步扩展，给LogTool创建子类，来添加email的功能：
class EmailTool(LogTool):
"""
LogTool的子类，实现email通知功能，在函数调用时发送email给用户
"""
def __init__(self, email='admin@myproject.com', *args, **kwargs):
self.email = email
super(EmailTool, self).__init__(*args, **kwargs)
# 覆盖父类的通知功能，实现发送一封email到self.email
def notify(self):
pass
@EmailTool()
def bill_func():
pass
4、装饰函数 -> 装饰类
（1）函数层面的装饰器很常见，以一个函数作为输入，返回一个新的函数；（2）类层面的装饰其实也类似，已一个类作为输入，返回一个新的类；
例如：给一个已有的类添加长度属性和getter、setter方法
def Length(cls):
class NewClass(cls):
@property
def length(self):
if hasattr(self, '__len__'):
self._length = len(self)
return self._length
@length.setter
def length(self, value):
self._length = value
return NewClass
@Length
class Tool(object):
pass
t = Tool()
t.length = 10
print(t.length) # 10
五、上古神器
1、@property -> getter/setter方法
示例：给一个Student添加score属性的getter、setter方法
class Student(object):
@property
def score(self):
return self._score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer')
if value < 0 or value > 100:
raise ValueError('score must between 0~100!')
self._score = value
s = Student()
s.core = 60
print('s.score = ', s.score)
s.score = 999 # ValueError: score must between 0~100!
2、@classmethod、@staticmethod
（1）@classmethod 类方法：定义备选构造器，第一个参数是类本身（参数名不限制，一般用cls）（2）@staticmethod 静态方法：跟类关系紧密的函数
简单原理示例：
class A(object):
@classmethod
def method(cls):
pass
等价于
class A(object):
def method(cls):
pass
method = classmethod(method)
3、@functools.wraps
装饰器极大地复用了代码，但它有一个缺点：因为返回的是嵌套的函数对象wrapper，不是原函数，导致原函数的元信息丢失，比如函数的docstring、name、参数列表等信息。不过呢，办法总比困难多，我们可以通过@functools.wraps将原函数的元信息拷贝到装饰器里面的func函数中，使得装饰器里面的func和原函数有一样的元信息。
def timethis(func):
"""
Decorator that reports the execution time.
"""
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
print(func.__name__, time.time() - start)
return result
return wrapper
@timethis
def countdown(n: int):
"""Counts down"""
while n > 0:
n -= 1
countdown(10000000) # 1.3556335
print(countdown.__name__, ' doc: ', countdown.__doc__, ' annotations: ', countdown.__annotations__)
@functools.wraps让我们可以通过属性__wrapped__直接访问被装饰的函数，同时让被装饰函数正确暴露底层的参数签名信息
countdown.__wrapped__(1000) # 访问被装饰的函数
print(inspect.signature(countdown)) # 输出被装饰函数的签名信息
4、Easter egg
（1） 定义一个接受参数的包装器
@decorator(x, y, z)
def func(a, b):
pass
等价于
func = decorator(x, y, z)(func)
即：decorator(x, y, z)的返回结果必须是一个可调用的对象，它接受一个函数作为参数并包装它。
（2）一个函数可以同时定义多个装饰器，比如：
@a
@b
@c
def f():
pass
一、Python所有方向的学习路线
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。
二、Python必备开发工具
工具都帮大家整理好了，安装就可直接上手！
三、最新Python学习笔记
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。
四、Python视频合集
观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
五、实战案例
纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
六、面试宝典
