Python中生成器,迭代器,以及一些常用的内置函数.

知识点总结

生成器

生成器的本质就是迭代器.

迭代器:python中提供的已经写好的工具或者通过数据转化得来的.

生成器:需要我们自己用python代码构建的

创建生成器的三种方法:

1. 通过生成器函数
2. 通过生成器推导式
3. python内置函数或者模块提供

生成器函数

yield:一个yield对应一个next,next超过yield数量,就会报错,与迭代器一样.

yield与return的区别：

1. return一般在函数中只设置一个,他的作用是终止函数,并传给函数的执行者返回值
2. yield在生成器中可以设置多个,他并不会终止函数,next会获取对应yield生成的元素

列表推导式

推导式的两种模式:

1. 循环模式:[变量(加工的变量) for 变量 in iterable]

2. 筛选模式:[变量(加工的变量) for 变量 in iterable if 循环]

   循环模式:

   1. 将10以内所有整数的平方写入列表。

      l1 = [i*i for i in range(1,11)]
      print(l1)

   2. 100以内所有的偶数写入列表

      l1 = [i for i in range(2,101,2)]
      print(l1)

   3. 从python1期到python100期写入列表lst

      lst = [f'python{i}' % i for i in range(1,19)]
      print(lst)

   筛选模式:

   1. 将这个列表中大于3的元素留下来。

      l1 = [4, 3, 2, 6, 5, 5, 7, 8] 
      
      print([i for i in l1 if i > 3])

   2. 三十以内可以被三整除的数。

      multiples = [i for i in range(30) if i % 3 is 0]
      print(multiples)

   3. 过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母

      l = ['wusir', 'laonanhai', 'aa', 'b', 'taibai']
      print([i.upper() for i in l if len(i) > 3])

   4. 找到嵌套列表中名字含有两个‘e’的所有名字（有难度）

      names = [['tom', 'billy', 'jefferson', 'andrew', 'wesley', 'steven', 'joe'],
               ['alice', 'jill', 'ana', 'wendy', 'jennifer', 'sherry', 'eva']]
      
      print([name for lst in names for name in lst if name.count('e') >= 2])  # 注意遍历顺序，这是实现的关键

   生成器表达式

   1. 生成器表达式和列表推导式的语法上一模一样,只是把[]换成()就行了。比如将十以内所有数的平方放到一个生成器表达式中

      gen = (i**2 for i in range(10))
      print(gen)
      # 结果: <generator object <genexpr> at 0x0000026046caebf8>

   2. 生成器表达式也可以进行筛选

      # 获取1-100内能被3整除的数
      gen = (i for i in range(1,100) if i % 3 == 0)
      for num in gen:
          print(num)

   生成器表达式和列表推导式的区别:

   1. 列表推导式比较耗内存,所有数据一次性加载到内存。而.生成器表达式遵循迭代器协议，逐个产生元素。
   2. 得到的值不一样,列表推导式得到的是一个列表.生成器表达式获取的是一个生成器
   3. 列表推导式一目了然，生成器表达式只是一个内存地址。

   其他推导式

   1. 字典推导式

      lst1 = ['jay','jj','meet']
      lst2 = ['周杰伦','林俊杰','郭宝元']
      dic = {lst1[i]:lst2[i] for i in range(len(lst1))}
      print(dic)

   2. 集合推导式

      lst = [1,2,3,-1,-3,-7,9]
      s = {abs(i) for i in lst}
      print(s)

内置函数

1. 普通讲:

   all()  any()  bytes() callable() chr() complex() divmod() eval() exec() format() frozenset() globals() hash() help() id() input() int()  iter() locals() next()  oct()  ord()  pow()    repr()  round()
   

2. 重点讲:

   abs() enumerate() filter()  map() max()  min() open()  range() print()  len()  list()  dict() str()  float() reversed()  set()  sorted()  sum()    tuple()  type()  zip()  dir() 

