带参数的装饰器

来想想这个问题，难道 @wraps 不也是个装饰器吗？但是，它接收一个参数，就像任何普通的函数能做的那样。那么，为什么我们不也那样做呢？

这是因为，当你使用 @my_decorator 语法时，你是在应用一个以单个函数作为参数的一个包裹函数。记住，Python里每个东西都是一个对象，而且这包括函数！记住了这些，我们可以编写一下能返回一个包裹函数的函数。

在函数中嵌入装饰器

我们回到日志的例子，并创建一个包裹函数，能让我们指定一个用于输出的日志文件。

  1. from functools import wraps
  3. def logit(logfile='out.log'):
  4.     def logging_decorator(func):
  5.         @wraps(func)
  6.         def wrapped_function(*args, **kwargs):
  7.             log_string = func.__name__ + " was called"
  8.             print(log_string)
  9.             # 打开logfile，并写入内容
  10.             with open(logfile, 'a') as opened_file:
  11.                 # 现在将日志打到指定的logfile
  12.                 opened_file.write(log_string + '\n')
  13.             return func(*args, **kwargs)
  14.         return wrapped_function
  15.     return logging_decorator
  17. @logit()
  18. def myfunc1():
  19.     pass
  21. myfunc1()
  22. # Output: myfunc1 was called
  23. # 现在一个叫做 out.log 的文件出现了，里面的内容就是上面的字符串
  25. @logit(logfile='func2.log')
  26. def myfunc2():
  27.     pass
  29. myfunc2()
  30. # Output: myfunc2 was called
  31. # 现在一个叫做 func2.log 的文件出现了，里面的内容就是上面的字符串

装饰器类

现在我们有了能用于正式环境的 logit 装饰器，但当我们的应用的某些部分还比较脆弱时，异常也许是需要更紧急关注的事情。比方说有时你只想打日志到一个文件。而有时你想把引起你注意的问题发送到一个email，同时也保留日志，留个记录。这是一个使用继承的场景，但目前为止我们只看到过用来构建装饰器的函数。

幸运的是，类也可以用来构建装饰器。那我们现在以一个类而不是一个函数的方式，来重新构建 logit。

  1. class logit(object):
  3.     _logfile = 'out.log'
  5.     def __init__(self, func):
  6.         self.func = func
  8.     def __call__(self, *args):
  9.         log_string = self.func.__name__ + " was called"
  10.         print(log_string)
  11.         # 打开logfile并写入
  12.         with open(self._logfile, 'a') as opened_file:
  13.             # 现在将日志打到指定的文件
  14.             opened_file.write(log_string + '\n')
  15.         # 现在，发送一个通知
  16.         self.notify()
  18.         # return base func
  19.         return self.func(*args)
  23.     def notify(self):
  24.         # logit只打日志，不做别的
  25.         pass

这个实现有一个附加优势，在于比嵌套函数的方式更加整洁，而且包裹一个函数还是使用跟以前一样的语法：

  1. logit._logfile = 'out2.log' # 如果需要修改log文件参数
  2. @logit
  3. def myfunc1():
  4.     pass
  6. myfunc1()
  7. # 输出: myfunc1 was called

现在，我们给logit创建子类，来添加email的功能(虽然email这个话题不会在这里展开)。

  1. class email_logit(logit):
  2.     '''
  3.     一个logit的实现版本，可以在函数调用时发送email给管理员
  4.     '''
  5.     def __init__(self, func, email='admin@myproject.com', *args, **kwargs):
  6.         self.email = email
  7.         super(email_logit, self).__init__(func, *args, **kwargs)
  9.     def notify(self):
  10.         # 发送一封email到self.email
  11.         # 这里就不做实现了
  12.         pass

从现在起，@email_logit 将会和 @logit 产生同样的效果，但是在打日志的基础上，还会多发送一封邮件给管理员。

  1. email_logit._logfile = 'out3.log' # 如果需要修改log文件参数
  2. @email_logit
  3. def myfunc2():
  4.     pass
  6. myfunc2()
  7. # 输出: myfunc2 was called