guxh的python笔记四：迭代

1，可迭代对象iterable，迭代器iterator，生成器generator

可迭代对象iterable：

• 实现__iter__方法的类。__iter__方法返回iterator或者generator。
• 实现__getitem__方法的类。其参数是从0开始的索引。

迭代器Iterator：

• 实现__iter__方法和__next__方法的类（即自遍历）。其中__iter__方法返回iterator自身，__next__方法不断返回元素直到没有元素后抛出StopIteration异常。

生成器generator：

• 一个含有yield句法的函数。generator支持next()，属于iterator。

上述三种类型都可作用于for循环。

备注：

1）list、dict、str虽然是iterable，却不是iterator，为什么呢？因为iterator表示的是一个数据流，可以被next()调用不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把数据流看作一个序列，但我们无法提前知道序列长度，只有不断通过next()进行下一个计算。iterator甚至可以表示无限大的数据流，list不可能无限大。

2）iterable没有__next__（自遍历）。

3）iterator没有__getitem__不支持[]分量取值和切片，没有__len__不支持获取长度。

4）可获得iterator的内置方法：zip，enumerate，map，filter，reversed。

5）可获得iterable的内置方法：range。

6）iterator（包括generator）只能被消费一次，第二次调用时会直接返回空。

2，可迭代对象iterable与迭代器iterator的关系

关于可迭代对象iterable与迭代器iterator的实现细节可参考“3实现可迭代的方法”中的经典版方法。

2.1，iterable

s = 'abc'   # s是个iterable，<class 'str'>

s是iterable，可以被迭代：

for i in s:
   print(i)

2.2，iterable可迭代的本质

迭代的本质是从iterable获取iterator（iterable的__iter__方法return了一个iterator），然后再不断使用iterator的next()方法获取值，直到StopIteration异常结束：

sit = iter(s) # it是个iterator，<class 'str_iterator'>
while True:
　　try:
　　　  print(next(sit))
　　except StopIteration:
　　　　break　

next()可以接收默认值，当运行到StopIteration时就返回该默认值，上述代码页可以改写成这样：

sit = iter(s) # it是个iterator，<class 'str_iterator'>
i = next(sit)
while i:
    print(i)
    i = next(sit, None)

手工next()的话是这样的过程：

>>> s = 'abc'
>>> sit = iter(s)
>>> next(sit)
'a'
>>> next(sit)
'b'
>>> next(sit)
'c'
>>> next(sit)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

另外，如果一个obj没有实现__iter__方法，即无法通过iter(obj)获取到迭代器，但是它实现了__getitem__，那它也是可以被迭代的。

2.3，iterable和iterator判断方法

s可迭代却不能被next自遍历。sit可以迭代也可以被next自遍历。

可以用抽象基类判断iterable，iterator：

from collections import abc
print(isinstance(s, abc.Iterable))   # True
print(isinstance(s, abc.Iterator))   # False
print(isinstance(sit, abc.Iterable)) # True
print(isinstance(sit, abc.Iterator)) # True　　

或者用迭代的协议去判断：

print(hasattr(s, '__iter__'))    # True
print(hasattr(s, '__next__'))    # False
print(hasattr(sit, '__iter__'))  # True
print(hasattr(sit, '__next__'))  # True

　　

3，实现对象可迭代的方法

实现一个序列类型，接受输入值x，返回从x到11的值。

3.1，方法一：python序列鸭子类型

python在尝试迭代对象时，找不到__iter__就会去调用__getitem__，__getitem__实现从0开始的索引取值即可

class Foo:
    def __init__(self, data):
        self.data = data

    def __getitem__(self, i):
        return range(self.data, 11)[i]

　

3.2，方法二：经典版

iterable+iterator，构建Foo的iterator，缺点是代码量大。

关键点：iterable的__iter__返回iterator；iterator的__iter__返回self，__next__逐个取值。

class Foo:
    def __init__(self, data):
        self.data = list(data)

    def __iter__(self):    # iterable中的__iter__返回iterator
        return Foo_iterator(self.data)

class Foo_iterator:
    def __init__(self, data):
        self.data = data

    def __iter__(self):    # iterator中的__iter__返回自己
        return self

    def __next__(self):    # iterator实现__next__
        if self.data > 10:
            raise StopIteration
        else:
            num = self.data
        self.data += 1
        return num

自己实现的iterable/iterator：

f = Foo(1)
fit = iter(f)
print(type(f))    # <class '__main__.Foo'>
print(type(fit))  # <class '__main__.Foo_iterator'>

对比下内置的iterable/iterator：

s = 'abc'
sit = iter(s)
print(type(s))     # <class 'str'>
print(type(sit))   # <class 'str_iterator'>

r = range(10)
rit = iter(r)
print(type(r))     # <class 'range'>
print(type(rit))   # <class 'range_iterator'>

　　

3.3，方法三：糟糕版

Foo自己实现__next__和__iter__，让Foo既是iterable，也是自己的iterator，混淆了iterable和iterator，糟糕不推荐

