迭代器
容器类型：list / tuple / dict /set
容器类型取值方法
例:列表
#列表 #第一种方法:利用索引 l = [1,2,3,4] print(l[0]) # 利用索引 print(l[:2])# 所有切片都相当于把一段内容取出来放在一个新列表中 print(l[:]) # 生成了一个新的列表,默认浅拷贝 # 所有的切片,都拷贝第一层, 对于没有嵌套的列表来说,切片就相当于深拷贝 #第二种:for循环 l = [1,2,3,4] for i in l: print(i) 当需要对某一个列表中的每一个元素都需要的时候才用for循环
例:字典
dic = {'name':'wanglan','age':18}
#第一种方法:key
print(dic['name'])
print(dic['age'])
# #第二种方法:for循环
for k,v in dic.items():
print(k,v)
for k in dic:
if k == "name":
print(dic[k])
整型
for i in 10: print(i) 结果: for i in 10: TypeError: 'int' object is not iterable
报错:int类型不是一个iterable ,iterable表示可迭代的,说明整型不能迭代,可用使用dir()来查看数据类型是否可以迭代
print(dir([])) #判断列表 print(dir(())) #判断元组 print(dir(123)) #判断整型 :整型的内部不含有__iter__ 如果输出内容函数__iter__方法,说明该数据类型是可迭代的
可迭代协议 : 只要是含有'__iter__' 方法的数据类型都是可迭代的
检查某个变量或值是不是可迭代的
#第一种检测方法 print('__iter__' in dir([])) print('__iter__' in dir(123)) #结果: True False #第二种检测方法 from collections import Iterable print(isinstance([],Iterable)) # 内置函数,判断一个具体的值是不是某个数据类型的 print(isinstance(123,Iterable)) #结果: True False
可以迭代的都是可以使用for循环的
l = [1,2,3,4] res = l.__iter__() print(res) 结果: <list_iterator object at 0x00000000025D80F0> # iterator : 迭代器
迭代器和可迭代的区别
l = [1,2,3,4] res = l.__iter__() print(dir(res)) print(dir(l)) print(set(dir(res)) - set(dir(l))) #在 res 中,但是不在 l 中的所以方法 结果: ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__length_hint__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__'] ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] {'__length_hint__', '__setstate__', '__next__'} #区别在此
__length_hint__ :查看迭代器中有多少个元素()
l = [1,2,3,4] res = l.__iter__() print(res.__length_hint__()) 结果: 4
__setstate__ :控制迭代器从哪儿开始迭代
l = [1,2,3,4] res = l.__iter__() res.__setstate__(2) for i in res: print(i) 结果: 3 4
__next__:从迭代器中取下一个值
l = [1,2,3,4] res = l.__iter__() print(res.__next__()) print(res.__next__()) print(res.__next__()) print(res.__next__()) 结果: 1 2 3 4
用迭代器的next方法来写一个不依赖for的遍历
l = [1,2,3,4] l_iter = l.__iter__() item = l_iter.__next__() print(item) item = l_iter.__next__() print(item) item = l_iter.__next__() print(item) item = l_iter.__next__() print(item) item = l_iter.__next__() print(item) 结果: item = l_iter.__next__() StopIteration 1 2 3 4
这段代码会报错,因为一直取next取到迭代器没有元素了,就会抛出StopIteration
使用异常处理机制来处理异常
l = [1,2,3,4] l_iter = l.__iter__() while True: try: item = l_iter.__next__() print(item) except StopIteration: break
迭代器协议 : 含有__next__和__iter__方法的变量/值都是迭代器
迭代器的特点:
具有next和iter方法
通过一个next多次执行就可以获得所有这个容器中的值
迭代器中的值只能取一次
不取的时候值不出现
for 循环取值:
for循环内部的机制就是迭代器取值的机制
在for循环执行的过程中 : 先把可迭代的变成一个迭代器,然后再从中一个一个的取值
本质上for循环替我们做的操作:
1.生成迭代器
2.循环每一次对这个迭代器执行next
3.并且到迭代器的最后就停止
迭代器的作用就是节省内存,for循环就是利用了迭代器节省内存的特点来对python当中的变量来进行操作的
l = [1,2,3,4] res1 = l.__iter__() res2 = l.__iter__() # res1和res2都是迭代器 # 是两个完全不同的迭代器
l = [1,2,3,4] res1 = l.__iter__() res2 = l.__iter__() for i in res1: print(i) print('**') for i in res1: print(i) print('--') 结果: 1 2 3 4 ** --
第二个for循环并没有打印,因为for循环内部的机制就是迭代器取值的机制,每个迭代器都只能取值一次
创建一个迭代器,循环这个迭代器,每次执行iter方法就创建一个迭代器,
l = [1,2,3,4] for i in l.__iter__(): print(i) print('^^') for i in l.__iter__(): print(i) 结果: 1 2 3 4 ^^ 1 2 3 4
用while循环实现一个for循环的功能(循环list/dict)
l = [1,2,3,5,6,7,12,23,412] l_iter = l.__iter__() count = 0 while count < len(l): try: # 要保护的代码 print(l_iter.__next__()) except StopIteration: # 要保护的代码中一旦出现了StopIteration错误,程序不报错,直接执行break break count +=1
生成器
迭代器有两种：
一种是调用方法直接返回的，一种是可迭代对象通过执行iter方法得到的，迭代器有的好处是可以节省内存。
如果在某些情况下，我们也需要节省内存,就只能自己写。我们自己写的这个能实现迭代器功能的东西就叫生成器
生成器函数：
常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
本质：迭代器(所以自带了__iter__方法和__next__方法，不需要我们去实现)
特点：惰性运算,开发者自定义
定义:
一个包含yield关键字的函数就是一个生成器函数。yield可以为我们从函数中返回值，但是yield又不同于return，return的执行意味着程序的结束，调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象。每一次获取这个可迭代对象的值，就能推动函数的执行，获取新的返回值。直到函数执行结束。
定义一个生成器
def func(): print('hello') yield 1 a = func() #调用生成器函数,调用不会执行这个函数,而是返回一个生成器,a是一个生成器 g = a.__next__() #执行一次 print(g)
def func(): print('hello') yield 1 print('world') yield 2 g = func() a = g.__next__() print(a) b = g.__next__() print(b)
yield关键字的特点: 可以记录当前函数中执行的位置,下一次继续执行,需要next来触发这个函数继续向下执行
next和yield是一对搭档 : next开始函数的执行 yield停止函数的执行
生成器函数和其他函数[在本质上]我们得到的结果是相同的,只不过中间的过程不同
普通函数:必须得到所有结果之后才返回
生成器函数:可以一边计算结果一边返回
迭代器:
可迭代协议 : 某个变量中含有__iter__方法,这个变量可迭代
迭代器协议 : 某个变量中含有__iter__和__next__方法,这个变量是迭代器
迭代器和可迭代的关系:
迭代器一定可迭代反之不成立
迭代器的特点 :
节省内存
惰性运算
只能取一次
只能按照顺序取
for循环和迭代器之间的关系
如果是非迭代器,for循环会帮助我们把这个飞迭代器编程迭代器(通过iter方法)
帮助我们执行next方法从迭代器中取值
帮助我们处理异常停止迭代
生成器
生成器就是迭代器 我们怎么获得生成器?? 生成器函数 生成器表达式 什么是生成器函数? 含有yield方法 生成器函数有什么特点? 调用的时候不执行 返回一个生成器/迭代器 从生成器中取值的方式和迭代器一样
例:
def produce(): """生产衣服""" for i in range(2000000): yield "生产了第%s件衣服"%i product_g = produce() print(product_g.__next__()) #要一件衣服 print(product_g.__next__()) #再要一件衣服 print(product_g.__next__()) #再要一件衣服 num = 0 for i in product_g: #要一批衣服，比如5件 print(i) num +=1 if num == 5: break 结果: 生产了第0件衣服 生产了第1件衣服 生产了第2件衣服 生产了第3件衣服 生产了第4件衣服 生产了第5件衣服 生产了第6件衣服 生产了第7件衣服
监听文件的输入,对于文件中随时输入的内容进行自动化分析/自动化展示
def get_line(): f = open('file',encoding='utf-8') while True: line = f.readline().strip() if line: yield line.strip() line_g = get_line() for line in line_g: print(line.split(','))
send
def func(): print('草莓') yield 1 print('香蕉味') yield 2 print('榴莲') yield 3 g = func() for i in g: print(i) # 拆开for循环 # n = g.__next__() # print(n) # n = g.__next__() # print(n) # n = g.__next__() # print(n) # send def func(): print('草莓') wl = yield 1 print(wl) yield 2 print('榴莲') yield 3 g = func() print(g.__next__()) #开头必须是__next__ print(g.send('香蕉')) #相当于g.__next__,只不过传入一个值进去
计算移动平均值
def fun(): sum_n = 0 count = 0 while True: if count: num = yield sum_n/count #9 返回 4.0 else: # 2 num = yield 0 #3 返回 0 # 6 num = 4 sum_n +=num #7 sum_n = 4 count +=1 #8 count = 1 g = fun() avg = g.__next__() # 1 print(avg) #4 0 avg = g.send(4) # 5 传入4 #10 返回4 print(avg) ##11 4.0 avg = g.send(5) print(avg) avg = g.send(6) print(avg)
yield form
def func(): l1 = [1,2,3] s2 = 'abc' yield from l1 #yield form 后面直接跟可迭代变量 yield from s2 g = func() for i in g: print(i)
其他
def func(): lst = [1,2,3,4,5] return lst #[1,2,3,4,5] #lst = func() for i in func(): print(i)
def func(): lst = [1,2,3,4,5] for num in lst: yield num #相当于 # num = 1 # yield num # num = 2 # yield num # num = 3 # yield num # num = 4 # yield num # num = 5 # yield num #g = func() #生成器函数的返回值是一个生成器,生成器的本质是迭代器,g是一个生成器/迭代器 for i in func(): # g 和 func 是相同的 print(i) #for 循环是通过迭代器实现的 #相当于 # print(g.__next__()) # 1 从生成器中,通过next取到的值才是yield的返回值 # print(g.__next__()) # 2 # print(g.__next__()) # 3 # print(g.__next__()) # 4 # print(g.__next__()) # 5
在python2.x中: range() 列表 xrange():生成器
在python3.x中:range() 可迭代的,既不是生成器也不是迭代器