day16 迭代器和生成器

Posted 2020-09-30 A-a

 

分页查找

#5.随意写一个20行以上的文件(divmod)
# 运行程序，先将内容读到内存中，用列表存储。
# l = []
# 提示：一共有多少页
# 接收用户输入页码，每页5条，仅输出当页的内容
def read_page(bk_list,n,endline=None):
    startline = 5 * (n-1)
    endline = endline+startline-1 if endline else startline + 4
    # print(startline,endline)
    for i in range(startline,endline+1):
        print(bk_list[i],end = ‘‘)

def read_book(filename):
    f = open(filename)
    book_list = f.readlines()
    f.close()
    return book_list

book_list = read_book(‘tmp_file‘)
line_num = len(book_list)

x,y = divmod(line_num,5)
print(line_num,x,y)
# if y:
#     page = x+1
# else:
#     page = x
page = x+1 if y else x
print(‘一共有%s页‘%page)
while True:
    page_num = input(‘请输入您要阅读的页码 ： ‘).strip()
    if page_num.isdigit():
        page_num = int(page_num)
        if page_num < page:
            read_page(book_list,page_num)
        elif page_num == page:
            read_page(book_list,page_num,y)
        else:
            print(‘您输入的内容有误‘)

 

 

一、可迭代对象

可以将某个数据集内的数据“一个挨着一个的取出来”，就叫做迭代。

可迭代协议

假如我们自己写了一个数据类型，希望这个数据类型里的东西也可以使用for被一个一个的取出来，那我们就必须满足for的要求。这个要求就叫做“协议”。

可以被迭代要满足的要求就叫做可迭代协议。可迭代协议的定义非常简单，就是内部实现了__iter__方法。

可以被for循环的都是可迭代的，要想可迭代，内部必须有一个__iter__方法。

l = [1,2,3,4,5]
s = {1,2,3,4}
#索引
#for
# for i in l:
#     print(i)

# for i in 50:
#     print(i)

#iterable  可迭代的
#迭代

#str
#列表
#tuple
#set
#dict

#可迭代的 ——对应的标志  __iter__
# print(‘__iter__‘ in dir([1,2,3]))  #判断一个变量是不是一个可迭代的

二、迭代器

接着分析，__iter__方法做了什么事情呢？

print([1,2].__iter__())

结果
<list_iterator object at 0x1024784a8>

#可迭代协议
l = [1,2,3,4,5]
# for i in l:
#     print(i)
# print(iter(l))   #内置函数
l.__iter__()
#iterator  #迭代器
#iterator   iterable
l_iterator = iter(l)
# print(set(dir(l_iterator))-set(dir(l)))
#__next__

# iter({1,2,3})

迭代器协议

既什么叫“可迭代”之后，又一个历史新难题，什么叫“迭代器”？

虽然我们不知道什么叫迭代器，但是我们现在已经有一个迭代器了，这个迭代器是一个列表的迭代器。

我们来看看这个列表的迭代器比起列表来说实现了哪些新方法，这样就能揭开迭代器的神秘面纱了吧？

 

可迭代协议——凡是可迭代的内部都有一个__iter__方法
迭代器里既有iter方法，又有next方法  ——迭代器协议
通过iter(o)得到的结果就是一个迭代器，

‘‘‘
dir([1,2].__iter__())是列表迭代器中实现的所有方法，dir([1,2])是列表中实现的所有方法,都是以列表的形式返回给我们的，为了看的更清楚，我们分别把他们转换成集合，
然后取差集。
‘‘‘
#print(dir([1,2].__iter__()))
#print(dir([1,2]))
print(set(dir([1,2].__iter__()))-set(dir([1,2])))

结果：
{‘__length_hint__‘, ‘__next__‘, ‘__setstate__‘}

我们看到在列表迭代器中多了三个方法，那么这三个方法都分别做了什么事呢？

