【Python】笔记：可迭代的对象、迭代器和生成器

当前位置:

首页 > temp > python入门教程 >

【Python】笔记：可迭代的对象、迭代器和生成器

import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence_v1:

    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)

    def __getitem__(self, index):
        return self.words[index]
    
    def __len__(self):
        return len(self.words)
    
    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

s = Sentence_v1('"The time has come," the Walrus said,')
print(repr(s))
for word in s:
    print(word)

Sentence('"The time ha... Walrus said,')
The
time
has
come
the
Walrus
said

当解释器需要迭代对象时,

__iter__
__getitem__
抛出 TypeError

class Foo:
    def __iter__(self):
        pass

from collections import abc
print(issubclass(Foo, abc.Iterable))
f = Foo()
print(isinstance(f, abc.Iterable))

True
True

s = 'ABC'
for char in s:
    print(char)

A
B
C

s = 'ABC'
it = iter(s)
while True:
    try:
        print(next(it))
    except StopIteration:
        del it
        break

A
B
C

import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence_v2:

    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)
    
    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

    def __iter__(self):
        return SentenceIterator(self.words)

class SentenceIterator:
    
    def __init__(self, words):
        self.words = words
        self.index = 0

    def __next__(self):
        try:
            word = self.words[self.index]
        except IndexError:
            raise StopIteration()
        self.index += 1
        return word
    
    def __iter__(self):
        return self

__iter__ 实例化并返回一个迭代器

import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence_v3:

    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)
    
    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

    def __iter__(self):
        for word in self.words:
            yield word
        return  # 可有可无

yield

惰性求值

# yield

def gen_AB():
    print('start')
    yield 'A'
    print('continue')
    yield 'B'
    print('end')  # 第三次迭代到这里后, 抛出异常, 被 for 捕捉, 停止迭代

for c in gen_AB():
    print('--> ', c)

start
-->  A
continue
-->  B
end

import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence_v4:

    def __init__(self, text):
        self.text = text
    
    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

    def __iter__(self):
        for match in RE_WORD.finditer(self.text):
            yield match.group()

惰性求值与迫切求值

l1 = [x for x in gen_AB()]

start
continue
end

for x in l1:
    print(x)

A
B

g1 = (x for x in gen_AB())

for x in g1:
    print(x)

start
A
continue
B
end

import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence_v5:

    def __init__(self, text):
        self.text = text
    
    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

    def __iter__(self):  # 直接返回一个 iter
        return (match.group() for match in RE_WORD.finditer(self.text))

无限等差数列

class ArithmeticProgression:

    def __init__(self, begin, step, end=None):
        self.begin, self.step, self.end = begin, step, end

    def __iter__(self):
        result = type(self.begin + self.step)(self.begin)  将 
        forever = self.end is None

        index = 0
        while forever or result < self.end:
            yield result
            index += 1
            result = self.begin + self.step * index

def aritprog_gen(begin, step, end=None):
    result = type(begin + step)(begin)
    forever = end is None
    index = 0
    while forever or result < end:
            yield result
            index += 1
            result = begin + step * index

itertools 中的等差数列

import itertools
gen = itertools.count(1, .5)
print(next(gen))
print(next(gen))
print(next(gen))

1
1.5
2.0

itertools.takewhile 生成一个使用另一个生成器的生成器, 仅在计算结果为 False 时停止

gen2 = itertools.takewhile(lambda n: n < 3, itertools.count(1, .5))
print(list(gen2))

[1, 1.5, 2.0, 2.5]

def aritprog_gen2(begin, step, end=None):
    first = type(begin + step)(begin)
    ap_gen = itertools.count(first, step)
    if end is not None:
        ap_gen = itertools.takewhile(lambda n: n < end, ap_gen)
    return ap_gen

标准库中的生成器

用于过滤的生成器函数

