資訊專欄INFORMATION COLUMN
摘要：介紹中實現了很多生成器函數，本篇主要介紹模塊中的生成器。會過濾掉中所有非元音字母，返回符合元素組成的生成器對象。函數等同于下面的生成器表達式用法。相關鏈接中的迭代器和生成器
介紹
Python3中實現了很多生成器函數，本篇主要介紹built-in、itertools、functools模塊中的生成器。
過濾器生成器本類生成器函數將iterable對象作為參數，在不改變該iterable對象的條件下，返回iterable子集的生成器對象。
filter(predicate, iterable)iterable的每一個元素會傳入predicate函數中判斷是否為True，該生成器會返回所有返回為True的元素組成的生成器對象。
def is_vowel(c):
return c.lower() in "aeiou"
word = "abcdefghijk"
print(list(filter(is_vowel, word)))
## output: ["a", "e", "i"]
filter會過濾掉word中所有非元音字母，返回符合元素組成的生成器對象。
注意：通過list(generator)可以將生成器對象轉換為列表，但如果是無限生成器list將會產生大量元素導致出錯。
filter函數等同于下面的生成器表達式用法。
(item for item in iterable if function(item))
如果filter的第一個參數為None，則不過濾返回全部，等同于下面的生成器表達式用法。
(item for item in iterable if item)itertools.filterfalse(predicate, iterable)
該函數和filter類似，區別是過濾掉predicate返回True的元素。
print(list(itertools.filterfalse(is_vowel, word))) ## output: ["b", "c", "d", "f", "g", "h", "j", "k"]itertools.takewhile(predicate, iterable)
該函數連續迭代iterable對象中的元素，并用predicate函數判斷，若predicate返回為True，將不斷產出該元素，直到predicate返回False，過濾了iterable后面不符合的元素。
print(list(itertools.takewhile(is_vowel, word))) ## output: ["a"]itertools.dropwhile(predicate, iterable)
該函數與itertools.takewhile相反，過濾了iterable對象前面符合predicate返回True的元素，保留后面的子集。
print(list(itertools.dropwhile(is_vowel, word))) ## output: ["b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]itertools.compress(iterable, selectors)
該函數中的selectors也是一個迭代對象，compress根絕selectors中的值(0/1或是True/False)判斷是否過濾iterable中的元素。
print(list(itertools.compress(word, [1, 0, 1, 0]))) ## output: ["a", "c"]
如果selectors長度不夠，則iterable后面的對象全部被過濾掉。
itertools.islice(iterable, stop)根據傳入參數的個數不同，該函數另一種寫法是itertools.islice(iterable, start, stop[, step])，islice函數類似python中的分片操作：list[start:stop:step]。
print(list(itertools.islice(word, 4))) ## output: ["a", "b", "c", "d"] print(list(itertools.islice(word, 4, 8))) ## output: ["e", "f", "g", "h"] print(list(itertools.islice(word, 4, 8, 2))) ## output: ["e", "g"]映射生成器
該類生成器主要對于傳入的一個或多個迭代對象中的每一個元素進行操作，返回映射后的生成器對象。
map(func, *iterables, timeout=None, chunksize=1)map是Python中常用的原生生成器，將迭代對象中的每一個元素傳入func進行映射返回新的迭代對象。如果有n個iterable對象，則func的參數則為n個，后面的timeout和chunksize參數涉及到異步，本篇將不闡述。
print(list(map(lambda x: x.upper(), word))) print([x.upper() for x in word]) ## output: ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K"]
上面第一行中的map將word中的每個元素轉換為大寫，和第二行中的列表生成式用法相似。
print(list(map(lambda x, y: (x, y), word, word)))
print(list(zip(word, word)))
## output: [("a", "a"), ("b", "b"), ("c", "c") ... ("k", "k")]
當有兩個iterable傳入時，func將需要處理傳入的兩個參數，第一行的用法和zip函數的作用相似。
itertools.starmap(function, iterable)當iterable中的元素也是個迭代對象時，如果使用map函數，需要在函數內部實現解壓操作獲取到單個元素，而startmap將iterable中的元素按function(*item)方式傳入，我們可以在定義function的參數時完成解壓操作。舉例，如果想輸入序列[(2,5), (3,2), (10,3)]來得到一個每個元組元素的和的序列[7, 5, 13], 若使用map方法，fun函數將會復雜，而使用startmap則只需要傳遞一個add函數作為startmap參數，元組解壓后的兩個值將傳入add函數作為參數。
from operator import add print(list(map(lambda x: add(x[0], x[1]), [(2, 5), (3, 2), (10, 3)]))) print(list(itertools.starmap(add, [(2, 5), (3, 2), (10, 3)]))) ## output: [7, 5, 13]enumerate(iterable, start=0)
enumerate函數也是常見的生成器函數，它的主要用法是提供for-in循環中的索引。若設置start參數，索引將從start值開始逐1增加。
for i, c in enumerate(word, 2):
print(i, c)
itertools.accumulate(iterable[, func])
accumulate函數將通過func函數完成逐步累加操作，默認func為operator.add。下面用例子進行說明。
sample = [1, 2, 3, 4, 5]
print(list(itertools.accumulate(sample)))
## output: [1, 3, 6, 10, 15]
print(list(itertools.accumulate(sample, mul)))
## output: [1, 2, 6, 24, 120]
print(list(itertools.accumulate(sample, mul)))
## output: [1, 2, 6, 24, 120]
print(list(itertools.accumulate(sample, min)))
## output: [1, 1, 1, 1, 1]
print(list(itertools.accumulate(sample, max)))
## output: [1, 2, 3, 4, 5]
print(list(itertools.starmap(lambda x, y: y/x,
enumerate(itertools.accumulate(sample), 1))))
## output: [1.0, 1.5, 2.0, 2.5, 3.0]
合并生成器
合并生成器接收多個可迭代對象參數，將他們組合后返回新的生成器對象。
itertools.chain(*iterables)chain生成器函數接收多個可迭代對象參數，將他們按順序組合成新的生成器對象返回。
print(list(itertools.chain(range(3), range(3, 7)))) ## output: [0, 1, 2, 3, 4, 5, 6]itertools.chain.from_iterable(iterable)
chain.from_iterable函數接收一個元素為可迭對象的可迭代對象，將該所有可迭代的元素拆開，重新按順序組合成一個新的生成器，新的生成器產出的元素為iterable參數某個元素的解壓，chain.from_iterable功能更像是逐層解壓迭代對象。
a, b = [1,2], [3,4] iterable= [[a,b],[a,b]] print(iterable) new_iterable = list(itertools.chain.from_iterable(iterable)) print(new_iterable) print(list(itertools.chain.from_iterable(new_iterable))) ## output: ## [[[1, 2], [3, 4]], [[1, 2], [3, 4]]] ## [[1, 2], [3, 4], [1, 2], [3, 4]] ## [1, 2, 3, 4, 1, 2, 3, 4]zip(*iterables)
zip函數接收多個iterable參數，并提取每個iterable元素組成元組，返回這些元組組成的生成器對象。
iterable1 = "abcd"
iterable2 = [1, 2, 3]
iterable3 = [10, 20, 30, 40]
print(list(zip(iterable1, iterable2, iterable3)))
## output:
## [("a", 1, 10), ("b", 2, 20), ("c", 3, 30)]
如果多個iterable元素個數不一致，zip會在最短的iterable耗盡后停止。
我們可以通過zip函數生成一個字典對象
keys = "abc"
values = [1, 2, 3]
print(dict(zip(keys, values)))
## output: {"a": 1, "b": 2, "c": 3}
itertools.zip_longest(*iterables, fillvalue=None)
zip_longes函數作用和zip類似，在zip中如果某個iterable對象耗盡，生成器將就此停止，而zip_longest函數將為耗盡的iterable補充fillvalue值。
iterable1 = "abcd"
iterable2 = [1, 2, 3]
iterable3 = [10, 20, 30, 40]
print(list(itertools.zip_longest(iterable1, iterable2, iterable3, fillvalue=0)))
## output: [("a", 1, 10), ("b", 2, 20), ("c", 3, 30), ("d", 0, 40)]
itertools.product(*iterables, repeat=1)
product函數計算所有iterable的笛卡爾積，它像是生成器表達式中處理嵌套循環的步驟，product(a, b)可以等同于((x, y) for x in a for y in b)。
repeat相當于擴展了iterables, product(a, b, repeat=2)相當于product(a, b, a, b)
a = (0, 1) b = (2, 3) print(list(itertools.product(a, b))) print(list(itertools.product(a, repeat=2))) ## output: ## [(0, 2), (0, 3), (1, 2), (1, 3)] ## [(0, 0), (0, 1), (1, 0), (1, 1)]擴展生成器
擴展生成器將傳進的單一對象進行擴展，生成更多元素組成的生成器對象。
itertools.repeat(object[, times])repeat函數可以接收一個對象(可以不是可迭代對象), 根據非必選參數times，生成元素個數為times的生成器，如果不提供times參數，將生成無限生成器。
print(list(itertools.repeat(1, 3)))
print(list(itertools.repeat((1, 2), 3)))
print(list(zip(range(1, 4), itertools.repeat("a"))))
print([1, 2] * 3)
"""output:
[1, 1, 1]
[(1, 2), (1, 2), (1, 2)]
[(1, "a"), (2, "a"), (3, "a")]
[1, 2, 1, 2, 1, 2]
"""
注意repeat()和列表乘法的區別，通過上文提到的itertools.chain.from_iterable函數結合repeat函數可以實現列表乘法。
lst = [1, 2, 3] g = itertools.repeat(lst, 3) print(list(itertools.chain.from_iterable(g))) print(lst * 3) """output [1, 2, 3, 1, 2, 3, 1, 2, 3] [1, 2, 3, 1, 2, 3, 1, 2, 3] """itertools.cycle(iterable)
cycle函數將傳進的iterable可迭代對象首尾相連形成循環，生成無限生成器。
# cycle("ABCD") --> A B C D A B C D A B C D ...
itertools.count(start=0, step=1)
計數器函數，start和step參數可以為小數，直接看例子。
g = itertools.count(1.2, 2.5) print(next(g)) print(next(g)) print(next(g)) """output: 1.2 3.7 6.2 """
上文提到的enumerate生成器函數可以通過map和count來實現。
for i, v in map(lambda x, y: (x, y), itertools.count(), range(3, 10)):
print(i, v)
我們可以通過調整count函數讓索引i的值更加靈活。
Python中的range(start, stop[, step])函數可以生成一個序列，但是要求輸入參數必須為整數，可以通過count函數實現一個可以接收小數的新range。
def range_new(start, stop, step):
for i in itertools.count(start, step):
if i >= stop:
break
yield i
print(list(range_new(1, 5.5, 1.5)))
## output: [1, 2.5, 4.0]
排列組合生成器
以下三個函數可以實現迭代對象的排列組合
itertools.combinations(iterable, r)
非重復組合
print(list(itertools.combinations("ABC", 1)))
print(list(itertools.combinations("ABC", 2)))
print(list(itertools.combinations("ABC", 3)))
"""output:
[("A",), ("B",), ("C",)]
[("A", "B"), ("A", "C"), ("B", "C")]
[("A", "B", "C")]
"""
itertools.combinations_with_replacement(iterable, r)
重復組合
print(list(itertools.combinations_with_replacement("ABC", 1)))
print(list(itertools.combinations_with_replacement("ABC", 2)))
print(list(itertools.combinations_with_replacement("ABC", 3)))
"""output:
[("A",), ("B",), ("C",)]
[("A", "A"), ("A", "B"), ("A", "C"), ("B", "B"), ("B", "C"), ("C", "C")]
[("A", "A", "A"), ("A", "A", "B"), ("A", "A", "C"), ("A", "B", "B"), ("A", "B", "C"), ("A", "C", "C"), ("B", "B", "B"), ("B", "B", "C"), ("B", "C", "C"), ("C", "C", "C")]
"""
itertools.permutations(iterable, r=None)
全排列
print(list(itertools.permutations("ABC", 1)))
print(list(itertools.permutations("ABC", 2)))
print(list(itertools.permutations("ABC", 3)))
"""output:
[("A",), ("B",), ("C",)]
[("A", "B"), ("A", "C"), ("B", "A"), ("B", "C"), ("C", "A"), ("C", "B")]
[("A", "B", "C"), ("A", "C", "B"), ("B", "A", "C"), ("B", "C", "A"), ("C", "A", "B"), ("C", "B", "A")]
"""
對比itertools.product(*iterables, repeat=1)函數
print(list(itertools.product("ABC", repeat=1)))
print(list(itertools.product("ABC", repeat=2)))
"""output:
[("A",), ("B",), ("C",)]
[("A", "A"), ("A", "B"), ("A", "C"), ("B", "A"), ("B", "B"), ("B", "C"), ("C", "A"), ("C", "B"), ("C", "C")]
"""
整理生成器
此類生成器將傳入的可迭代對象經過整理后，以生成器的形式全部返回。
itertools.groupby(iterable, key=None)groupby生成器可以根據key，將iterable分組，返回的生成器的元素為(key, iterable)的元組形式。掃描整個序列并且查找連續相同值（或者根據指定 key 函數返回值相同）的元素序列。 在每次迭代的時候，它會返回一個值和一個迭代器對象， 這個迭代器對象可以生成元素值全部等于上面那個值的組中所有對象。
g = itertools.groupby("LLLLAAGGG")
for char, group in g:
print(char, "->", list(group))
"""output:
L -> ["L", "L", "L", "L"]
A -> ["A", "A"]
G -> ["G", "G", "G"]
"""
rows = [
{"address": "5412 N CLARK", "date": "07/01/2012"},
{"address": "5148 N CLARK", "date": "07/04/2012"},
{"address": "5800 E 58TH", "date": "07/02/2012"},
{"address": "2122 N CLARK", "date": "07/03/2012"},
{"address": "5645 N RAVENSWOOD", "date": "07/02/2012"},
{"address": "1060 W ADDISON", "date": "07/02/2012"},
{"address": "4801 N BROADWAY", "date": "07/01/2012"},
{"address": "1039 W GRANVILLE", "date": "07/04/2012"},
]
rows.sort(key=itemgetter("date"))
g = itertools.groupby(rows, itemgetter("date"))
for char, group in g:
print(char, "->", list(group))
"""output:
07/01/2012 -> [{"address": "5412 N CLARK", "date": "07/01/2012"}, {"address": "4801 N BROADWAY", "date": "07/01/2012"}]
07/02/2012 -> [{"address": "5800 E 58TH", "date": "07/02/2012"}, {"address": "5645 N RAVENSWOOD", "date": "07/02/2012"}, {"address": "1060 W ADDISON", "date": "07/02/2012"}]
07/03/2012 -> [{"address": "2122 N CLARK", "date": "07/03/2012"}]
07/04/2012 -> [{"address": "5148 N CLARK", "date": "07/04/2012"}, {"address": "1039 W GRANVILLE", "date": "07/04/2012"}]
"""
groupby() 僅僅檢查連續的元素，因此在調用之前需要根據指定的字段將數據排序。
reversed(seq)reversed函數接收一個序列（實現sequence相關協議，已知長度）
print(list(reversed(range(5)))) ## output: [4, 3, 2, 1, 0]itertools.tee(iterable, n=2)
tee函數返回單個iterable對象的n個獨立迭代器
g1, g2 = itertools.tee("ABC")
print(next(g1), next(g2))
print(next(g1), next(g2))
print(list(zip(*itertools.tee("ABC"))))
"""output
A A
B B
[("A", "A"), ("B", "B"), ("C", "C")]
"""
縮減生成器
接收一個迭代對象，處理只返回一個單一值。
functools.reduce(function, iterable，initializer=None)function參數是一個接收兩個參數的函數function(x, y)，reduce函數將上一次function得到的返回值作為參數x，將iterable的下一次迭代值作為參數y傳進function計算，初始時x的值為initializer值(若initializer為None，初始值則為iterable的第一個元素值)。循環直到iterable耗盡返回最終值。
reduce的基本實現大概為一下代碼:
def reduce(function, iterable, initializer=None):
it = iter(iterable)
if initializer is None:
value = next(it)
else:
value = initializer
for element in it:
value = function(value, element)
return value
print(functools.reduce(add, [1, 2, 3, 4, 5])) ## output: 15
常用的min和max函數都可以用reduce實現
def min_reduce(iterable):
return functools.reduce(lambda x, y: x if x < y else y, iterable)
def max_reduce(iterable):
return functools.reduce(lambda x, y: x if x > y else y, iterable)
print(min_reduce([4, 6, 6, 78]))
print(max_reduce([4, 6, 6, 78]))
"""output
4
78
"""
除此之外any和all函數原理也是類似，不再闡述。
總結本篇按照分類介紹了python庫中的一些常用的生成器，可以通過不同場景選擇不同的生成器工具，將它們組合靈活運用。
相關鏈接Python3中的迭代器和生成器
文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。
轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/42621.html
摘要：常規的使用來統計一段代碼運行時間的例子輸出結果總結其實是一門特別人性化的語言，但凡在工程中經常遇到的問題，處理起來比較棘手的模式基本都有對應的比較優雅的解決方案。 python的高級特性 名詞與翻譯對照表 generator 生成器 iterator 迭代器 collection 集合 pack/unpack 打包/解包 decorator 裝飾器 context manager ...
摘要：比較的是兩個對象的內容是并發編程之協程異步后端掘金引言隨著的盛行，相信大家今年多多少少都聽到了異步編程這個概念。使用進行并發編程篇二掘金我們今天繼續深入學習。 python 之機器學習庫 scikit-learn - 后端 - 掘金一、 加載sklearn中的數據集datasets from sklearn import datasets iris = datasets.load_i...
摘要：將每一行作為返回，其中是每行中的列名。對于每一行，都會生成一個對象，其中包含和列中的值。它返回一個迭代器，是迭代結果都為的情況。深度解析至此全劇終。 簡單實戰 大家好，我又來了，在經過之前兩篇文章的介紹后相信大家對itertools的一些常見的好用的方法有了一個大致的了解，我自己在學完之后仿照別人的例子進行了真實場景下的模擬練習，今天和大家一起分享，有很多部分還可以優化，希望有更好主意...
閱讀 3569·2021-08-02 13:41
閱讀 2429·2019-08-30 15:56
閱讀 1526·2019-08-30 11:17
閱讀 1182·2019-08-29 15:18
閱讀 585·2019-08-29 11:10
閱讀 2680·2019-08-26 13:52
閱讀 516·2019-08-26 13:22
閱讀 2960·2019-08-23 15:41
