詳解Python中的排列組合生成器

在實際的開發(fā)場景中，經常需要遍歷多個數(shù)組中的元素，將它們組合在一起使用。要取完所有可能的組合，最基本的方法是使用嵌套的循環(huán)，有多少個數(shù)組就嵌套多少層循環(huán)。嵌套循環(huán)是基本的原理，但不夠簡潔，Python中有更優(yōu)雅的方式來實現(xiàn)這種功能。

在Python的內置模塊 functools 中，提供了高階類 product() ，用于實現(xiàn)多個可迭代對象（列表、字符串等）中元素的組合，返回可迭代對象中元素組合的笛卡爾積，效果相當于嵌套的循環(huán)。為了更直觀地看出效果，下面用代碼對比來看 product 的效果。

product 效果演示

# coding=utf-8
phone = ['iPhone', 'HuaWei', 'Mi']
number = [1, 2, 3]
color = ['白', '黑']
for p in phone:
    for n in number:
        for c in color:
            print(f'{p}{n}{c}', end='  ')

# 調用product實現(xiàn)元素組合，替代for循環(huán)
import itertools
for p, n, c in itertools.product(phone, number, color):
    print(f'{p}{n}{c}', end='  ')

Output：

iPhone1白  iPhone1黑  iPhone2白  iPhone2黑  iPhone3白  iPhone3黑  HuaWei1白  HuaWei1黑  HuaWei2白  HuaWei2黑  HuaWei3白  HuaWei3黑  Mi1白  Mi1黑  Mi2白  Mi2黑  Mi3白  Mi3黑  
iPhone1白  iPhone1黑  iPhone2白  iPhone2黑  iPhone3白  iPhone3黑  HuaWei1白  HuaWei1黑  HuaWei2白  HuaWei2黑  HuaWei3白  HuaWei3黑  Mi1白  Mi1黑  Mi2白  Mi2黑  Mi3白  Mi3黑 

可以看到，實現(xiàn)相同的功能，for循環(huán)使用了三層嵌套，而 product() 只需要一層循環(huán)。

product 的結果是生成器，生成器中的每個元素是一個元組，可以直接遍歷，也可以遍歷時解包取出元組中的數(shù)據(jù)，還可以與列表推導式配合使用等。

product 用法介紹

在源碼中，對 product 的描述是：Cartesian product of input iterables. Equivalent to nested for-loops. 翻譯成中文：求輸入可迭代對象的笛卡爾積，相當于嵌套的for循環(huán)。解釋一下這句話，第一，product 的輸入要是可迭代對象，如字符串、列表、元組等。第二，product 會將可迭代對象中的元素按笛卡爾積進行組合，相當于嵌套的循環(huán)。

如果不知道笛卡爾積是什么？這里簡單介紹一下。笛卡爾積（Cartesian product）是指數(shù)學中將兩個集合 X 和 Y 中的對象組合，第一個對象是 X 中的成員而第二個對象是 Y 中的成員，組合完所有可能的有序對。笛卡爾積又稱為直積，表示為 X×Y 。例如，假設集合 X={a, b} ，集合 Y={0, 1, 2} ，則兩個集合的笛卡爾積為 {(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)} 。

product 類就是專門為求笛卡爾積而量身定做的，用途一致，命名也一致（英文單詞一樣，見名知意）。

product 使用時可以傳入多個可迭代對象，結果會求所有可迭代對象累加的笛卡爾積。product 還有一個 repeat 參數(shù)，repeat 用于設置 product() 中每個可迭代對象的重復次數(shù)，默認值為1。如果只傳入一個可迭代對象，求自身的笛卡爾積，可以使用 repeat 參數(shù)指定重復多少次。例如，product(X, Y, repeat=2) 與 product(X, Y, X, Y) 相同，product(X, repeat=4) 與 product(X, X, X, X) 相同。

X = [1, 2]
Y = ['a', 'b']
itertools.product(X, repeat=4)
for combination in itertools.product(X, Y, X, Y):
    print(combination, end=' ')
    
print()
# 使用repeat參數(shù)設置重復次數(shù)
for combination in itertools.product(X, Y, repeat=2):
    print(combination, end=' ')

Output：

(1, 'a', 1, 'a') (1, 'a', 1, 'b') (1, 'a', 2, 'a') (1, 'a', 2, 'b') (1, 'b', 1, 'a') (1, 'b', 1, 'b') (1, 'b', 2, 'a') (1, 'b', 2, 'b') (2, 'a', 1, 'a') (2, 'a', 1, 'b') (2, 'a', 2, 'a') (2, 'a', 2, 'b') (2, 'b', 1, 'a') (2, 'b', 1, 'b') (2, 'b', 2, 'a') (2, 'b', 2, 'b') 
(1, 'a', 1, 'a') (1, 'a', 1, 'b') (1, 'a', 2, 'a') (1, 'a', 2, 'b') (1, 'b', 1, 'a') (1, 'b', 1, 'b') (1, 'b', 2, 'a') (1, 'b', 2, 'b') (2, 'a', 1, 'a') (2, 'a', 1, 'b') (2, 'a', 2, 'a') (2, 'a', 2, 'b') (2, 'b', 1, 'a') (2, 'b', 1, 'b') (2, 'b', 2, 'a') (2, 'b', 2, 'b') 