模块	函数	说明
`itertools`	`compress(it, selector_it)`	并行处理两个 iter , 如果 selector_it 中元素为真, 则产出对应 it 中的元素
`itertools`	`dropwhile(predicate, it)`	处理 it , 跳过 predicate 中计算结果为真的元素, 然后查出剩下的各个元素(不再进一步检查)
`(inner)`	`filter(predicate, it)`	把 it 中的各个元素传给 predicate, 如果 predicate(item) 返回真, 那么产出对应元素
`itertools`	`filterfalse(predicate, it)`	与上面相反
`itertools`	`islice(it, stop)` 或 `islice(it, start, stop, step=1)`	产出 it 切片, 作用类似于 s[:stop] 或 s[start:stop:step], 但返回的是一个可迭代对象
`itertools`	`takewhile(predicate, it)`	predicate 返回真值时产出对应的元素, 然后立即停止, 不在继续检查

from itertools import filterfalse, dropwhile, takewhile, compress, islice

def vowel(c):
    return c.lower() in 'aeiou'

print('filter: ', list(filter(vowel, 'Aardvark')))  # 产出所有 aeiou
print('filterfalse: ', list(filterfalse(vowel, 'Aardvark')))  # 产出所有 除了aeiou

print('dropwhile: ', list(dropwhile(vowel, 'Aardvark')))  # 从第一个不是 aeiou 的元素开始产出到末尾
print('takewhile: ', list(takewhile(vowel, 'Aardvark')))  # 从第一个元素开始产出 到不是 aeiou 的元素停止

print('compress: ', list(compress('Aardvark', (1, 0, 1, 1, 0, 1))))  #  产出 后面 it 为真的元素

print('islice: ', list(islice('Aardvark', 1, 7, 2)))  # 类似于切片

filter:  ['A', 'a', 'a']
filterfalse:  ['r', 'd', 'v', 'r', 'k']
dropwhile:  ['r', 'd', 'v', 'a', 'r', 'k']
takewhile:  ['A', 'a']
compress:  ['A', 'r', 'd', 'a']
islice:  ['a', 'd', 'a']

用于映射的生成器函数

模块	函数	说明
`itertools`	`accumulate(it, func=sum)`	每次将前两个元素传给 func, 产出计算结果, 默认 func=sum
`(inner)`	`enumerate(iterable, start=0)`	每次产出(index, item), index 从 start 开始, 默认为 0
`(inner)`	`map(func, it1, it2, it3 ...)`	把 it 中的各个元素传给 func, 产出结果, 多个 it 时, 并行处理, func(it1, it2, it3 ...), 遍历次数取最小 it
`itertools`	`starmap(func, it)`	把 it 中各个元素传给 func, 产出结果, 输入的 it 应产出可迭代对象 iit, 以 func(*iit) 的形式调用 func

from itertools import accumulate, starmap
from operator import mul

sample = [5, 4, 2, 8, 7, 6, 3, 0, 9, 1]

print('accumulate sum(default): ', list(accumulate(sample)))
print('accumulate min: ', list(accumulate(sample, min)))
print('accumulate max: ', list(accumulate(sample, max)))
print('accumulate mul: ', list(accumulate(sample, mul)))

print('accumulate fact: ', list(accumulate(range(1, 11), mul)))

accumulate sum(default):  [5, 9, 11, 19, 26, 32, 35, 35, 44, 45]
accumulate min:  [5, 4, 2, 2, 2, 2, 2, 0, 0, 0]
accumulate max:  [5, 5, 5, 8, 8, 8, 8, 8, 9, 9]
accumulate mul:  [5, 20, 40, 320, 2240, 13440, 40320, 0, 0, 0]
accumulate fact:  [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]

print('enumerate: ', list(enumerate('Ryugu Reina', 1)))

print('map', list(map(mul, range(11), range(11))))
print('map', list(map(mul, range(11), range(3))))  # 取最小长度

print('starmap', list(starmap(mul, enumerate('Ryugu Reina', 1))))
print('starmap', list(starmap(lambda a, b: b / a, enumerate(accumulate(sample), 1))))

