python3-cookbook筆記：第四章 迭代器與生成器

python3-cookbook中每個小節以問題、解決方案和討論三個部分探討了Python3在某類問題中的最優解決方式，或者說是探討Python3本身的資料結構、函式、類等特性在某類問題上如何更好地使用，這本書對于加深Python3的理解和提升Python編程能力的都有顯著幫助，特別是對怎么提高Python程式的性能會有很好的幫助，如果有時間的話強烈建議看一下，
本文為學習筆記，文中的內容只是根據自己的作業需要和平時使用寫了書中的部分內容，并且文中的示例代碼大多直接貼的原文代碼，當然，代碼多數都在Python3.6的環境上都驗證過了的，不同領域的編程關注點也會有所不同，有興趣的可以去看全文，
python3-cookbook：https://python3-cookbook.readthedocs.io/zh_CN/latest/index.html

 4.2 代理迭代

如果想要迭代一個不可迭代物件，只需要為這個物件定義一個__iter__()方法即可，__iter__()方法必須回傳一個實作了__next__()方法的迭代器物件，

class Node:
    """Node類似一個樹節點"""
    def __init__(self, value):
        self._value = value
        self._children = []

    def __repr__(self):
        return 'Node({!r})'.format(self._value)

    def add_child(self, node):
        self._children.append(node)

    def __iter__(self):
        # iter(s)只是簡單的通過呼叫s.__iter__()方法來回傳對應的迭代器物件，就跟len(s)會呼叫s.__len__()原理是一樣的
        return iter(self._children)


if __name__ == '__main__':
    root = Node(0)
    child1 = Node(1)
    child2 = Node(2)
    root.add_child(child1)
    root.add_child(child2)
    # 輸出當前節點下其他節點的列印值
    for ch in root:
        print(ch)

Node(1)
Node(2)

4.4 實作迭代器協議

想在迭代某個物件時按照自己的方式來迭代，最簡單的方法就是使用yield定義一個生成器函式，但是需要注意的是，在迭代操作時，如果不是使用for回圈，就需要先使用iter()函式轉換一下，再去迭代它，比如以下示例代碼中在樹形結構中定義一個深度優先的生成器函式：

class Node:
    """Node類似一個樹節點"""

    def __init__(self, value):
        self._value = value
        self._children = []

    def __repr__(self):
        return 'Node({!r})'.format(self._value)

    def add_child(self, node):
        self._children.append(node)

    def __iter__(self):
        # 回傳一個可以迭代子節點的迭代器
        return iter(self._children)

    def depth_first(self):
        """深度優先遍歷節點"""
        # 使用yield定義一個生成器
        yield self
        for c in self:
            # 注意這里是yield from
            yield from c.depth_first()


if __name__ == '__main__':
    root = Node(0)
    child1 = Node(1)
    child2 = Node(2)
    root.add_child(child1)
    root.add_child(child2)
    child1.add_child(Node(3))
    child1.add_child(Node(4))
    child2.add_child(Node(5))
    # 以深度優先原則遍歷節點
    for ch in root.depth_first():
        print(ch)

Node(0)
Node(1)
Node(3)
Node(4)
Node(2)
Node(5)

4.7 迭代器切片

想要對迭代物件切片，或者說只想要其中某一段，可以使用itertools.islice，但是需要注意的是這樣會消耗掉這個迭代器，之后就不能使用了，因為迭代器是不可逆的，

>>> def count(n):
    while True:
        yield n
        n += 1

        
>>> c = count(0)
>>> c[10:20]
Traceback (most recent call last):
  File "<pyshell#105>", line 1, in <module>
    c[10:20]
TypeError: 'generator' object is not subscriptable
>>> import itertools
>>> for x in itertools.islice(c, 10, 20):
    print(x)

    
10
11
12
13
14
15
16
17
18
19
>>> 

4.8 跳過可迭代物件的開始部分