更多排列組合生成器及對比

在內置模塊 functools 中，用于將多個可迭代對象中的元素排列組合的類不只 product ，還有三個類提供了類似的功能，共同組成了一組非常有用的高階工具。下面依次介紹它們并進行對比。

permutations(iterable[, r]): Return successive r-length permutations of elements in the iterable. 返回可迭代對象中元素的長度為 r 的排列，元素不能重復。

combinations(iterable, r): Return successive r-length combinations of elements in the iterable. 返回可迭代對象中元素的長度為 r 的組合，元素不能重復。

combinations_with_replacement(iterable, r): Return successive r-length combinations of elements in the iterable allowing individual elements to have successive repeats. 返回可迭代對象中元素的長度為 r 的組合，允許元素重復。

product 是求笛卡爾積，permutations 是求排列，combinations 是求組合，combinations_with_replacement 是求組合但允許元素重復。它們分別是什么結果？相互之間有什么區(qū)別呢？通過下面的代碼可以進行對比。

# 笛卡爾積
for p in itertools.product('ABCD', repeat=2):
    print(p, end=' ')

print('\n', '-'*20)
# 排列
for pe in itertools.permutations('ABCD', 2):
    print(pe, end=' ')

print('\n', '-'*20)
# 組合
for c in itertools.combinations('ABCD', 2):
    print(c, end=' ')

print('\n', '-'*20)
# 組合，元素可以重復
for cr in itertools.combinations_with_replacement('ABCD', 2):
    print(cr, end=' ')

Output：

('A', 'A') ('A', 'B') ('A', 'C') ('A', 'D') 
('B', 'A') ('B', 'B') ('B', 'C') ('B', 'D')
('C', 'A') ('C', 'B') ('C', 'C') ('C', 'D') 
('D', 'A') ('D', 'B') ('D', 'C') ('D', 'D') 
 --------------------
('A', 'B') ('A', 'C') ('A', 'D') 
('B', 'A') ('B', 'C') ('B', 'D') 
('C', 'A') ('C', 'B') ('C', 'D') 
('D', 'A') ('D', 'B') ('D', 'C') 
 --------------------
('A', 'B') ('A', 'C') ('A', 'D') 
('B', 'C') ('B', 'D') ('C', 'D') 
 --------------------
('A', 'A') ('A', 'B') ('A', 'C') ('A', 'D') 
('B', 'B') ('B', 'C') ('B', 'D') 
('C', 'C') ('C', 'D') ('D', 'D') 

四個生成器返回的結果中都是元組，為了更直觀地對比效果，將結果整理如下：

product('ABCD', repeat=2)
AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD

permutations('ABCD', 2)
AB AC AD BA BC BD CA CB CD DA DB DC

combinations('ABCD', 2)
AB AC AD BC BD CD

combinations_with_replacement('ABCD', 2)
AA AB AC AD BB BC BD CC CD DD

permutations 與 product 對比，比 product 少了元素相同的情況，從可迭代對象中取出 r 個元素，元素順序相反屬于不同情況，結果中會保留。 combinations 與 permutations 對比，combinations 中元素順序相反的結果屬于相同情況，結果中不重復保留，也就是說 combinations （組合）是無序的， permutations （排列）是有序的。combinations_with_replacement 與 combinations 對比，combinations_with_replacement 中允許相同元素重復被取，結果中多了兩個元素相同的情況。

這三個類的參數(shù)都有且只有一個可迭代對象，不能同時傳入多個可迭代對象。另一個參數(shù) r 是從可迭代對象中選取 r 個元素來排列組合，permutations 的 r 不是必傳參數(shù)，默認為可迭代對象的長度，permutations 和 combinations 的結果中不允許元素重復，所以 r 大于可迭代對象長度時結果為空，combinations_with_replacement 的結果允許元素重復，r 可以大于可迭代對象長度。

總結

1.四個生成器的用法和區(qū)別已經介紹完，它們相當于工具箱中的一組高級工具，可以根據(jù)不同的場景選用，提高代碼的優(yōu)雅性。

2.在一些特殊場景，我們知道要用多層循環(huán)嵌套，但是循環(huán)的嵌套層數(shù)是動態(tài)的，導致無法下手寫循環(huán)代碼，此時可以巧妙地用 product 解決問題。這點后面我會在實際的問題中說明。

參考文檔：
[1] Python文檔標準庫functools：https://docs.python.org/2/library/itertools.html#

相關閱讀：

Python中的@cache有什么妙用？

??歡迎 點贊?? 收藏? 評論?? 關注? 如有錯誤敬請指正！

? 學Python，點擊下方名片關注我。?文章來源地址http://www.zghlxwxcb.cn/news/detail-495611.html

到了這里，關于詳解Python中的排列組合生成器的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！