enumerate:  [(1, 'R'), (2, 'y'), (3, 'u'), (4, 'g'), (5, 'u'), (6, ' '), (7, 'R'), (8, 'e'), (9, 'i'), (10, 'n'), (11, 'a')]
map [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
map [0, 1, 4]
starmap ['R', 'yy', 'uuu', 'gggg', 'uuuuu', '      ', 'RRRRRRR', 'eeeeeeee', 'iiiiiiiii', 'nnnnnnnnnn', 'aaaaaaaaaaa']
starmap [5.0, 4.5, 3.6666666666666665, 4.75, 5.2, 5.333333333333333, 5.0, 4.375, 4.888888888888889, 4.5]

合并多个可迭代对象的生成器

模块	函数	说明
`itertools`	`chain(it1, it2, ...)`	将各个 it 拼接在一起
`itertools`	`chain.from_iterable(it1)`	将各个 it 产出的 iit 拼接在一起
`itertools`	`product(it1, it2, ..., repeat=1)`	计算笛卡尔积, repeat 重复处理多少次
`(inner)`	`zip(it1, it2, ...)`	将各个 it 中的元素并行组成元组
`itertools`	`zip_longest(it1, it2, ..., fillvalue=None)`	同上, 短的 it 用 fillvalue 填充

from itertools import chain, zip_longest, product
print('chain: ', list(chain('abc', range(2))))
print('chain.from_iterable:', list(chain.from_iterable(enumerate('abc'))))

print('zip: ', list(zip('abc', range(10))))
print('zip_longest: ', list(zip_longest('abc', range(10), fillvalue='q')))

chain:  ['a', 'b', 'c', 0, 1]
chain.from_iterable: [0, 'a', 1, 'b', 2, 'c']
zip:  [('a', 0), ('b', 1), ('c', 2)]
zip_longest:  [('a', 0), ('b', 1), ('c', 2), ('q', 3), ('q', 4), ('q', 5), ('q', 6), ('q', 7), ('q', 8), ('q', 9)]

print('product', list(product('ABC', range(2))))

suits = 'spades hearts diamonds clubs'.split()
print('product', list(product('AK', suits)))

print('product', list(product('ABC')))
print('product', list(product('AB', repeat=3)))  #<==> ('AB', 'AB', 'AB')

product [('A', 0), ('A', 1), ('B', 0), ('B', 1), ('C', 0), ('C', 1)]
product [('A', 'spades'), ('A', 'hearts'), ('A', 'diamonds'), ('A', 'clubs'), ('K', 'spades'), ('K', 'hearts'), ('K', 'diamonds'), ('K', 'clubs')]
product [('A',), ('B',), ('C',)]
product [('A', 'A', 'A'), ('A', 'A', 'B'), ('A', 'B', 'A'), ('A', 'B', 'B'), ('B', 'A', 'A'), ('B', 'A', 'B'), ('B', 'B', 'A'), ('B', 'B', 'B')]

把输入的各个元素扩展成多个输出元素的生成器

模块	函数	说明
`itertools`	`combinations(it, out_len)`	把 it 产出的 out_len 个元素组合在一起, 然后产出, 即 out_len 个元素的组合
`itertools`	`combinations_with_replacement(it, out_len)`	把 it 产出的 out_len 个元素组合在一起, 然后产出, 包含相同元素的组合
`itertools`	`count(start=0, step=1)`	从 start 开始产出数字, 步长为 step
`itertools`	`rpcle(it, out_len)`	把 it 产出的元素存储, 不断重复产出
`itertools`	`permutations(it, out_len=len(list(it)))`	把 out_len 个产出的元素排列在一起, 然后产出这些排列, 即 out_len 个元素的排列
`itertools`	`repeat(item, [times])`	重复产出 item, 除非提供 times

from itertools import count, cycle, repeat, combinations, combinations_with_replacement, permutations, islice

ct = count()
print('count: ', next(ct), next(ct), next(ct))

print('count & islice: ', list(islice(count(1, .3), 3)))

cy = cycle('RUA')
print('cycle: ', next(cy), next(cy), next(cy), next(cy), next(cy), next(cy))

rp = repeat(6)
print('repeat: ', next(rp), next(rp), next(rp))

print('repeat: ', list(repeat(8, 4)))

print('repeat: ', list(map(mul, range(11), repeat(5))))

print('combinations', list(combinations('ABC', 2)))
print('combinations', list(combinations_with_replacement('ABC', 2)))
print('combinations', list(combinations('ABC', 1)))

print('permutations', list(permutations('ABC', 2)))

count:  0 1 2
count & islice:  [1, 1.3, 1.6]
cycle:  R U A R U A
repeat:  6 6 6
repeat:  [8, 8, 8, 8]
repeat:  [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
combinations [('A', 'B'), ('A', 'C'), ('B', 'C')]
combinations [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]
combinations [('A',), ('B',), ('C',)]
permutations [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]

用于重新排列的元素生成器

模块	函数	说明
`itertools`	`groupby(it, key=None)`	产出由两个元素组成的元素 (key, group)
`(inner)`	`reversed(seq)`	倒序产出 seq 中的元素, seq 必须是序列, 或者实现了 `__reversed__`
`itertools`	`tee(it, n=2)`	产出由 n 个元素组成的元组

from itertools import groupby, tee

print(list(groupby('LLLLLLLAAAAAAGGGGGGGGGGGGGGGGGGGGGGGGG')))

for key, group in groupby('LLLLLLLAAAAAAGGGGGGGGGGGGGGGGGGGGGGGGG'):
    print(key, '-->', list(group))

print()
for key, group in groupby(['rua', 'aur', 'rau', 'aaaa', 'afeswr', 'sgse'], key=len):  # 按长度分组, 最好先排个序 -_-|
    print(key, '-->', list(group))

print()
for key, group in groupby(reversed(['rua', 'aur', 'rau', 'aaaa', 'afeswr', 'sgse']), key=len):  # 从右向左迭代列表
    print(key, '-->', list(group))

print()
g1, g2 = tee('ABC')  # 产出多个相同的迭代器
print('tee', next(g1), next(g2), next(g1))

[('L', <itertools._grouper object at 0x000001E3B5D93760>), ('A', <itertools._grouper object at 0x000001E3B5D93A30>), ('G', <itertools._grouper object at 0x000001E3B5D91390>)]
L --> ['L', 'L', 'L', 'L', 'L', 'L', 'L']
A --> ['A', 'A', 'A', 'A', 'A', 'A']
G --> ['G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G']

3 --> ['rua', 'aur', 'rau']
4 --> ['aaaa']
6 --> ['afeswr']
4 --> ['sgse']

4 --> ['sgse']
6 --> ['afeswr']
4 --> ['aaaa']
3 --> ['rau', 'aur', 'rua']

tee A A B

yield from

def chain_(*iterables):
    for it in iterables:
        for i in it:
            yield i

print(list(chain_('APPLE', range(3))))

['A', 'P', 'P', 'L', 'E', 0, 1, 2]

def chain_(*iterables):
    for it in iterables:
        yield from it

print(list(chain_('APPLE', range(3))))

['A', 'P', 'P', 'L', 'E', 0, 1, 2]

可迭代规约函数

模块	函数
`(inner)`	`all(it)`
`(inner)`	`any(it)`
`(inner)`	`max(it, [it2], ..., [key], [default])`
`(inner)`	`min(it, [it2], ..., [key], [default])`
`functools`	`reduce(func, it, [initial])`
`(inner)`	`sum(it, start=0)`

iter 函数

python 在迭代对象时会调用 iter(x)

iter(v, w) 其中, w 是哨符, 当生成器产出这个对象时, 会抛出 StopIteration, 停止迭代

from random import randint

def d6():
    return randint(1, 6)

d6_iter = iter(d6, 1)

for roll in d6_iter:  # 抛到 1 停止
    print(roll, end=' ')

3 6 2 4

__EOF__

本文作者： Zinc233

本文链接： https://www.cnblogs.com/Zinc233/p/FluentPython_S14.html

栏目列表