day12

一.今日内容大纲

• 1. 毒鸡汤课

     坚持努力。

  2. 生成器

     • yield

     • yield return

     • yield from

  3. 生成器表达式，列表推导式

  4. 内置函数 I

二.昨日内容回顾作业讲解

• 1. 可迭代对象：

     • 可以更新迭代的实实在在值。

     • 内部含有'__iter__'方法的。

     • str list tuple dict set range

     • 优点：操作方法多，操作灵活，直观，

     • 缺点：占用内存。

  2. 迭代器：

     • 可以更新迭代的一个工具（数据结构）。

     • 内部含有'__iter__'``且含有__next__方法的的。

     • 文件句柄。

     • 优点：节省内存。惰性机制。

     • 缺点：不直观，速度相对慢，操作方法单一，不走回头。

  3. 格式化输出。

  4. 函数名的应用。

  5. 默认参数可变的数据类型坑。作用域的坑。

三.具体内容

• • 生成器

    • 生成器：python社区，生成器与迭代器看成是一种。生成器的本质就是迭代器。唯一的区别：生成器是我们自己用python代码构建的数据结构。迭代器都是提供的，或者转化得来的。

      • 获取生成器的三种方式：

        • 生成器函数。

        • 生成器表达式。

        • python内部提供的一些。

    • 生成器函数获得生成器：

    函数
    def func():
        print(111)
        print(222)
        return 3
    ret = func()
    print(ret)
    
    生成器函数
    def func():
        print(111)
        print(222)
        yield 3
        a = 1
        b = 2
        c = a + b
        print(c)
        yield 4
    ret = func()
    # print(ret)
    print(next(ret))
    print(next(ret))
    print(next(ret))
    一个next 对应一个yield

    • yield return

      return：函数中只存在一个return结束函数，并且给函数的执行者返回值。 yield：只要函数中有yield那么它就是生成器函数而不是函数了。生成器函数中可以存在多个yield，yield不会结束生成器函数，一个yield对应一个next。

    • 吃包子练习题：

      def func():
          l1 = []
          for i in range(1,5001):
              l1.append(f'{i}号包子')
          return l1
      ret = func()
      print(ret)
      
      def gen_func():
          for i in range(1,5001):
              yield f'{i}号包子'
      ret = gen_func()
      # [3号包子.]
      for i in range(200):
          print(next(ret))
      
      for i in range(200):
          print(next(ret))

    • yield from

      def func():
          l1 = [1, 2, 3, 4, 5]
          yield l1
      ret = func()
      print(next(ret))
      
      
      
      def func():
          l1 = [1, 2, 3, 4, 5]
          yield from l1
          '''
          yield 1
          yield 2
          yield 3
          yield 4
          yield 5
          '''
          将l1这个列表变成了迭代器返回。
      ret = func()
      print(next(ret))
      print(next(ret))
      print(next(ret))
      print(next(ret))
      print(next(ret))

  • 生成器表达式，列表推导式

    • 用一行代码构建一个比较复杂有规律的列表。

    • # 用一行代码构建一个比较复杂有规律的列表。
      # l1 = []
      # for i in range(1,11):
      #     l1.append(i)
      # print(l1)
      # 列表推导式
      # l1 = [i for i in range(1,11)]
      # print(l1)

    • 列表推导式：

      • 循环模式：[变量(加工后的变量) for 变量 in iterable]

      • 筛选模式：[变量(加工后的变量) for 变量 in iterable if 条件]

    • # 列表推导式分两类
      # 循环模式：
      # 循环模式：[变量(加工后的变量) for  变量  in  iterable]
      # 将10以内所有整数的平方写入列表。
      # ret = [i**2 for i in range(1,11)]
      # print(ret)
      # # 100以内所有的偶数写入列表.
      # print([i for i in range(2, 101, 2)])
      
      # 从python1期到python100期写入列表lst
      # print([f'python{i}期' for i in range(1,101)])
      
      # 筛选模式
      # 筛选模式：[变量(加工后的变量) for  变量  in  iterable if 条件]
      # 30以内能被3整除的数
      # l1 = [i for i in range(1,31) if i%3 == 0]
      # print(l1)
      # 过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母
      # l1 = ['barry', 'ab', 'alex', 'wusir', 'xo']
      # print([i.upper() for i in l1 if len(i) >= 3 ])
      
      # 含有两个'e'的所有的人名全部大写留下来
      names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
               ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
      l1 = []
      for i in names:
          for name in i:
              if name.count('e') == 2:
                  l1.append(name)
      print(l1)
      print([name.upper() for i in names for name in i if name.count('e') == 2])
      
      # 生成器表达式：
      # 与列表推导式的写法几乎一模一样,也有筛选模式，循环模式，多层循环构建。写法上只有一个不同：
      # [] 换成 ().
      # print([i for i in range(1,11)])
      # print((i for i in range(1,11)))
      # obj = (i for i in range(1,11))
      # print(next(obj))
      # print(next(obj))
      # print(next(obj))
      # print(next(obj))
      # print(next(obj))
      # for i in obj:
      #     print(i)
      
      
      # 总结：
      # 列表推导式：
          # 缺点：
          # 1，有毒。列表推导式只能构建比较复杂并且有规律的列表。 不要太着迷。
          # 2，超过三层循环才能构建成功的，就不建议用列表推导式。
          # 3，查找错误（debug模式）不行。
          # 优点：
              # 一行构建，简单。
              # 装逼。
      # 构建一个列表： [2,3,4,5,6,7,8,9,10,'j','Q','K','A']
      # l1 = [i for i in range(2,11)] + list('JQKA')
      # print(l1)
      
      # 列表推导式与生成器表达式区别。
      # 写法上： [] ()
      # iterable iterator
      
      
      # 字典推导式（了解）
      # # lst1 = ['jay', 'jj', 'meet']
      # # lst2 = ['周杰伦','林俊杰','元宝']
      # # dic = { lst2[i]: lst1[i] for i in range(len(lst1))}
      # # print(dic)
      # 集合推导式（了解）
      # print({i for i in range(1,11)})

  • 内置函数 I

  • # python 提供了68个内置函数。
    # 今天讲的这部分大部分了解即可。
    # eval 剥去字符串的外衣运算里面的代码，有返回值。
    s1 = '1 + 3'
    # print(s1)
    # print(eval(s1))  **
    # s = '{"name": "alex"}'
    # print(s,type(s))
    # print(dict(s)) # 不行
    # print(eval(s),type(eval(s)))
    # 网络传输的str input 输入的时候,sql注入等等绝对不能使用eval。
    
    # exec 与eval几乎一样， 代码流。
    msg = """
    for i in range(10):
        print(i)
    """
    # print(msg)
    # exec(msg)
    # hash 哈希值
    # print(hash('fsjkdafsda'))
    
    # help 帮助
    # s1 = 'fjdsls'
    # print(help(str))
    # print(help(str.upper))
    # s1 = 'sfsda'
    # s1.upper()
    
    
    s1 = 'fdsklfa'
    # s1()
    def func():
        pass
    # func
    # # callable 判断一个对象是否可被调用  ***
    # print(callable(s1))
    # print(callable(func))

四.今日总结

• 1. 生成器：***

  2. 生成器函数 yield

  3. yield与return 区别。yield from

  4. 列表推导式，生成器表达式。 ***

  5. 内置函数：今天讲的内置函数，了解。