码迷,mamicode.com
首页 > 编程语言 > 详细

python 闭包 装饰器

时间:2019-08-17 10:57:57      阅读:101      评论:0      收藏:0      [点我收藏+]

标签:保存   结果   pytho   closure   使用   调用   span   对象   lin   

闭包

1. 什么是闭包

  • 在 python 中创建一个闭包一般有3个要求:
    • (1)闭包函数必须有内嵌函数
    • (2)内嵌函数必须要引用外层函数的变量
    • (3)闭包函数返回内嵌函数的地址(函数名称)
  • 作用:可以在不修改目标源码的前提下,加功能
  • 注意:闭包函数中的变量的生命周期得到延长

2. 创建一个闭包函数

def funcOut():
    name = ‘Jery‘
        
    def funcIn():
        # format的简写方式
        print(f"姓名 = {name}")
    return funcIn
    
f = funcOut()
f()

 运行结果:

姓名 = Jery

  

3. 判断是否为闭包函数

  • 闭包函数相对与普通函数会多出一个__closure__的属性,里面定义了一个元组用于存放所有的cell对象,每个cell对象保存了这个闭包中所有的外部变量。
  • funcIn.__closure__:返回None,则不是闭包函数
  • 如:
    def funcOut():
        name = ‘Jery‘
        def funcIn():
            print(f"姓名 = {name}")
        print(funcIn.__closure__)
        print(funcIn.__closure__[0].cell_contents)  # 第一个外部变量
        return funcIn
    
    f = funcOut()
    f()
    

    运行结果

    (<cell at 0x000000000272F8B8: str object at 0x00000000026A08B8>,)
    Jery
    姓名 = Jery
    

    装饰器

    1. 本质及作用

    • 装饰器的本质
      • 闭包函数
    • 装饰器的作用:
      • 在不修改原函数及其调用方式的情况下对原函数功能进行扩展

    2. 装饰器的使用

  • 需求:为现有功能fun1增加日志功能
    • 传统方案解决 —— 使用闭包
       def writeLog(fn):
            print("记录日志")
            print(‘访问方法:‘+fn.__name__)
      
        def funcOut(func):
            def funcIn():
                writeLog(func)
                func()
            return funcIn
            
        def fun1():
            print("使用功能1")
            
        def fun2():
            print("使用功能2")
        
        fun1 = funcOut(fun1)
        # 装饰器(闭包)
        fun1()
      
    • 运行结果:

      记录日志
      访问方法:fun1
      使用功能1 
    • 使用装饰器(语法糖)解决 

        def writeLog(fn):
            print("记录日志")
            print(‘访问方法:‘+fn.__name__)
        
        def funcOut(func):
            def funcIn():
                writeLog(func)
                func()
            return funcIn
        
        @funcOut
        def fun1():
            print("使用功能1")
        @funcOut
        def fun2():
            print("使用功能2")
        
        fun1()
        fun2()
      

      运行结果: 

      记录日志
      访问方法:fun1
      使用功能1
      记录日志
      访问方法:fun2
      使用功能2 

3. 多个装饰器的使用

    • 如:

    • def war1(func):
          print("war 1")
      
          def inner(*args, **kwargs):
              print("======war1 start=====")
              func(*args, **kwargs)  # inner
              print("======war1 end=====")
              return inner
      
      def war2(func):
          print("war2")
      
          def inner(*args, **kwargs):
              print("======war2 start=====")
              func(*args, **kwargs)
              print("======war2 end=====")
          return inner
      
      @war1
      @war2
      def f():
          print("****self****")
      
      f()

    • 运行结果:
      war2
      war1
      ======war1 start=====
      ======war2 start=====
      ****self****
      ======war2 end=====
      ======war1 end=====  
    • 解释:
      (1)
      @war1
      @war2 之后相当于 --> f = war1(war2(f))
      其中war2(f)是一个函数,作为实参传递
      war2(f):
        print("======war2 start=====")
        print("****self****")
        print("======war2 end=====")
      
      war1(war2(f)):
        print("======war1 start=====")
        war2(f)
        print("======war1 end=====")
      (2)
      f() 相当于执行 --> war1(war2(f))() 

  4. 对有参数的函数进行装饰

    • def funcOut(fn):
          print("funcOut")
          def funcIn(aa, bb):
              print("funcIn1")
              fn(aa,bb)
              print("funcIn2")
          return funcIn
      
      @funcOut
      def test(a, b):
          print("a=%d,b=%d" % (a, b))
      # 装饰器装饰之后,这不是直接调用test方法,而是调用func_in方法
      test(1,2)
      

       结果

    • funcOut
      funcIn1
      a=1,b=2
      funcIn2

  5. 通用装饰器的使用

    • 一个装饰器可以装饰多个不同参数、不同返回值的函数
    • 如:
         def funcOut(fn):
              # 需要有参数,*args,**kwargs
              def funcIn(*args,**kwargs):
                  print("记录日志")
                  print(‘访问方法:‘+fn.__name__)
                  # 需要有参数,*args,**kwargs
                  # 需要有返回值
                  return fn(*args,**kwargs)
              return funcIn
          
          # 待装饰函数1:无参数,无返回值
          @funcOut
          def test1():
              print("test1")
          test1()
          print("---------")
          # 待装饰函数2:无参数,有返回值
          @funcOut
          def test2():
              return "Hello"
          print(test2())
          print("---------")
          # 待装饰函数3:有参数,无返回值
          @funcOut
          def test3(a):
              print(‘a=%d‘%a)
          test3(1)
          print("---------")
          # 待装饰函数3:有键值对参数,无返回值
          @funcOut
          def test4(**kwargs):
              print(kwargs)
          test4(a=1)
    • 结果
      记录日志
      访问方法:test1
      test1
      ---------
      记录日志
      访问方法:test2
      Hello
      ---------
      记录日志
      访问方法:test3
      a=1
      ---------
      记录日志
      访问方法:test3
      {a: 1}

       

 

 

      

  

 

python 闭包 装饰器

标签:保存   结果   pytho   closure   使用   调用   span   对象   lin   

原文地址:https://www.cnblogs.com/songdanlee/p/11367571.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!