在遍歷一個可迭代物件時，想要跳過開始的某些元素，可以使用itertools.dropwhile，為它傳入一個函式和可迭代物件，如果知道確切的索引位置，也可以使用itertools.islice，

>>> from itertools import dropwhile, islice
>>> items = ['a', 'b', 'c', 1, 4, 10, 15]
>>> for x in dropwhile(lambda i: isinstance(i, str), items):
    print(x)

    
1
4
10
15
>>> for x in islice(items, 3, None):
    print(x)

    
1
4
10
15
>>> 

4.11 同時迭代多個序列

內置函式zip的使用有時候很方便，但是它只會遍歷到最短的那個序列完就結束了，如果想要遍歷完最長的那個序列，可以使用itertools.zip_longest()，

>>> a = [1, 2, 3]
>>> b = ['w', 'x', 'y', 'z']
>>> for i in zip(a,b):
    print(i)

    
(1, 'w')
(2, 'x')
(3, 'y')
>>> from itertools import zip_longest
>>> for i in zip_longest(a, b):
    print(i)

    
(1, 'w')
(2, 'x')
(3, 'y')
(None, 'z')
>>> 

4.12 不同集合上元素的迭代

想要遍歷多個可迭代物件中的元素，但又不想單獨遍歷每個物件，或者把它們都整合在一個物件中再遍歷，此時可以使用itertools.chain()，

>>> from itertools import chain
>>> a = [1, 2, 3, 4]
>>> b = ['x', 'y', 'z']
>>> for x in chain(a, b):
    print(x)

    
1
2
3
4
x
y
z
>>> 

4.14 展開嵌套的序列

展開嵌套的序列，這個問題或許有其他的解決方式，但文中使用遞回生成器的方式還是很很不錯的，

from collections import Iterable


def flatten(items, ignore_types=(str, bytes)):
    for x in items:
        if isinstance(x, Iterable) and not isinstance(x, ignore_types):
            yield from flatten(x)
        else:
            yield x


items = [1, 2, [3, 4, [5, 6], 7], 8]
for x in flatten(items):
    print(x)

1
2
3
4
5
6
7
8

4.15 順序迭代合并后的排序迭代物件

你有多個可迭代物件，想要將它們合并排序后遍歷里面的元素，那么可以使用heapq.merge(*iterables, key=None, reverse=False)，但是需要注意，使用這個函式前每個可迭代物件都要預先排序好，因為這個函式只是每次從多個序列的第一個元素中選出最小或最大的元素，并且因為它是可迭代的，意味著它可以處理非常長的序列而不用擔心記憶體消耗，

>>> import heapq
>>> a = [1, 4, 7, 10]  # 預先排好序的序列
>>> b = [2, 5, 6, 11]
>>> for c in heapq.merge(a, b):
    print(c)

    
1
2
4
5
6
7
10
11
>>> 

4.16 迭代器代替while無限回圈

某些情況下可以使用iter創建一個迭代器來替換while回圈，iter函式它接受一個可選的 callable 物件和一個標記(結尾)值作為輸入引數，當以這種方式使用iter的時候，它會創建一個迭代器， 這個迭代器會不斷呼叫 callable 物件直到回傳值和標記值相等為止，雖然文中并沒有說這兩種方式在性能上有什么差別，但是從代碼撰寫上看，iter的方式會更加優雅些，

CHUNKSIZE = 8192

def reader(s):
    while True:
        # 接收資料
        data =https://www.cnblogs.com/guyuyun/p/ s.recv(CHUNKSIZE)
        if data =https://www.cnblogs.com/guyuyun/p/= b'':
            break
        # 處理資料
        process_data(data)

def reader2(s):
    for data in iter(lambda: s.recv(CHUNKSIZE), b''):
        # 處理資料
        process_data(data)

標籤：Python

上一篇：根據詞頻生成詞云(Python wordcloud實作)

下一篇：python變數加逗號,的含義