一. 如何实现可迭代对象和迭代器对象

实际案列

某软件要求， 从网络抓取各个城市气温信息， 并依次显示：
    北京： 15-20
    天津： 17-22
    长春： 12-18
    ...

如果一次抓取所有城市气温再显示， 显示第一个城市气温时， 有很高的延时，
并且浪费存储空间， 我们期望以“用时访问”的策略， 并且能把所有城市气温
封装到一个对象里， 可用for语句进行迭代。  如何解决？

可迭代对象和迭代器原理

from collections import Iterable, Iterator
l = [1,2,3,4,5]


isinstance(l, Iterable)  # True  列表是可迭代对象
issubclass(list, Iterable)  # True  列表是Iterable的子类
issubclass(str, Iterable)  # True  字符串是Iterable的子类
issubclass(dict, Iterable)  # True  字典是Iterable的子类


it = iter(l)  #  调用了__iter__方法    生成Iterator 迭代器

next(it)  #  next 可以对迭代器进行迭代   直到抛出 StopIteration异常  无法next


list(it)  # 迭代器传给列表， 可以将剩下没next的  变成列表


for x in it:   # 迭代器也是一个可迭代对象
    print(x)
    
isinstance(it, Iterable)  # True   迭代器也是一个可迭代对象

it.__iter__() is it   # True       或者iter(it)   都会返回它自身

解决方法

Step1: 实现一个迭代器对象WeatherIterator, __next__方法  每次返回一个城市的气温


Step2: 实现一个可迭代对象WeatherIterable, __iter__方法 返回一个WeatherIterator对象

from collections import Iterable, Iterator
import requests


class WeatherIterator(Iterator):
    def __init__(self, caties):
        self.caties = caties
        self.index = 0

    def __next__(self):
        if self.index == len(self.caties):
            raise StopIteration
        city = self.caties[self.index]
        self.index += 1
        return self.get_weather(city)

    def get_weather(self, city):
        url = 'http://wthrcdn.etouch.cn/weather_mini?city=' + city  # 获取相应城市气温
        r = requests.get(url)
        data = r.json()['data']['forecast'][0]
        return city, data['high'], data['low']


class WeatherIterable(Iterable):
    def __init__(self, cities):
        self.cities = cities

    def __iter__(self):
        return WeatherIterator(self.cities)


def show(w):
    for x in w:
        print(x)


w = WeatherIterable(['北京', '上海', '广州'] * 10)
show(w)

代码的注意点

如果不要WeatherIterable， 直接用WeatherIterator， 也可以。
但是 如果 show 结束  再次调用show  就什么都没有了。
因为Iterator 迭代器是一次性的， 但迭代器对象Iterable不是一次性的

二. 如何使用生成器函数实现可迭代对象

实际案列

实现一个可迭代对象的类， 它能迭代出给定范围内所有素数：
    
    pn = PrimeNumbers(1, 30)
    for k in pn:
        print k
    
    输出结果:
    2 3 5 7 11 13 17 19 23 29


用一节  中的 方法也能实现， 但用yield生成器 会更简单

解决方案

将该类的__iter__方法实现生成器函数， 每次yield返回一个素数


from collections import Iterable

class PrimeNumbers(Iterable):
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def __iter__(self):
        for k in range(self.a, self.b + 1):
            if self.is_prime(k):
                yield k

    def is_prime(self, k):
        return False if k < 2 else all(map(lambda x: k % x, range(2, k)))      #  k%x  为0  必然不是素数

pn = PrimeNumbers(1, 30)
for n in pn:
    print(n)

三. 如何进行反向迭代以及如何实现反向迭代

实际案例

实现一个连续浮点数发生器FloatRange（和range类似）， 根据给定范围（start， end） 和步进值（step）
产生一些连续浮点数， 如迭代FloatRange(3.0, 4.0, 0.2) 可产生序列:

正向： 3.0->3.2->3.4->3.6->3.8->4.0
反向： 4.0->3.8->3.6->3.4->3.2->3.0

实现反向迭代

from decimal import Decimal   #  专门处理10进值浮点数

class FloatRange:
    def __init__(self, a, b, step):
     #  有时候会发生3.400000000000000004 这样的误差持续放大的问题，  
     #  使用Decimal解决， 产生10进值的浮点数  就没有误差。  在需要精准数据时， 常用
        self.a = Decimal(str(a))   
        self.b = Decimal(str(b))
        self.step = Decimal(str(step))

    def __iter__(self):
        t = self.a
        while t <= self.b:
            yield float(t)  #  用户需要的是python的float， 需要转换。另外的注意点：decimal对象是无法与float进行运算的
            t += self.step

    def __reversed__(self):  #  实现反向迭代  reversed
        t = self.b
        while t >= self.a:
            yield float(t)
            t -= self.step

fr = FloatRange(3.0, 4.0, 0.2)
for x in fr:
    print(x)
print('-' * 20)
for x in reversed(fr):
    print(x)

四. 如何对可迭代对象做切片操作

实际案列

有某个文本文件， 我们想读取其中某范围的内容如100~300 行之间的内容， python中文件是可迭代对象，
我们是否可以使用类似列表切片的方式得到一个100~300行文件内容的生成器？

f = open('/var/log/dpkg.log.1')
for line in f[100:300]:       #  可以吗？   答案是 不可以

原理解析

l = list(range(10))

l[2:8]   # 即 l.__getitem__(slice(2,8))    slice  是切片函数， 对应[2:8]
l[2:8: 2]   # 即 l.__getitem__(slice(2,8, 2))
l[3]    # 即 l.__getitem__(3)



f = open('/var/log/dkpg.log.1')

# f.readlines可以  使用切片， 但会把真个文件都读入内存， 不推荐

解决方案

使用 itertools.islice, 它能返回一个迭代对象切片的生成器


from itertools import islice
f = open('/var/log/dkpg.log.1')

for line in islice(f, 100-1, 300, 2):  #  参数: 可迭代对象   开始行(默认从0开始)  结束行  步进
    print(line)

自己实现简化版的islice

def my_islice(iterable, start, end, step=1):
    tmp = 0
    for i, x in enumerate(iterable):
        if i >= end:
            break
        if i >= start:
            if tmp == 0：
                tmp =step
            yield x
        tmp -= 1

五. 如何在一个for语句中迭代多个可迭代对象

实际案例

情况1（并行）： 某班学生期末考试成绩， 语文， 数学， 英语 分别存储在3个列表中， 同时迭代三个列表， 计算每个学生的总分


情况2（串行）： 某年级有4个班， 每次考试每班英语成绩分别存储在4个列表中， 依次迭代每个列表， 统计全学年成绩高于90分的人数

解决方案

- 并行：  使用zip函数  将多个可迭代对象 合并成一个

from random import randint

chinese = [randint(60, 100) for _ in range(20)]
math = [randint(60, 100) for _ in range(20)]
english = [randint(60, 100) for _ in range(20)]


t = []
for s1, s2, s3 in zip(chinese, math, english):  # zip得到的元组  是传入 的可迭代对象 中最少的   
    t.append(s1+s2+s3)   # 得到三科总分
    


- 串行：使用标准库中的itertools.chain, 它能将多个可迭代对象连接

class1 = [randint(60, 100) for _ in range(20)]
class2 = [randint(60, 100) for _ in range(20)]
class3 = [randint(60, 100) for _ in range(23)]
class4 = [randint(60, 100) for _ in range(25)]

from itertools import chain

len([for x in chain(class1, class2, class3, class4) if x > 90])   #  得到分数大于90的 学生人数