iter_l = [1,2,3,4,5,6].__iter__()
#获取迭代器中元素的长度
print(iter_l.__length_hint__())
#根据索引值指定从哪里开始迭代
print(‘*‘,iter_l.__setstate__(4))
#一个一个的取值
print(‘**‘,iter_l.__next__())
print(‘***‘,iter_l.__next__())

在for循环中，就是在内部调用了__next__方法才能取到一个一个的值。

那接下来我们就用迭代器的next方法来写一个不依赖for的遍历。

l=[1,2,8,1,9,4]
l_iterator=iter(l)
print(l_iterator.__next__())
print(l_iterator.__next__())
while True:
    try:
        print(next(l_iterator))
    except:
        break

判断是否是迭代器 和 可迭代对象的简便方法

#迭代器 大部分都是在python的内部去使用的，我们直接拿来用就行了
#迭代器：内置__iter__和__next__方法
from collections import Iterable
from collections import Iterator
#判断是否是迭代器 和 可迭代对象的简便方法
# s = ‘abc‘
# print(isinstance(s,Iterable))
# print(isinstance(s,Iterator))
# print(isinstance(iter(s),Iterator))
map_o = map(abs,[1,2,-3,4])
#map_o = [1,2,3,4]
print(isinstance(map_o,Iterable))
print(isinstance(map_o,Iterator))

range()

#不管是一个迭代器还是一个可迭代对象，都可以使用for循环遍历
#迭代器出现的原因 帮你节省内存
from collections import Iterable
from collections import Iterator
a = range(100)
print(isinstance(a,Iterable))
print(isinstance(a,Iterator))

为什么要有for循环

基于上面讲的列表这一大堆遍历方式，聪明的你立马看除了端倪，于是你不知死活大声喊道，你这不逗我玩呢么，有了下标的访问方式，我可以这样遍历一个列表啊

l=[1,2,3]

index=0
while index < len(l):
    print(l[index])
    index+=1

#要毛线for循环，要毛线可迭代，要毛线迭代器

for循环就是基于迭代器协议提供了一个统一的可以遍历所有对象的方法，即在遍历之前，先调用对象的__iter__方法将其转换成一个迭代器，然后使用迭代器协议去实现循环访问，这样所有的对象就都可以通过for循环来遍历了，

 

 

初识生成器

我们知道的迭代器有两种：一种是调用方法直接返回的，一种是可迭代对象通过执行iter方法得到的，迭代器有的好处是可以节省内存。

如果在某些情况下，我们也需要节省内存,就只能自己写。我们自己写的这个能实现迭代器功能的东西就叫生成器。

 

Python中提供的生成器：

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

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

 

生成器Generator：

　　本质：迭代器(所以自带了__iter__方法和__next__方法，不需要我们去实现)

　　特点：惰性运算,开发者自定义

生成器函数

一个包含yield关键字的函数就是一个生成器函数。yield可以为我们从函数中返回值，但是yield又不同于return，return的执行意味着程序的结束，调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象。每一次获取这个可迭代对象的值，就能推动函数的执行，获取新的返回值。直到函数执行结束。

import time
def genrator_fun1():
    a = 1
    print(‘现在定义了a变量‘)
    yield a
    b = 2
    print(‘现在又定义了b变量‘)
    yield b

g1 = genrator_fun1()
print(‘g1 : ‘,g1)       #打印g1可以发现g1就是一个生成器
print(‘-‘*20)   #我是华丽的分割线
print(next(g1))
time.sleep(1)   #sleep一秒看清执行过程
print(next(g1))

生成器有什么好处呢？就是不会一下子在内存中生成太多数据

假如我想让工厂给学生做校服，生产2000000件衣服，我和工厂一说，工厂应该是先答应下来，然后再去生产，我可以一件一件的要，也可以根据学生一批一批的找工厂拿。
而不能是一说要生产2000000件衣服，工厂就先去做生产2000000件衣服，等回来做好了，学生都毕业了。。。