3. 未来讲

   classmethod()  delattr() getattr() hasattr()  issubclass()  isinstance()  object() property()  setattr()  staticmethod()  super()

   eval：执行字符串类型的代码，并返回最终结果。

   eval('2 + 2')  # 4
   n=81
   eval("n + 4")  # 85
   eval('print(666)')  # 666

   exec:执行字符串类型的代码。

   s = '''
   for i in [1,2,3]:
       print(i)
   '''
   exec(s)

   hash：获取一个对象（可哈希对象：int，str，bool，tuple）的哈希值。

   print(hash(12322))
   print(hash('123'))
   print(hash('arg'))
   print(hash('alex'))
   print(hash(true))
   print(hash(false))
   print(hash((1,2,3)))
   
   '''
   -2996001552409009098
   -4637515981888139739
   2528502973977326415
   '''

   help：函数用于查看函数或模块用途的详细说明。

   print(help(list))
   print(help(str.split))

   callable：函数用于检查一个对象是否是可调用的。如果返回true，object仍然可能调用失败；但如果返回false，调用对象ojbect绝对不会成功。

   name = 'alex'
   def func():
       pass
   print(callable(name))  # false
   print(callable(func))  # true

   int：函数用于将一个字符串或数字转换为整型。

   print(int())  # 0
   print(int('12'))  # 12
   print(int(3.6))  # 3
   print(int('0100',base=2))  # 将2进制的 0100 转化成十进制。结果为 4

   float：函数用于将整数和字符串转换成浮点数。

   complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。

   print(float(3))  # 3.0
   print(complex(1,2))  # (1+2j)

   bin：将十进制转换成二进制并返回。

   oct：将十进制转化成八进制字符串并返回。

   hex：将十进制转化成十六进制字符串并返回。

   print(bin(10),type(bin(10)))  # 0b1010 <class 'str'>
   print(oct(10),type(oct(10)))  # 0o12 <class 'str'>
   print(hex(10),type(hex(10)))  # 0xa <class 'str'>

   divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

   round：保留浮点数的小数位数，默认保留整数。

   pow：求xy次幂。（三个参数为xy的结果对z取余）

   print(divmod(7,2))  # (3, 1)
   print(round(7/3,2))  # 2.33
   print(round(7/3))  # 2
   print(round(3.32567,3))  # 3.326
   print(pow(2,3))  # 两个参数为2**3次幂
   print(pow(2,3,3))  # 三个参数为2**3次幂，对3取余。

   bytes：用于不同编码之间的转化。

   s = '你好'
   bs = s.encode('utf-8')
   print(bs)
   s1 = bs.decode('utf-8')
   print(s1)
   bs = bytes(s,encoding='utf-8')
   print(bs)
   b = '你好'.encode('gbk')
   b1 = b.decode('gbk')
   print(b1.encode('utf-8'))

   ord:输入字符找该字符编码的位置

   chr:输入位置数字找出其对应的字符

   #ord 输入字符找该字符编码的位置
   print(ord('a'))
   print(ord('中'))
   
   chr 输入位置数字找出其对应的字符
   print(chr(97))
   print(chr(20013))

   repr:返回一个对象的string形式（原形毕露）。

   # %r  原封不动的写出来
   # name = 'taibai'
   # print('我叫%r'%name)
   
   # repr 原形毕露
   print(repr('{"name":"alex"}'))
   print('{"name":"alex"}')

   all：可迭代对象中，全都是true才是true

   any：可迭代对象中，有一个true 就是true

   # all  可迭代对象中，全都是true才是true
   # any  可迭代对象中，有一个true 就是true
   print(all([1,2,true,0]))
   print(any([1,'',0]))

匿名函数

1. 匿名函数，顾名思义就是没有名字的函数，那么什么函数没有名字呢？这个就是我们以后面试或者工作中经常用匿名函数 lambda，也叫一句话函数。

   函数名 = lambda 参数:返回值

2. 此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func.

3. lambda 是定义匿名函数的关键字，相当于函数的def.

   func = lambda a,b,*args,sex= 'alex',c,**kwargs: kwargs
   print(func(3, 4,c=666,name='alex')) 
   # {'name': 'alex'}
   # 所有类型的形参都可以加，但是一般使用匿名函数只是加位置参数，其他的用不到。

4. lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行。

5. 返回值在冒号之后设置，返回值和正常的函数一样,可以是任意数据类型.匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据.

内置函数2

1. 重点讲解:

   print() 屏幕输出。

   ''' 源码分析
   def print(self, *args, sep=' ', end='\n', file=none): # known special case of print
       """
       print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=false)
       file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
       sep:   打印多个值之间的分隔符，默认为空格
       end:   每一次打印的结尾，默认为换行符
       flush: 立即把内容输出到流文件，不作缓存
       """
   '''
   ​
   print(111,222,333,sep='*')  # 111*222*333
   ​
   print(111,end='')
   print(222)  #两行的结果 111222
   ​
   f = open('log','w',encoding='utf-8')
   print('写入文件',fle=f,flush=true)

   int():pass

   str():pass

   bool():pass

   set(): pass

   list() 将一个可迭代对象转换成列表

   tuple() 将一个可迭代对象转换成元组

   dict() 通过相应的方式创建字典。

   int():pass

   str():pass

   bool():pass

   set(): pass

   list() 将一个可迭代对象转换成列表

   tuple() 将一个可迭代对象转换成元组

   dict() 通过相应的方式创建字典。

   list
   l1 = list('abcd')
   print(l1)  # ['a', 'b', 'c', 'd']
   tu1 = tuple('abcd')
   print(tu1)  # ('a', 'b', 'c', 'd')

   abs() 返回绝对值

   i = -5
   print(abs(i))  # 5

   sum() 求和

   print(sum([1,2,3]))
   print(sum((1,2,3),100))

   min() 求最小值

   print(min([1,2,3]))  # 返回此序列最小值
   ​
   ret = min([1,2,-5,],key=abs)  # 按照绝对值的大小，返回此序列最小值
   print(ret)
   # 加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，然后通过你设定的返回值比较大小，返回最小的传入的那个参数。
   print(min(1,2,-5,6,-3,key=lambda x:abs(x)))  # 可以设置很多参数比较大小
   dic = {'a':3,'b':2,'c':1}
   print(min(dic,key=lambda x:dic[x]))
   ​
   # x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键

   max() 最大值与最小值用法相同。

   reversed() 将一个序列翻转, 返回翻转序列的迭代器 reversed 示例:

   l = reversed('你好')  # l 获取到的是一个生成器
   print(list(l))
   ret = reversed([1, 4, 3, 7, 9])
   print(list(ret))  # [9, 7, 3, 4, 1]

   bytes() 把字符串转换成bytes类型

   s = '你好太白'
   bs = s.encode('utf-8')
   print(bs)
   结果:b'\xe4\xbd\xa0\xe5\xa5\xbd\xe6\xad\xa6\xe5\xa4\xa7'
   ​
   s1 = bs.decode('utf-8')
   print(s1)
   结果: 你好太白
   ​
   ​
   s = '你好'
   bs = bytes(s,encoding='utf-8')
   print(bs)
   # 将字符串转换成字节
   ​
   bs1 = str(bs,encoding='utf-8')
   print(bs1)
   # 将字节转换成字符串

   zip() 拉链方法。函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,

   然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回

   lst1 = [1,2,3]
   ​
   lst2 = ['a','b','c','d']
   ​
   lst3 = (11,12,13,14,15)
   ​
   for i in zip(lst1,lst2,lst3):
   ​
       print(i)
   ​
   结果:
   ​
   (1, 'a', 11)
   ​
   (2, 'b', 12)
   ​
   (3, 'c', 13)

   sorted排序函数

   语法:sorted(iterable,key=none,reverse=false)
   
   iterable : 可迭代对象
   
   key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序
   
   reverse :是否是倒叙,true 倒叙 false 正序
   
   lst = [1,3,2,5,4]
   lst2 = sorted(lst)
   print(lst)    #原列表不会改变
   print(lst2)   #返回的新列表是经过排序的
   
   
   lst3 = sorted(lst,reverse=true)
   print(lst3)   #倒叙
   
   结果:
   [1, 3, 2, 5, 4]
   [1, 2, 3, 4, 5]
   [5, 4, 3, 2, 1]
   
   字典使用sorted排序
   
   dic = {1:'a',3:'c',2:'b'}
   print(sorted(dic))   # 字典排序返回的就是排序后的key
   
   结果:
   [1,2,3]
   
   
   
   
   和函数组合使用
   
   # 定义一个列表,然后根据一元素的长度排序
   lst = ['天龙八部','西游记','红楼梦','三国演义']
   
   # 计算字符串的长度
   def func(s):
       return len(s)
   print(sorted(lst,key=func))
   
   # 结果:
   # ['西游记', '红楼梦', '天龙八部', '三国演义']
   
   
   和lambda组合使用
   
   lst = ['天龙八部','西游记','红楼梦','三国演义']
   
   print(sorted(lst,key=lambda s:len(s)))
   
   结果:
   ['西游记', '红楼梦', '天龙八部', '三国演义']
   
   
   lst = [{'id':1,'name':'alex','age':18},
       {'id':2,'name':'wusir','age':17},
       {'id':3,'name':'taibai','age':16},]
   
   # 按照年龄对学生信息进行排序
   
   print(sorted(lst,key=lambda e:e['age']))
   
   结果:
   [{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]

   filter筛选过滤

   语法: filter(function,iterable)
   
   function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的true或者false来判断是否保留此项数据
   
   iterable:可迭代对象
   
   lst = [{'id':1,'name':'alex','age':18},
           {'id':1,'name':'wusir','age':17},
           {'id':1,'name':'taibai','age':16},]
   
   ls = filter(lambda e:e['age'] > 16,lst)
   
   print(list(ls))
   
   结果:
   [{'id': 1, 'name': 'alex', 'age': 18},
    {'id': 1, 'name': 'wusir', 'age': 17}]

   map

   映射函数
   
   语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function
   
   计算列表中每个元素的平方,返回新列表
   
   lst = [1,2,3,4,5]
   ​
   def func(s):
   ​
       return  s*s
   ​
   mp = map(func,lst)
   ​
   print(mp)
   ​
   print(list(mp))
   
   
   
   
   改写成lambda
   
   lst = [1,2,3,4,5]
   ​
   print(list(map(lambda s:s*s,lst)))
   
   
   
   
   计算两个列表中相同位置的数据的和
   
   lst1 = [1, 2, 3, 4, 5]
   ​
   lst2 = [2, 4, 6, 8, 10]
   ​
   print(list(map(lambda x, y: x+y, lst1, lst2)))
   ​
   结果:
   ​
   [3, 6, 9, 12, 15]

   reduce

   from functools import reduce
   def func(x,y):
       return x + y
   ​
   # reduce 的使用方式:
   # reduce(函数名,可迭代对象)  # 这两个参数必须都要有,缺一个不行
   ​
   ret = reduce(func,[3,4,5,6,7])
   print(ret)  # 结果 25
   reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,
   接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始
   临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推
   ​
   注意:我们放进去的可迭代对象没有更改
   以上这个例子我们使用sum就可以完全的实现了.我现在有[1,2,3,4]想让列表中的数变成1234,就要用到reduce了.
   普通函数版
   from functools import reduce
   ​
   def func(x,y):
   ​
       return x * 10 + y
       # 第一次的时候 x是1 y是2  x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了
       # 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了
       # 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了
   ​
   l = reduce(func,[1,2,3,4])
   print(l)
   ​
   ​
   匿名函数版
   l = reduce(lambda x,y:x*10+y,[1,2,3,4])
   print(l)
   
   
   
   
   在python2.x版本中recude是直接 import就可以的, python3.x版本中需要从functools这个包中导入
   
   龟叔本打算将 lambda 和 reduce 都从全局名字空间都移除, 舆论说龟叔不喜欢lambda 和 reduce
   
   最后lambda没删除是因为和一个人写信写了好多封,进行交流然后把lambda保住了.