笔记20210513迭代生成装饰器

笔记

1. 迭代器

   1. 什么是迭代器（iter）

      1. 迭代器是容器型数据类型（序列），无法直接获取所有元素，也不能统计元素个数
      2. 获取迭代器中的元素，会导致这个元素从迭代器中消失。（元素取一个就少一个）

   2. 创建迭代器

      1. 将其他序列转换成迭代器——iter(序列)

         iter1 = iter(['abc', '123'])
         iter2 = iter([1, 2, 3])
         print(iter1)
         print(iter2)
         

      2. 创建生成器

   3. 获取迭代器中元素

      1. 获取单个函数——next(迭代器)

         print(next(iter1))  # abc
         print(next(iter1))  # 123
         # print(next(iter1))  # StopIteration
         print(next(iter2))
         print(next(iter2))
         print(next(iter2))
         

      2. 遍历

         iter3 = iter([1, 2, 3])
         for x in iter3:
             print(x)
         

2. 生成器

   生成器从获取数据和保存数据特点来看，就是迭代器
   生成器保存数据的本质不是保存数据本身，而是保存产生数据的算法。

   1. 创建生成器

      1. 调用带有yield关键字的函数就可以得到一个生成器(yield可以在函数内部任何位置)

         def func1():
             yield
             print('===')
             return 100
         print(func1())
         

      2. 调用带有yield关键字的函数时，不会执行函数体，也不会获取函数返回值，只是单纯的创建一个生成器

         def func1():
             # yield  # 可以在任何位置
             print('===')
             return 100
             yield
         list1 = func1()
         print(list1)
         print(list(list1))
         

   2. 确定生成器的元素——也就是生成器可以创造的数据

      1. 一个生成器能产生多个数据就看这个生成器对应的函数，执行完函数能够遇到几次yield。
         每次遇到yield的时候，yield后面的数据就是产生的数据
         return后边的yield没有意义

         def func3():
             print('111111111111')
             yield 100
             print('222222222222')
             yield 200
             print('333333333333')
             yield 300
             print('444444444444')
         
         
         result = func3()
         print(next(result))     # 111111111111      100
         print(next(result))     # 222222222222      200
         print(next(result))     # 333333333333      300
         print(next(result))     # 444444444444      StopIteration
         
         
         def func5():
             yield 10
             yield 20
             yield 30
         
         
         print(next(func5()))        # 10
         print(next(func5()))        # 10
         print(next(func5()))        # 10
         
         result = func5()
         print(next(result))        # 10
         print(next(result))        # 20
         print(next(result))        # 30
         
         写一个创建学生学号的生成器，要求产生的学号前缀是python，后面是指定范围的值
         def study_num(subject='python', start=26, end=56):
         

   for x in range(start, end+1):
   yield f’{subject}{str(x).zfill(4)}’

     creater = study_num('java', 1, 50)
     print(next(creater))
     ```
   

3. 装饰器

   1. 什么是装饰器

      装饰器 = 实参高阶函数 + 返回值高阶函数 + 糖语法 ——本质是函数
      作用：给已经定义好的函数定义功能

   2. 无参装饰器的实现方法

      1. 装饰器的工作原理：将需要添加功能的函数传给装饰器，装饰器创建一个保留原函数功能并且添加新功能的一个新函数，将添加完功能的新函数返回，最后将新函数替换原函数

      2. 装饰器创建格式：

         def 函数1(原函数：function):
                def 函数2(*args, **kwargs):
                    添加新功能
                    result = 原函数(*args, **kwargs)
                    return result
                return 函数2 
         函数1——装饰器名称（根据装饰器功能来命名） 
         原函数——类型是function,指向需要添加功能的原函数，习惯命名成：fn
         函数2——指向添加完功能的新函数，习惯命名：new_fn
         
                 def 装饰器名称(fn):
                     def new_fn(*args, **kwargs):
                         添加新功能
                         result = fn(*args, **kwargs)
                         return result
                     return new_fn 
         
                 
         # 写一个装饰器，能够在函数调用结束的时候打印'end'
         def add_end_message(fn):
             def new_fn(*args, **kwargs):
                 result = fn(*args, **kwargs)
                 print('end')
                 return result
             return new_fn
         
         
         @add_end_message
         def func3(num: int):
             sum1 = 1
             for x in range(1, num+1):
                 sum1 *= x
             return sum1
         # end    24
         
         

4. 递归

   1. 递归函数

      1. 定义函数的时候调用函数本身，这种函数就是递归函数

      2. 理论上：循环能做的事情，递归都能做。（能用循环实现的就不要用递归）

         def fn():
             print('hello')
             fn()
         

      3. 使用递归套路

         1. 找临界值，在临界值的位置结束函数（相当于循环结束条件）

         2. 找关系，招上一次循环结束的结果和当次循环结束的结果的关系（f(n)和f(n-1)的关系）

         3. 假设函数功能已经全部实现，通过关系用f(n-1)和f(n)的功能

            # fn()
            # 计算：1+2+3+...+100
            # 一、递归方法
            def sum1(n):
                # 临界值
                if n == 1:
                    return 1
                return sum1(n-1) + n
            
            
            print(sum1(100))
            
            
            # 1,1,2,3,5,8,13,...
            def num(n):
                if n == 1 or n == 2:
                    return 1
                return num(n-2) + num(n - 1)
            
            
            print(num(6))
            

         4. 注意：使用递归解决问题的时候，内存和CPU的消耗会随着循环次数的增加而不断增加