初识生成器二

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

#到这里我们找工厂拿了8件衣服，我一共让我的生产函数(也就是produce生成器函数)生产2000000件衣服。
#剩下的还有很多衣服，我们可以一直拿，也可以放着等想拿的时候再拿

读取文件

import time


def tail(filename):
    f = open(filename)
    f.seek(0, 2) #从文件末尾算起
    while True:
        line = f.readline()  # 读取文件中新的文本行
        if not line:
            time.sleep(0.1)
            continue
        yield line

tail_g = tail(‘tmp‘)
for line in tail_g:
    print(line)

 

计算移动平均值‘

#计算移动平均值
#7日平均年化收益
#10,12,11  = （10+12+11）/3
#total = 10 + 12  + 11
#day = 1 + 1 + 1
#avg = 10/1  22/2  33/3
#       10    11    11

def averager():
    total = 0
    day = 0
    avrage = 0
    while True:
        day_num  = yield avrage  #return avrage
        total += day_num
        day += 1
        avrage = total/day

# avg = averager()
# num = next(avg)  #激活生成器 avg.send(),什么都不send和next效果一样
# print(avg.send(10))  #传值 next
# print(avg.send(20))

__author__ = ‘Administrator‘
def wapper(fun):
    def inner(*args,**kwargs):
        g=fun(*args,**kwargs)
        next(g)
        return g
    return inner

@wapper
def aa():
    day=0
    total=0
    avrage =0
    while True:
        day_num=yield avrage
        total+=day_num
        day+=1
        avrage=total/day

g=aa()
print(g.send(20))

yield from

# __author__ = ‘Administrator‘
# def fun():
#     for i in "ab":
#         yield i
#         print("....")
#         yield 1
#
# aa=fun()
# while True:
#     try:
#         print(next(aa))
#     except:
#         break
# print(next(aa))


def fun():
    yield  from "abc"
    yield  from [1,2,4,5]

aa=fun()
print(next(aa))
print(aa.__next__())
print(next(aa))
print(aa.__next__())

while True:
    try:
        print(next(aa))
    except:
        break

列表推导式和生成器表达式

#老男孩由于峰哥的强势加盟很快走上了上市之路,alex思来想去决定下几个鸡蛋来报答峰哥

egg_list=[‘鸡蛋%s‘ %i for i in range(10)] #列表解析

#峰哥瞅着alex下的一筐鸡蛋,捂住了鼻子,说了句:哥,你还是给我只母鸡吧,我自己回家下

laomuji=(‘鸡蛋%s‘ %i for i in range(10))#生成器表达式
print(laomuji)
print(next(laomuji)) #next本质就是调用__next__
print(laomuji.__next__())
print(next(laomuji))

# for i in range(100):
#     print(i*i)

# l =[i*i for i in range(100)]
# print(l)

# l = [{‘name‘:‘v‘,‘age‘:28},{‘name‘:‘v‘}]
# name_list = [dic[‘name‘] for dic in l]
# print(name_list)

# l = [{‘name‘:‘v1‘,‘age‘:28},{‘name‘:‘v2‘}]
# name_list_generator = (dic[‘name‘] for dic in l)
# print(name_list_generator)
# print(next(name_list_generator))
# print(next(name_list_generator))

# egg_list=[‘鸡蛋%s‘ %i for i in range(10)]
# print(egg_list)

# laomuji = (‘鸡蛋%s‘ %i for i in range(1,11))
# print(laomuji)
# print(next(laomuji))
# print(next(laomuji))

# print(sum([1,2,3]))
# print(sum(range(1,4)))

def func():
    # yield from ‘ABC‘
    for i in ‘ABC‘:
        yield i

# g = func()
# print(next(g))
# print(next(g))

for i in range(10):
    print(i)

[i for i in range(10)]
a = 10
b=20
if a >b :
    print(a)
else:
    print(b)
a if a>b else b