class Foo:
    def __init__(self, data):
        self.data = data

    def __iter__(self):
        return self

    def __next__(self):
        if self.data > 10:
            raise StopIteration
        else:
            num = self.data
        self.data += 1
        return num

　　

3.4，方法四：generator版

用generator实现iterable中的__iter__方法

class Foo:
    def __init__(self, data):
        self.data = data

    def __iter__(self):
        for i in range(self.data, 11):
            yield i

iter()返回的类名是generator，而不是iterator：

f = Foo(1)
fit = iter(f)
print(type(f))     #  <class '__main__.Foo'>
print(type(fit))   #  <class 'generator'>

备注：Foo中的__iter__获取数据时，用的是惰性获取range(非惰性就是list(range(self.data, 11)))。一般推荐用惰性函数实现，例如用finditer替代findall。

3.5，方法五：生成器表达式

class Foo:
    def __init__(self, data):
        self.data = data

    def __iter__(self):
        return (i for i in range(self.data, 11))

3.6，方法六：委托

将iter方法委托其他iterable背后的iterator，range()是个iterable，可以通过iter(range())获取到它的iterator。

下例将Foo的迭代器实现委托给了range()的迭代器：

class Foo:
    def __init__(self, data):
        self.data = data

    def __iter__(self):
        return iter(range(self.data, 11))

iter()返回的是range的iterator：

f = Foo(3)
fit = iter(f)
print(isinstance(fit, abc.Iterator))   # True
print(type(fit))    # <class 'range_iterator'>

　

4，生成器函数

4.1，生成器函数

如果函数返回的是列表，可以用generator改写，优点是代码简介，节省内存。

函数中只要出现了yield就会转变为一个generator，其核心特性是只会在响应迭代过程中的next操作时才会运行，和iterator一致。

generator属于iterator，3.4中就直接返回了generator作为iterator。

并发的协程还会继续深入讨论generator的yield语法。

这里写看看适合单独编写一个generator的场景。

例如输入一个序列，返回其中的偶数列表：

def fun(components):
    result = []
    for c in components:
        if divmod(c, 2)[1] == 0:
            result.append(c)
    return result

生成器改写：

def fun(components):
    for c in components:
        if divmod(c, 2)[1] == 0:
            yield c

调用生成器：

f = fun(range(20))
print(f)  # <generator object fun at 0x0000022C2F1AB258>
print(list(f))  # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
print(isinstance(f, abc.Iterator))   # f是个iterator，因为generator属于iterator

4.2，生成器应用 - 生成器实现管道

脚本所在目录下有foo和bar两个文件夹，分别有多个防火墙日志文件，需要取出里面的access-list配置条目，可以：

def gen_find(filepat, top):
    # filepat: 文件名匹配模式；top：os.walk遍历的top目录。返回所有符合条件的文件名路径。
    for path, dirlist, filelist in os.walk(top):
        for name in [file for file in filelist if re.search(filepat, file)]:
            yield os.path.join(path, name)

def gen_opener(files):
    # 返回所有文件生成器。
    for file in files:
        with open(file, 'rt') as f:
            yield f     # f是个生成器，只能for循环被消费一次

def gen_concatenate(iterators):
    for it in iterators:
        yield from it

def gen_grep(pattern, lines):
    for line in lines:
        if re.search(pattern, line):
            yield line

lognames = gen_find('防火墙.*log', os.getcwd())
files = gen_opener(lognames)
lines = gen_concatenate(files)
acclines = gen_grep('^access-list', lines)
for each_acc in acclines:
    print(each_acc)

4.3，yield from扁平化处理嵌套序列

def flatten(items):
    for x in items:
        if isinstance(x, Iterable):
            yield from flatten(x)   # 递归
        else:
            yield x
>>> list(flatten([1, (3, 4, 5, {6, 7})]))
[1, 3, 4, 5, 6, 7]

5，其他

5.1，iterator(包括generator)只能被迭代一次

iterable可以被多次迭代：

>>> l = range(5)
>>> list(l)
[0, 1, 2, 3, 4]
>>> list(l)
[0, 1, 2, 3, 4]

iterator只能被迭代一次：

>>> lit = iter(range(5))   # lit是iterator
>>> list(lit)
[0, 1, 2, 3, 4]
>>> list(lit)
[]

generator也是只能迭代一次：

>>> ge = (i for i in range(5))
>>> list(ge)
[0, 1, 2, 3, 4]
>>> list(ge)
[]

　　

5.2，iter(it，x)函数的哨符值

有第二个参数时，it必须callable：

>>> iter(range(10))
<range_iterator object at 0x0000026F8968AEF0>
>>> iter(range(10), 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: iter(v, w): v must be callable

作改动：

l = iter(range(10))
def run():
    return next(l)
lit = iter(run, 3)  # 遇到3时终止
print(list(lit))  # [0, 1, 2]

5.3，生成器表达式高效处理文本

下面代码处理文本时，会惰性处理，不会事先读取文本至内存：

with open(filename) as f:
    lines = (line.strip() for line in f)
    for line in lines:
        ......