迭代器和生成器

迭代描述的就是一个重复的过程，之前学过的for和while，操作较多的就是列表，特点是:一个序列,有序，有索引。

例如：

l = ['a','b','c','d','e']
i = 0
while i < len(l):
    print(l[i])
    i+=1
for i in range(len(l)):
    print(l[i])

之前用的方法都是利用有下标和索引来取需要的值，但是无法对无下标的数据取值，所以我们现在需要用到了我们今天需要用到的迭代器：

d = {'a':1,'b':2,'c':3}
d.__iter__() #等同于iter(d)

#只要被内置了__iter__方法和__next__方法的对象，就被称为可迭代对象。

i = d.__iter__() #   i 就是迭代器
print(i.__next__())
print(i.__next__())

这样我们就可以用迭代器来遍历字典了

d = {'a':1,'b':2,'c':3}
i = d.__iter__() #iter(d)
while True:
    try:                               #抛出异常
       print(next(i))
    except StopIteration: ##捕捉一个叫StopIteration的异常
        break

遍历列表

l = ['a','b','c','d','e']
i = l.__iter__()
while True:
    try:                               #抛出异常
       print(next(i))
    except StopIteration:   #捕捉一个叫StopIteration的异常
        break
 

for循环

d = {'a':1,'b':2,'c':3}
for k in d:   #,python中的for循环是将 in后面的对象先调用d.__iter__()方法,并且还自动增加了try,except来操作的。
    print()

集合

s = {1,2,3,4}
for i in s：
    print(i)

遍历一个文件

with open('a.txt','r') as f:
    for line in f:
        print(line)

f = open('a.txt','r')
i = f.__iter__()
while True:
    try:
        print(next(i))
    except StopIteration: 
        break
 
 
f = open('a.txt','r')
f.__next__
f.__iter__
print(f)                   #
print(f.__iter__())  #f.__iter__()就是f本身
for line in f:
    print(line)

为什么要用迭代器：

优点：

1.迭代器提供了一种不依赖于索引的取值方式，这样就可以遍历那些没有索引的可迭代对象了（字典，集合，文件）

2.迭代器于列表比较，迭代器是惰性计算的，更节省内存

缺点：

1.无法获取迭代器的长度，使用不如列表索引取值灵活；

2.迭代器是一次性的，只能往后取值，不能倒着取值

 

查看可迭代对象与迭代器对象

from collections import Iterable,Iterator #导入一个模块可以使用isinstance函数来判断一个数据的类型。
isinstance('ssss',str) 
 
s = 'hello'
l = [1,2,3]
t = (1,2,3)
d = {'a':1}
set1 = {1,2,3,4}
f = open('a.txt')
 
#都是可迭代的
s.__iter__()
l.__iter__()
t.__iter__()
d.__iter__()
set1.__iter__()
f.__iter__()
print(isinstance(s,Iterable))
 
print(isinstance(l,Iterable))
print(isinstance(t,Iterable))
print(isinstance(d,Iterable))
print(isinstance(set1,Iterable))
print(isinstance(f,Iterable))
 
#查看是否是迭代器
print(isinstance(s,Iterator))
print(isinstance(l,Iterator))
print(isinstance(t,Iterator))
print(isinstance(d,Iterator))
print(isinstance(set1,Iterator))
print(isinstance(f,Iterator))

生成器：（本质其实就是迭代器）

生成器与return有何区别？？

return 只能返回一次函数就彻底结束了，而yield能返回多次值

yield到底干了什么事情：

1.yield把函数变成了生成器-->迭代器

2.用return返回值能返回一次，而yield可以返回多次

3.函数在暂停以及继续下一次运行时的状态由yield保存

生成器就是一个函数，这个函数内包含有yield这个关键字

def test():
   print('first') 
   yield 1 #return 1
test()
g = test()
print(g)

print(isinstance(g,Iterator))
print(next(g))

可以将函数作为生成器：

from collections import Iterable,Iterator 
def test():
   print('one') 
   yield 1 #return 1
   print('two') 
   yield 2#return 2
   print('three') 
   yield 3 #return 3
   print('four') 
   yield 4#return 4
    print('five')
    yield 5#return 5    
test()
g = test()

 
res = next(g)
print(res)
res = next(g)
print(res)
res = next(g)
print(res)
res = next(g)
print(res)
res = next(g)
print(res)
 
#或者用
for i in g:
    print(i)

举例：

def countdown(n):
    print('start countdown')
    while n>0
        yield n
        n-=1
    print('done')
g = countdown(5)

tail功能和grep功能      

将grep 也改成生成器：

 def eater(name):
    print('%s start to eat food' %name)
    while True:
        food = yield
        print('%s get %s to start eat' %(name,food))
    print('done')
 
e = eater('钢蛋')
print(e)
print(next(e))
11 e.send('包子') #相当于next，但是给当前的yield传一个值

练习一：

生成器的应用
    把下述函数改成生成器的形式，执行生成器函数的到一个生成器g，然后每次g.send(url)，打印页面的内容，利用g可以无限send

def get(url):
        def index():
            return urlopen(url).read()
        return index

"""
1.迭代器的应用
    文件名：a.txt,文件内容如下：
        apple 10 3
        tesla 100000 1
        mac 3000 2
        lenovo 30000 3
        chicken 10 3

        实现功能：cat a.txt |grep apple
            要求1：定义迭代器函数cat
            要求2：定义迭代器函数grep
            要求3：模拟管道的功能，将cat的处理结果作为grep的输入
"""
# list_com = []

def cat(file_path):
    with open(file_path,'r',encoding='utf-8') as f_cat:
        for line in f_cat:
            yield line

def grep(text,cat_result):
    for line in cat_result:
        if text in line:
            yield line

def my_com(command):
    list_com = []
    if '|' in command:
        list_temp = command.split('|')
        for i in list_temp:
            list_com.append(i.split( ))
        if list_com[0][0] == 'cat' and list_com[1][0]=='grep':
            c = cat(list_com[0][1])
            g = grep(list_com[1][1],c)
            return g
        else:
            print("请您注意命令的输入格式！！")

def main():
    while True:
        try:
            try:
                command = input("请输入您的命令例如：（cat a.txt |grep apple）：")
                print(next(my_com(command)))
            except StopIteration:
                break
        except TypeError:
            print("您输入的命令有误请重新输入！！")
            continue
if __name__ == '__main__':
    main()

练习二：

迭代器的应用
    文件名：a.txt,文件内容如下：
        apple 10 3
        tesla 100000 1
        mac 3000 2
        lenovo 30000 3
        chicken 10 3

        实现功能：cat a.txt |grep apple
            要求1：定义迭代器函数cat
            要求2：定义迭代器函数grep
            要求3：模拟管道的功能，将cat的处理结果作为grep的输入

"""
2.生成器的应用
    把下述函数改成生成器的形式，执行生成器函数的到一个生成器g，然后每次g.send(url)，打印页面的内容，利用g可以无限send
    def get(url):
        def index():
            return urlopen(url).read()
        return index
"""
from urllib.request import urlopen
def get(url):
    while True:
        def index():
            return urlopen(url).read()
        url = yield index()


def main():
    while True:
        url = input("请输入网页地址：")
        g = get(url)
        next(g)
        print(g.send(url))

if __name__ == '__main__':
    main()