Python3中的装饰器

一.装饰器

 @dec  def func():  # 被装饰对象   pass 

• 2.几个重要的原则和概念
  • a.python该程序从上到下执行。当遇到函数定义代码块时，不会立即执行，而是将其放入内存中。当此函数被调用时，函数中的代码块将开始执行。
  • b.因为程序是按顺序执行的，所以当我们定义一个函数两次时。然后，后面的定义将覆盖前面的定义。所以，在python中代码的位置不同，不能随意放置。通常，函数体应该放在调用句的前面。

   def foo():   print("第一次定义foo()函数")    def foo():   print("第二次定义foo()函数")  foo()  # 结果  第二次定义foo()函数 

  • c.找出以下概念：函数名、函数体、返回值、函数内存地址、函数名加括号、函数名加括号、函数名加括号、返回函数名、返回函数名加括号

   def outer(func):   def inner():    print("内层函数inner()")   return inner    def foo():   print("原始函数foo()")    outer(foo)  outer(foo()) 

  • 函数名：foo、outer、inner
  • 函数体：函数的整个代码结构
  • 返回值：return后面的表达式
  • 函数内存地址：id(foo)、id(outer)等
  • 函数名加括号：调用函数foo()、outer(foo)
  • 函数名作为参数：outer(foo)中foo它本身是一个函数，但作为参数传递给它outer函数
  • 函数名加括号作为参数：首先调用函数，然后将其返回值作为其他函数的参数，例如outer(foo())
  • 返回函数名：return inner
  • 返回函数名加括号：return inner()其实是先执行的。inner()函数，然后将其返回值作为其他函数的返回值。
• 3.装饰函数
  • 虚拟场景：有一家大公司，下属基础平台部负责内部应用程序和API开发。此外，数百个业务部门负责不同的业务。这些业务部门调用基本平台部提供的不同业务API，情况如下：

   # 基础平台部负责内部应用程序和API的开发  def f1():   print("业务部1的数据接口")  def f2():   print("业务部2的数据接口")  def f3():   print("业务部门3的数据接口")  def f100():   print("业务部100数据接口")  # 业务部门调用各自的API f1() f2() f3() f100() 

  • 现在基础平台部分决定为函数调用进行安全认证，第一种方法是重构基础平台部门的代码，N业务部门不需要做任何修改。这种方法不好，工作量太大！

  # 基础平台部负责内部应用程序和API的开发  def f1():   # 添加认证程序代码   print("业务部1的数据接口")  def f2():   # 添加认证程序代码   print("业务部2的数据接口")  def f3():   # 添加认证程序代码   print("业务部门3的数据接口")  def f100():   # 添加认证程序代码   print("业务部门100的数据接口")  # 业务部门调用各自的API f1() f2() f3() f100() 

  • 第二种方法：定义一个认证函数，并在其他原始函数中调用，代码如下：

  def login():  print("认证成功")  # 基础平台部负责内部应用程序和API的开发  def f1():   login()   print("业务部1的数据接口")  def f2():   login()   print("业务部2的数据接口")  def f3():   login()   print("业务部门3的数据接口")  def f100():   login()   print("业务部100数据接口")  # 业务部门调用各自的API f1() f2() f3() f100() 

  • 第三种方法：在第二种方法中，代码不遵循开放和封闭的原则。即已实现的功能代码内部不允许修改，但外部可以扩展。如果在上述需求中应用开放和封闭的原则，则不允许函数f1、f2、…、f100内部修改代码，但可以在外部扩展。代码如下:

   def outer(func):   def inner():    print("认证成功")    result = func()    print("成功添加日志")    return result   return inner # 基础平台部负责内部应用程序和API的开发  @outer  def f1():   print("业务部1的数据接口")  @outer  def f2():   print("业务部2的数据接口")  @outer  def f3():   print("业务部门3的数据接口")  @outer  def f100():   print("业务部100数据接口")  # 业务部门调用各自的API f1() f2() f3() f100() 

  • 使用装饰器@outer，在其他部门调用函数只需要扩展基础平台的代码API之前进行认证操作，操作后保存日志，其他业务部门不需要修改自己的代码，调用方式也不需要改变。
• 4.装饰器机制分析
• 下面以f以函数为例，分析装饰器的运行机制：

 def outer(func):  # 装饰函数      def inner():          print("认证成功！")          result = func()          print("成功添加日志")          return result      return inner   @outer  def f1():  # 被装饰函数      print("业务部1数据接口...") 

