python 迭代器和生成器

1.迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，
要么就引起一个StopIteration异常，以终止迭代 （只能往后走不能往前退）

2.可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法）

3.协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环，sum，min，max函数等)使用迭代器协议访问对象。

(字符串，列表，元组，字典，集合，文件对象）这些都不是可迭代对象，只不过在for循环式，
调用了他们内部的__iter__方法，把他们变成了可迭代对象
然后for循环调用可迭代对象的__next__方法去取值，而且for循环会捕捉StopIteration异常，以终止迭代

l = [1,2,3,4]

for i in l:

    print(i)

print(l.__iter__())

iter_l = l.__iter__()

print(iter_l.__next__())

print(iter_l.__next__())

print(iter_l.__next__())

print(iter_l.__next__())

# 用while 去模拟 for循环做的事

l = [1,2,3,4]

iter_l = l.__iter__()

while True:

    try:

        print(iter_l.__next__())

    except StopIteration:

        print("迭代完毕了，循环结束了")

        break

什么是生成器？

可以理解为一种数据类型，这种数据类型自动实现了迭代器协议
（其他的数据类型需要调用自己内置的__iter__方法），所以生成器就是可迭代对象

生成器分类及在python中的表现形式：（Python有两种不同的方式提供生成器）

1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。
yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行

2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

为何使用生成器之生成器的优点

Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。

# 1.生成器函数

def test():

    yield 1

    yield 2

g = test()

print(g)

print(g.__next__())

print(g.__next__())

#2.生成器表达式

g1 = ((i for i in range(10)))

print(g1)

print(g1.__next__())

print(g1.__next__())

print(g1.__next__())

print(g1.__next__())

生成器小结：

1.是可迭代对象

2.实现了延迟计算,省内存啊

3.生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象可没有这点好处

#总结：

#1.把列表解析的[]换成()得到的就是生成器表达式

#2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存

#3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
# 例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，
# 所以，我们可以直接这样计算一系列值的和：

#列表解析

s = sum([i for i in range(1000000)]) #内存占用大,机器容易卡死

print(s)

#生成器表达式

s1 = sum(i for i in range(1000000)) #几乎不占内存

print(s1)

import time

def test():

    print("开始生孩子了")

    print("开始生孩子了")

    print("开始生孩子了")

    yield "我"

    time.sleep(2)

    print("开始生")

    yield "小孩"

    time.sleep(2)

    print("开始生")

    yield  "孙子"

g = test()               #生成器函数

print(g.__next__())     #yield语句一次返回一个结果,在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行

print(g.__next__())

print(g.__next__())

def t():

    for i in range(10):

        yield i         #yield语句一次返回一个结果,在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行

g = t()

print(g)              #生成器函数

print(g.__next__())    #.__next__()执行一次返回一个结果，光标会停在yield的后面

print("可以做别的事情")

print(g.__next__())

print("可以做别的事情")

print(g.__next__())

print("可以做别的事情")

print(g.__next__())

def t1():

    for i in range(10):

        print("111")

        yield i

        print("222")

g1 = t1()

print(g1)

print(next(g1))

print(next(g1))

#人口信息.txt文件内容

# {'name':'北京','population':10}

# {'name':'南京','population':100000}

# {'name':'山东','population':10000}

# {'name':'山西','population':19999}

def get_provice_population(filename):

    with open(filename) as f:

        for line in f:

            p=eval(line)    #字符提为字典

            yield p['population']

gen=get_provice_population('人口信息.txt')

all_population=sum(gen)

for p in gen:

    print(p/all_population)

#执行上面这段代码，将不会有任何输出，这是因为，生成器只能遍历一次。在我们执行sum语句的时候，

# 就遍历了我们的生成器，当我们再次遍历我们的生成器的时候，将不会有任何记录。所以，上面的代码不会有任何输出。

#因此，生成器的唯一注意事项就是：生成器只能遍历一次。

巴特西

python 迭代器和生成器

最新文章

热门文章