python7：装饰器

目录

• 1.调用外部程序
• • os.system-阻塞式调用
  • subprocess-python中的模块
  • 2.装饰器前戏
  • • 作用域
    • • （1）全局和局部-就近原则
      • （2）嵌套作用域
      • （3）内置作用域、变量
      • 高阶函数：函数是最高级的对象
      • • （1）函数名可以被赋值给其他对象
        • （2）函数名当作参数传递
        • （3）函数名可以作为返回值
        • 闭包
        • 3.装饰器高阶
        • • 测试任务
          • 装饰器概念

            1.调用外部程序

            os.system-阻塞式调用

            import os
            #打开操作系统,可以输入命令
            os.system("ipconfig")
            retCode=os.system("mspaint")
            print("retCode",retCode)
            print("after")
            

            画板打开并关闭后，才执行下一步打印操作

            

            subprocess-python中的模块

            subprocess.check_output：以字节形式返回，不能直接打印到控制台

            subprocess.Popen：非阻塞式的，可以直接打印到控制台

            import subprocess
            #执行命令，将结果以字节形式返回，bytes
            output_bytes=subprocess.check_output("ipconfig")
            print(output_bytes.decode("gbk"))
            print("=======after=========")#解码转为人能看懂的语言，mac写utf-8,windows写gbk
            subprocess.Popen("ipconfig")
            print("=========after================")
            

            

            2.装饰器前戏

            作用域

            #解决Non-utf-8问题，在python代码最前面放这几行代码

            Python file uses the following encoding: utf-8
            

            （1）全局和局部-就近原则

            先在自己这一层找

            当局部变量和全局变量重名时：

            • 在局部作用域使用该变量，则使用局部变量
            • 在全局使用时，使用的是全局。

              # This Python file uses the following encoding: utf-8
              b = 99#全局变量
              def foo():
                  a=100#局部变量
                  print(a)
                  print(b)#局部作用域使用全局变量，可以
              foo()
              # print(a)#在全局使用局部变量，报错
              print(b)# 全局作用域使用全局变量，可以
              

              

              （2）嵌套作用域

              # This Python file uses the following encoding: utf-8
              b = 99#全局变量
              def foo():
                  a=100#局部变量
                  print(a)
                  print(b)#局部作用域使用全局变量，可以
                  def bar():
                      c=21#嵌套局部变量
                      print("嵌套==",a,b,c)#嵌套作用域引用局部变量和全局变量
                  bar()
                //  print(c)#局部引用内置嵌套局部变量，报错
              foo()
              # print(a)#在全局使用局部变量，报错
              print(b)# 全局作用域使用全局变量，可以
              

              

              （3）内置作用域、变量

              系统内固定模块里预先定义好的变量：

              name

              os模块里的变量

              

              高阶函数：函数是最高级的对象

              （1）函数名可以被赋值给其他对象

              def foo():
                  print("我是一个函数对象")
              a=foo#将函数对象赋给变量，a就具有了函数foo的特征
              print(a)
              b=foo()#调用函数，并将函数foo的返回值赋给变量b,b就等于foo的返回值
              print(b)
              

              

              （2）函数名当作参数传递

              def foo1(func):
                  func()
              def bar():
                  print("123")
              foo1(bar)
              

              

              （3）函数名可以作为返回值

              #函数名可以作为返回值
              def foo():
                  def bar():
                      print("过年啦")
                  return bar
              a=foo()
              a()
              

              

              闭包

              在一个内部函数里边，对在外部作用域（但不是全局作用域）的变量进行引用，那么这个内部函数就被认为是闭包

              

              #闭包
              def outer():
                  x=10
                  def inner():
                      print(x)
                  return inner
              a=outer()
              a()
              

              3.装饰器高阶

              测试任务

              装饰器概念

              为已经存在的对象添加额外的功能

              

              

              import time
              #原本逻辑
              def foo():
                  print("执行了一些测试逻辑")
                  time.sleep(1)
              #新增计时逻辑
              def show_time(func):
                  def inner():
                      begin_time=time.time()
                      func()
                      end_time=time.time()
                      print("用例执行时间==",end_time-begin_time)
                  return inner
              foo=show_time(foo)
              foo()
              

              

              foo被装饰函数，show_time是装饰器（装饰函数），python提供了语法糖，在被装饰函数上@装饰器，这样就不用赋值了每次

              import time
              #新增计时逻辑
              def show_time(func):
                  def inner():
                      begin_time=time.time()
                      func()
                      end_time=time.time()
                      print("用例执行时间==",end_time-begin_time)
                  return inner
              #原本逻辑
              @show_time
              def foo():
                  print("执行了一些测试逻辑")
                  time.sleep(1)
              # 省去了赋值的步骤，在外部看来相当于直接调用原函数
              foo()