欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python — 装饰器、迭代器

程序员文章站 2023-11-14 21:29:58
[TOC] 1 装饰器 1.1目的、应用场景: 目的: 在不改变原函数内部代码的基础上,在函数执行前后自定义功能。 应用场景: 想要为函数扩展功能时,可以选择用装饰器。 1.2 编写装饰器和应用 1. 基本装饰器 练习题 注:问题:为什么要加 arg、 kwarg 理解: 变量赋值 看看到底retu ......

目录

1 装饰器

1.1目的、应用场景:

  • 目的:

    在不改变原函数内部代码的基础上,在函数执行前后自定义功能。

  • 应用场景:

    想要为函数扩展功能时,可以选择用装饰器。

1.2 编写装饰器和应用

    1. 基本装饰器

      # 装饰器的编写格式     (双层嵌套函数)
      def 外层函数(参数):
         def 内层函数(*arg,**kwarg)
             return 参数(*arg,**kwarg)
         return 内层函数
      
      #装饰器的应用格式
      @外层函数
      def 要装饰的函数()
         pass
      
      # 执行函数,自动触发装饰器了
      要装饰的函数()

      练习题

      def func(arg):
          def inner():
              print('before')
              v = arg()
              print('after')
              return v 
          return inner 
      
      def index():
          print('123')
          return '666'
      
      
      # 示例一
      v1 = index() # 执行index函数,打印123并返回666赋值给v1.
      
      # 示例二
      v2 = func(index) # v2是inner函数,arg=index函数
      index = 666 
      v3 = v2()
      
      # 示例三
      v4 = func(index)
      index = v4  # index ==> inner 
      index()
      
      # 示例四
      index = func(index)
      index()
      def func(arg):
          def inner():
              v = arg()
         return v 
          return inner 
      
      # 第一步:执行func函数并将下面的函数参数传递,相当于:func(index)
      # 第二步:将func的返回值重新赋值给下面的函数名。 index = func(index)
      @func 
      def index():
          print(123)
          return 666
      
      print(index)
      # 计算函数执行时间
      
      def wrapper(func):
        def inner():
              start_time = time.time()
              v = func()
              end_time = time.time()
              print(end_time-start_time)
              return v
          return inner
      
      @wrapper
      def func1():
          time.sleep(2)
          print(123)
      @wrapper
      def func2():
          time.sleep(1)
          print(123)
      
      def func3():
          time.sleep(1.5)
          print(123)
      
      func1()

      注:问题:为什么要加*arg、**kwarg

      理解:

  • 变量赋值

    ```python
    def func():
    print(1)

    v1 = func
    func = 666
    ```

    • 看看到底return的是什么?

    • 自己有找自己的,自己没有到上一级作用域去找

背会:

python @xx # index = xx(index) def index(): pass index()

    1. 关于参数

      def x(func):
          def inner(a1):
              return func(a1)
          return inner 
      
      @x
      def index(a1):
         pass
      def x(func):
          def inner(a1,a2):
              return func(a1,a2)
          return inner 
      
      @x
      def index(a1,a2):
         pass
      
      # index = inner
      index(1,2)
      
      # ################################### 参数统一的目的是为了给原来的index函数传参
      def x(func):
          def inner(a1,a2):
              return func()
          return inner 
      
      @x
      def index():
         pass
      # func = 原来的index函数u
      # index = inner
      index(1,2)

      如果给好几个函数写一个统一的装饰器,怎么办?

      def x1(func):
          def inner(*args,**kwargs):
              return func(*args,**kwargs)
          return inner 
      
      @x1
      def f1():
          pass
      
      @x1
      def f2(a1):
          pass
      @x1
      def f3(a1,a2):
          pass 

      装饰器建议写法:

      def x1(func):
          def inner(*args,**kwargs):
              data = func(*args,**kwargs)
              return data
          return inner 
    1. 带参数的装饰器

      # 第一步:执行 v1 = uuu(9)
      # 第二步:ret = v1(index)
      # 第三步:index = ret 
      @uuu(9)
      def index():
          pass
      # ################## 普通装饰器 #####################
      def wrapper(func):
          def inner(*args,**kwargs):
              print('调用原函数之前')
              data = func(*args,**kwargs) # 执行原函数并获取返回值
              print('调用员函数之后')
              return data
          return inner 
      
      @wrapper
      def index():
          pass
      
      # ################## 带参数装饰器 #####################
      def x(counter):
          def wrapper(func):
              def inner(*args,**kwargs):
                  data = func(*args,**kwargs) # 执行原函数并获取返回值
                  return data
              return inner 
         return wrapper 
      
      @x(9)
      def index():
          pass

      练习题

      # 写一个带参数的装饰器,实现:参数是多少,被装饰的函数就要执行多少次,把每次结果添加到列表中,最终返回列表。
      def xxx(counter):![](https://img2018.cnblogs.com/blog/1646753/201907/1646753-20190719213053775-1588807446.png)
      
      
          print('x函数')
          def wrapper(func):
              print('wrapper函数')
              def inner(*args,**kwargs):
                  v = []
                  for i in range(counter):
                      data = func(*args,**kwargs) # 执行原函数并获取返回值
                      v.append(data)
                  return v
              return inner
          return wrapper
      
      @xxx(5)
      def index():
          return 8
      
      v = index()
      print(v)
      
      # 写一个带参数的装饰器,实现:参数是多少,被装饰的函数就要执行多少次,并返回最后一次执行的结果
      def xxx(counter):
          print('x函数')
          def wrapper(func):
              print('wrapper函数')
              def inner(*args,**kwargs):
                  for i in range(counter):
                      data = func(*args,**kwargs) # 执行原函数并获取返回值
                  return data
              return inner
          return wrapper
      
      @xxx(5)
      def index():
          return 8
      
      v = index()
      print(v)
      # 写一个带参数的装饰器,实现:参数是多少,被装饰的函数就要执行多少次,并返回执行结果中最大的值。
      def xxx(counter):
          print('x函数')
          def wrapper(func):
              print('wrapper函数')
              def inner(*args,**kwargs):
                  value = 0
                  for i in range(counter):
                      data = func(*args,**kwargs) # 执行原函数并获取返回值
                      if data > value:
                          value = data 
                  return value
              return inner
          return wrapper
      
      @xxx(5)
      def index():
          return 8
      
      v = index()
      print(v)
      def x(counter):
          print('x函数')
          def wrapper(func):
              print('wrapper函数')
              def inner(*args,**kwargs):
                  if counter:
                      return 123
                  return func(*args,**kwargs)
              return inner
          return wrapper
      
      @x(true)
      def fun990():
          pass
      
      @x(false)
      def func10():
          pass

2 迭代器

自己不会写迭代器,只需要会用。

任务:请展示列表中所有的数据

    1. while + 索引 + 计数器

    2. 迭代器,对 某种对象(str/list/tuple/dict/set类创建的对象)-可迭代对象中的元素进行逐一获取

      表象:具有_ _ next _ _方法且每次调用都获取可迭代对象中的元素(从前到后一个一个获取)。

        1. 先将某对象(如列表)转换成迭代器

          v1 = iter([11,22,33,44])

          v1 = [11,22,33,44]_ _ iter _ ()

        2. 迭代器想要获取每个值:反复调用(val = v1._ _ next _ _())

          v1 = [11,22,33,44]
          
          # 列表转换成迭代器
          v2 = iter(v1)
          result1 = v2.__next__()
          print(result1)
          result2 = v2.__next__()
          print(result2)
          result3 = v2.__next__()
          print(result3)
          result4 = v2.__next__()
          print(result4)
          result5 = v2.__next__()   # v1只有4个元素,第五次获取就会报错:stopiteration
          print(result5)
          
          v1 = "alex"
          v2 = iter(v1)
          while true:
              try:
                  val = v2.__next__()
                  print(val)
              except exception as e:
                  break
        3. 直到报错:stopiteration错误,表示已经迭代完毕。

          python — 装饰器、迭代器

        4. 如何判断一个对象是否是可迭代对象:内部是否有_ _ next _ _方法。

    3. for循环:

      v1 = [11,22,33,44]
      
      # 1.内部会将v1转换成迭代器
      # 2.内部反复执行 迭代器.__next__()
      # 3.取完不报错
      for item in v1:
          print(item)

3 可迭代对象

    1. 内部具有_ _ iter _ _()方法且返回一个迭代器

      v1 = [11,22,33,44]
      result = v1.__iter__()
    2. 可以被for循环的