• a.程序开始运行，从上到下解释。def outer(func)时，发现这是一个函数的定义，将其函数体放入内存中，然后跳过。
• b.跳到@outer时，程序被@这个python语法糖被吸引，知道这是一个装饰，按照规则立即执行，所以程序开始运行@后面的名字outer定义函数。
• c.程序返回到outer开始执行装饰器语法规则的函数。规则是：装饰函数的名称将作为函数形参传递给装饰函数。装饰函数执行其内部代码后，将其返回值赋予装饰函数。原来f函数作为参数传递给1函数func，而f这个函数名将指向inner函数。 注意：@outer和outer()有区别。没有括号，outer函数将立即执行。这种传统的括号可以调用不同的函数。
• d.程序开始执行outer一开始，函数内部的内容遇到了另一个函数inner，inner程序观察到函数定义块后，不会立即执行，而是读入内存(这是默认规则)。
• e.再往下走，遇见return inner，返回值是函数名，该函数名将被赋值f1这个装饰函数，即f1 = inner。此时，f函数是新函数inner覆盖了（实际上是f这个函数名改为指向inner函数名指向函数体内存地址，f1不再指向其原函数体的内存地址），再往后调用f将在1时执行inner代码在函数中，而不是以前的函数体。那以前的函数体去哪了？还记得我们会f1作为参数传递func这个形参吗？func这个变量保存了内存中旧函数的地址，旧函数体可以通过它执行，你可以inner函数里看到result = func()这个代码，就是这么做的！
• f.接下来，还没有结束。当业务部门仍然通过时，f1()调用方式f1函数时，执行的不再是旧的f代码1函数，但是inner函数代码。在这种情况下，它首先会打印一个认证成功的提示，显然你可以用任何代码代替，这只是一个例子；然后，它将执行func函数并将返回值赋值给变量result，这个func函数是旧的f1函数；然后，它打印了日志添加成功的提示，这只是你想要的任何东西的例子；最后返回result这个变量。我们可以使用业务部门的代码r = f1()接收方式result的值。
• g.完成上述流程后，您应该看到，在没有修改业务部门的代码和接口调用方法的同时，也没有修改基本平台部门的原始代码码做内部修改，仅仅是添加了一个装饰函数，就实现了我们的需求，在函数调用前进行认证，调用后写入日志。这就是装饰器的最大作用。
• 4.上面的例子中，f1函数没有参数，在实际情况中肯定会需要参数的，函数的参数怎么传递的呢？

def outer(func):
	def inner(username):
		print("认证成功")
		result = func(username)
		print("日志添加成功")
		return result
	return inner
@outer
def f1(name):
	print("{}正在调用业务部门1的数据接口".format(name))
# 调用方法
f1("Jack")

• 在inner函数的定义部分也加上一个参数，调用func函数的时候传递这个参数，很好理解吧？可问题又来了，那么另外一个部门调用的f2有2个参数呢？f3有3个参数呢？你怎么传递？很简单，我们有*args和**kwargs嘛！号称“万能参数”！简单修改一下上面的代码：

def outer(func):
	def inner(*args, *kwargs):
		print("认证成功")
		result = func(*args, **kwargs)
		print("日志添加成功")
		return result
	return inner
@outer
def f1(name, age):
	print("{}正在调用业务部门1的数据接口".format(name))
# 调用方法
f1("jack", 19)

• 一个函数可以被多个函数装饰吗？可以的！看下面的例子:

	def outer1(func):
    def inner(*args,**kwargs):
        print("认证成功！")
        result = func(*args,**kwargs)
        print("日志添加成功")
        return result
    return inner


def outer2(func):
    def inner(*args,**kwargs):
        print("一条欢迎信息。。。")
        result = func(*args,**kwargs)
        print("一条欢送信息。。。")
        return result
    return inner


@outer1
@outer2
def f1(name,age):
    print("%s 正在连接业务部门1数据接口......"%name)

# 调用方法
f1("jack",18)

• 更进一步，装饰器自己可以有参数吗？可以的！看下面的例子：

	# 认证函数
	def  auth(request,kargs):
	    print("认证成功！")
	    
	# 日志函数
	def log(request,kargs):
	    print("日志添加成功")
	    
	# 装饰器函数。接收两个参数，这两个参数应该是某个函数的名字。
	def Filter(auth_func,log_func):
	    # 第一层封装，f1函数实际上被传递给了main_fuc这个参数
	    def outer(main_func):
	        # 第二层封装，auth和log函数的参数值被传递到了这里
	        def wrapper(request,kargs):
	            # 下面代码的判断逻辑不重要，重要的是参数的引用和返回值
	            before_result = auth(request,kargs)
	            if(before_result != None):
	                return before_result;
	
	            main_result = main_func(request,kargs)
	            if(main_result != None):
	                return main_result;
	
	            after_result = log(request,kargs)
	            if(after_result != None):
	                return after_result;
	        return wrapper
	    return outer
	# 注意了，这里的装饰器函数有参数哦，它的意思是先执行filter函数。然后将filter函数的返回值作为装饰器函数的名字返回到这里。所以，Filter(auth,log) = outer , @Filter(auth,log) =  @outer
	@Filter(auth,log)
	def f1(name,age):
	    print("%s 正在连接业务部门1数据接口......"%name)
	
	# 调用方法
	f1("jack",18)

二.参考博客