考えられるすべての方法でリストをペアに分割する方法

87

私はリストを持っています（簡単にするために6つの要素を言います）

L = [0, 1, 2, 3, 4, 5]

そして私はそれをすべての可能な方法でペアにチャンクしたいと思います。いくつかの構成を示します。

[(0, 1), (2, 3), (4, 5)]
[(0, 1), (2, 4), (3, 5)]
[(0, 1), (2, 5), (3, 4)]

等々。ここ(a, b) = (b, a)とペアの順序は重要ではありません。

[(0, 1), (2, 3), (4, 5)] = [(0, 1), (4, 5), (2, 3)]

このような構成の総数は1*3*5*...*(N-1)どこN私のリストの長さです。

任意の可能なすべての構成を提供するジェネレーターをPythonで作成するにはどうすればよいNですか？

python 
— アダム
ソース
2
itertoolsまだ見ていない場合は、その標準モジュールを確認することをお勧めします。関数は、この問題は（おそらくを支援することがあるはずpermutations、combinationsまたはproduct機能）。
— dappawit 2011年
順序が重要でない場合は、おそらくセットまたはフリーズセットを使用する必要があります。
— asmeurer 2013
組み合わせ論の言語では、（完全グラフで）特定のセットに対してすべての完全一致を生成する必要があります。
— バレンタス2015

回答:

106

を見てくださいitertools.combinations。

matt@stanley:~$ python
Python 2.6.5 (r265:79063, Apr 16 2010, 13:57:41) 
[GCC 4.4.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import itertools
>>> list(itertools.combinations(range(6), 2))
[(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]
— マットジョイナー
ソース
47
それは質問が尋ねるものではありません...しかし、たまたま私が探していたものです:)
— gatoatigrado 2012年
5
なぜこれが最も賛成の答えなのですか？質問に答えていないようです。
— Halbort 2016年
11
それはこのサイトに来るほとんどの人々の質問に答えます。
— ラジコン2016
2
@Halbortタイトルには答えますが、多くの人に役立ちます。さらに、これは確かにOPがとにかく持っていた主な問題です。これが反復可能なの組み合わせです。今度は好きなようにチャンクします。
— OJFord 2017年
1
@OJFordこれがタイトルに答えるとは思いません。リストを「分割」するということは、元のサブセットがばらばらになってしまうことを意味すると思います。この答えは、「リストからすべての可能なペアを生成する方法」に答えていると私は主張します。しかし、これがほとんどの人が求めている答えであるというのは事実かもしれません。
— ザック
40

標準ライブラリには、必要なことを正確に実行する関数はないと思います。使用itertools.combinationsするだけで、考えられるすべての個々のペアのリストを取得できますが、実際には、すべての有効なペアの組み合わせの問題を解決するわけではありません。

これは次の方法で簡単に解決できます。

import itertools
def all_pairs(lst):
    for p in itertools.permutations(lst):
        i = iter(p)
        yield zip(i,i)

ただし、これにより、（a、b）と（b、a）が異なるものとして扱われ、ペアのすべての順序が示されるため、重複が発生します。結局、結果をフィルタリングするよりも、これを最初からコーディングする方が簡単だと思ったので、これが正しい関数です。

def all_pairs(lst):
    if len(lst) < 2:
        yield []
        return
    if len(lst) % 2 == 1:
        # Handle odd length list
        for i in range(len(lst)):
            for result in all_pairs(lst[:i] + lst[i+1:]):
                yield result
    else:
        a = lst[0]
        for i in range(1,len(lst)):
            pair = (a,lst[i])
            for rest in all_pairs(lst[1:i]+lst[i+1:]):
                yield [pair] + rest

再帰的であるため、長いリストでスタックの問題が発生しますが、それ以外の場合は必要なことを実行します。

>>> for x in all_pairs（[0,1,2,3,4,5]）：
    xを印刷

[（0、1）、（2、3）、（4、5）]
[（0、1）、（2、4）、（3、5）]
[（0、1）、（2、5）、（3、4）]
[（0、2）、（1、3）、（4、5）]
[（0、2）、（1、4）、（3、5）]
[（0、2）、（1、5）、（3、4）]
[（0、3）、（1、2）、（4、5）]
[（0、3）、（1、4）、（2、5）]
[（0、3）、（1、5）、（2、4）]
[（0、4）、（1、2）、（3、5）]
[（0、4）、（1、3）、（2、5）]
[（0、4）、（1、5）、（2、3）]
[（0、5）、（1、2）、（3、4）]
[（0、5）、（1、3）、（2、4）]
[（0、5）、（1、4）、（2、3）]
— シャン
ソース
16
デフォルトでは、Pythonには1000回の呼び出しの深さのリターンスタックがあります。数字のペアで繰り返し発生するため、リストの長さがほぼ2000アイテムになるまで、これは問題にはなりません。たった50アイテムで、5 * 10 ^ 31以上の組み合わせが得られます。スタックの深さが問題になるずっと前に、10億年の計算に遭遇するでしょう。
— Hugh Bothwell 2011年
4
これはこれを書くための古典的な方法です。
— hughdbrown 2011年
この回答には問題があるようです（Python 2.7.11を実行しています）。まったく同じコードを実行した場合の出力の最初の行は、次のようになります[(0, 1), (2, 3), 4]。
— アルセウコスタ2016
2
申し訳ありませんが、答えは最善の意図で書かれていると確信していますが、奇数の長さのすべての入力リストでは正しくありません
— Moritz Walter
2
@MoritzWalter奇数の長さの入力リストの出力は何を期待していましたか？私にとって、リストの長さが奇数の場合、ペアに分割できなかったため、この質問は意味がありません。
— ザック
15

これはどう：

items = ["me", "you", "him"]
[(items[i],items[j]) for i in range(len(items)) for j in range(i+1, len(items))]

[('me', 'you'), ('me', 'him'), ('you', 'him')]

または 

items = [1, 2, 3, 5, 6]
[(items[i],items[j]) for i in range(len(items)) for j in range(i+1, len(items))]

[(1, 2), (1, 3), (1, 5), (1, 6), (2, 3), (2, 5), (2, 6), (3, 5), (3, 6), (5, 6)]
— lefterav
ソース
1
まあ、それはペアのセットをグループ化しません
— Janus Troelsen 2013年
10

概念的には@shangの回答に似ていますが、グループのサイズが2であるとは想定していません。

import itertools

def generate_groups(lst, n):
    if not lst:
        yield []
    else:
        for group in (((lst[0],) + xs) for xs in itertools.combinations(lst[1:], n-1)):
            for groups in generate_groups([x for x in lst if x not in group], n):
                yield [group] + groups

pprint(list(generate_groups([0, 1, 2, 3, 4, 5], 2)))

これにより、次の結果が得られます。

[[(0, 1), (2, 3), (4, 5)],
 [(0, 1), (2, 4), (3, 5)],
 [(0, 1), (2, 5), (3, 4)],
 [(0, 2), (1, 3), (4, 5)],
 [(0, 2), (1, 4), (3, 5)],
 [(0, 2), (1, 5), (3, 4)],
 [(0, 3), (1, 2), (4, 5)],
 [(0, 3), (1, 4), (2, 5)],
 [(0, 3), (1, 5), (2, 4)],
 [(0, 4), (1, 2), (3, 5)],
 [(0, 4), (1, 3), (2, 5)],
 [(0, 4), (1, 5), (2, 3)],
 [(0, 5), (1, 2), (3, 4)],
 [(0, 5), (1, 3), (2, 4)],
 [(0, 5), (1, 4), (2, 3)]]
— トクランド
ソース
5

私の上司はおそらくこの楽しい問題に少し時間を費やしたことに満足することはないでしょうが、これは再帰を必要とせず、を使用する素晴らしい解決策ですitertools.product。それはdocstringで説明されています:)。結果は問題ないようですが、あまりテストしていません。

import itertools


def all_pairs(lst):
    """Generate all sets of unique pairs from a list `lst`.

    This is equivalent to all _partitions_ of `lst` (considered as an indexed
    set) which have 2 elements in each partition.

    Recall how we compute the total number of such partitions. Starting with
    a list

    [1, 2, 3, 4, 5, 6]

    one takes off the first element, and chooses its pair [from any of the
    remaining 5].  For example, we might choose our first pair to be (1, 4).
    Then, we take off the next element, 2, and choose which element it is
    paired to (say, 3). So, there are 5 * 3 * 1 = 15 such partitions.

    That sounds like a lot of nested loops (i.e. recursion), because 1 could
    pick 2, in which case our next element is 3. But, if one abstracts "what
    the next element is", and instead just thinks of what index it is in the
    remaining list, our choices are static and can be aided by the
    itertools.product() function.
    """
    N = len(lst)
    choice_indices = itertools.product(*[
        xrange(k) for k in reversed(xrange(1, N, 2)) ])

    for choice in choice_indices:
        # calculate the list corresponding to the choices
        tmp = lst[:]
        result = []
        for index in choice:
            result.append( (tmp.pop(0), tmp.pop(index)) )
        yield result

乾杯！

— ガトアティグラド
ソース
より正確な名前があるべきall_pairingsとxrange置き換えてくださいrangePythonの3中
— Valentas
実装はクリーンですが、要素数が奇数のリストでは機能しません。
— MattiaRossi20年
4

次の再帰ジェネレーター関数を試してください。

def pairs_gen(L):
    if len(L) == 2:
        yield [(L[0], L[1])]
    else:
        first = L.pop(0)
        for i, e in enumerate(L):
            second = L.pop(i)
            for list_of_pairs in pairs_gen(L):
                list_of_pairs.insert(0, (first, second))
                yield list_of_pairs
            L.insert(i, second)
        L.insert(0, first)

使用例：

>>> for pairs in pairs_gen([0, 1, 2, 3, 4, 5]):
...     print pairs
...
[(0, 1), (2, 3), (4, 5)]
[(0, 1), (2, 4), (3, 5)]
[(0, 1), (2, 5), (3, 4)]
[(0, 2), (1, 3), (4, 5)]
[(0, 2), (1, 4), (3, 5)]
[(0, 2), (1, 5), (3, 4)]
[(0, 3), (1, 2), (4, 5)]
[(0, 3), (1, 4), (2, 5)]
[(0, 3), (1, 5), (2, 4)]
[(0, 4), (1, 2), (3, 5)]
[(0, 4), (1, 3), (2, 5)]
[(0, 4), (1, 5), (2, 3)]
[(0, 5), (1, 2), (3, 4)]
[(0, 5), (1, 3), (2, 4)]
[(0, 5), (1, 4), (2, 3)]
— Adeel Zafar Soomro
ソース
3

順序が重要ではないすべての可能なペアを見つけるための非再帰関数、つまり（a、b）=（b、a）

def combinantorial(lst):
    count = 0
    index = 1
    pairs = []
    for element1 in lst:
        for element2 in lst[index:]:
            pairs.append((element1, element2))
        index += 1

    return pairs

非再帰的であるため、長いリストでメモリの問題が発生することはありません。

使用例：

my_list = [1, 2, 3, 4, 5]
print(combinantorial(my_list))
>>>
[(1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]
— melqkiades
ソース
1
これはitertools.combinationsと同じです
— Tmdean
3

準拠するすべてのソリューション用に小さなテストスイートを作成しました。Python 3で機能させるには、関数を少し変更する必要がありました。興味深いことに、PyPyで最も速い関数は、Python2 / 3で最も遅い関数である場合があります。

import itertools 
import time
from collections import OrderedDict

def tokland_org(lst, n):
    if not lst:
        yield []
    else:
        for group in (((lst[0],) + xs) for xs in itertools.combinations(lst[1:], n-1)):
            for groups in tokland_org([x for x in lst if x not in group], n):
                yield [group] + groups

tokland = lambda x: tokland_org(x, 2)

def gatoatigrado(lst):
    N = len(lst)
    choice_indices = itertools.product(*[
        range(k) for k in reversed(range(1, N, 2)) ])

    for choice in choice_indices:
        # calculate the list corresponding to the choices
        tmp = list(lst)
        result = []
        for index in choice:
            result.append( (tmp.pop(0), tmp.pop(index)) )
        yield result

def shang(X):
    lst = list(X)
    if len(lst) < 2:
        yield lst
        return
    a = lst[0]
    for i in range(1,len(lst)):
        pair = (a,lst[i])
        for rest in shang(lst[1:i]+lst[i+1:]):
            yield [pair] + rest

def smichr(X):
    lst = list(X)
    if not lst:
        yield [tuple()]
    elif len(lst) == 1:
        yield [tuple(lst)]
    elif len(lst) == 2:
        yield [tuple(lst)]
    else:
        if len(lst) % 2:
            for i in (None, True):
                if i not in lst:
                    lst = lst + [i]
                    PAD = i
                    break
            else:
                while chr(i) in lst:
                    i += 1
                PAD = chr(i)
                lst = lst + [PAD]
        else:
            PAD = False
        a = lst[0]
        for i in range(1, len(lst)):
            pair = (a, lst[i])
            for rest in smichr(lst[1:i] + lst[i+1:]):
                rv = [pair] + rest
                if PAD is not False:
                    for i, t in enumerate(rv):
                        if PAD in t:
                            rv[i] = (t[0],)
                            break
                yield rv

def adeel_zafar(X):
    L = list(X)
    if len(L) == 2:
        yield [(L[0], L[1])]
    else:
        first = L.pop(0)
        for i, e in enumerate(L):
            second = L.pop(i)
            for list_of_pairs in adeel_zafar(L):
                list_of_pairs.insert(0, (first, second))
                yield list_of_pairs
            L.insert(i, second)
        L.insert(0, first)

if __name__ =="__main__":
    import timeit
    import pprint

    candidates = dict(tokland=tokland, gatoatigrado=gatoatigrado, shang=shang, smichr=smichr, adeel_zafar=adeel_zafar)

    for i in range(1,7):
        results = [ frozenset([frozenset(x) for x in candidate(range(i*2))]) for candidate in candidates.values() ]
        assert len(frozenset(results)) == 1

    print("Times for getting all permutations of sets of unordered pairs consisting of two draws from a 6-element deck until it is empty")
    times = dict([(k, timeit.timeit('list({0}(range(6)))'.format(k), setup="from __main__ import {0}".format(k), number=10000)) for k in candidates.keys()])
    pprint.pprint([(k, "{0:.3g}".format(v)) for k,v in OrderedDict(sorted(times.items(), key=lambda t: t[1])).items()])

    print("Times for getting the first 2000 permutations of sets of unordered pairs consisting of two draws from a 52-element deck until it is empty")
    times = dict([(k, timeit.timeit('list(islice({0}(range(52)), 800))'.format(k), setup="from itertools import islice; from __main__ import {0}".format(k), number=100)) for k in candidates.keys()])
    pprint.pprint([(k, "{0:.3g}".format(v)) for k,v in OrderedDict(sorted(times.items(), key=lambda t: t[1])).items()])

    """
    print("The 10000th permutations of the previous series:")
    gens = dict([(k,v(range(52))) for k,v in candidates.items()])
    tenthousands = dict([(k, list(itertools.islice(permutations, 10000))[-1]) for k,permutations in gens.items()])
    for pair in tenthousands.items():
        print(pair[0])
        print(pair[1])
    """

それらはすべてまったく同じ順序を生成するように見えるので、セットは必要ありませんが、このようにすると将来の証拠になります。私はPython3変換を少し実験しました。リストを作成する場所が常に明確であるとは限りませんが、いくつかの代替案を試し、最速のものを選択しました。

ベンチマーク結果は次のとおりです。

% echo "pypy"; pypy all_pairs.py; echo "python2"; python all_pairs.py; echo "python3"; python3 all_pairs.py
pypy
Times for getting all permutations of sets of unordered pairs consisting of two draws from a 6-element deck until it is empty
[('gatoatigrado', '0.0626'),
 ('adeel_zafar', '0.125'),
 ('smichr', '0.149'),
 ('shang', '0.2'),
 ('tokland', '0.27')]
Times for getting the first 2000 permutations of sets of unordered pairs consisting of two draws from a 52-element deck until it is empty
[('gatoatigrado', '0.29'),
 ('adeel_zafar', '0.411'),
 ('smichr', '0.464'),
 ('shang', '0.493'),
 ('tokland', '0.553')]
python2
Times for getting all permutations of sets of unordered pairs consisting of two draws from a 6-element deck until it is empty
[('gatoatigrado', '0.344'),
 ('adeel_zafar', '0.374'),
 ('smichr', '0.396'),
 ('shang', '0.495'),
 ('tokland', '0.675')]
Times for getting the first 2000 permutations of sets of unordered pairs consisting of two draws from a 52-element deck until it is empty
[('adeel_zafar', '0.773'),
 ('shang', '0.823'),
 ('smichr', '0.841'),
 ('tokland', '0.948'),
 ('gatoatigrado', '1.38')]
python3
Times for getting all permutations of sets of unordered pairs consisting of two draws from a 6-element deck until it is empty
[('gatoatigrado', '0.385'),
 ('adeel_zafar', '0.419'),
 ('smichr', '0.433'),
 ('shang', '0.562'),
 ('tokland', '0.837')]
Times for getting the first 2000 permutations of sets of unordered pairs consisting of two draws from a 52-element deck until it is empty
[('smichr', '0.783'),
 ('shang', '0.81'),
 ('adeel_zafar', '0.835'),
 ('tokland', '0.969'),
 ('gatoatigrado', '1.3')]
% pypy --version
Python 2.7.12 (5.6.0+dfsg-0~ppa2~ubuntu16.04, Nov 11 2016, 16:31:26)
[PyPy 5.6.0 with GCC 5.4.0 20160609]
% python3 --version
Python 3.5.2

だから私は言う、gatoatigradoのソリューションで行きます。

— Janus Troelsen
ソース
2 
def f(l):
    if l == []:
        yield []
        return
    ll = l[1:]
    for j in range(len(ll)):
        for end in f(ll[:j] + ll[j+1:]):
            yield [(l[0], ll[j])] + end

使用法：

for x in f([0,1,2,3,4,5]):
    print x

>>> 
[(0, 1), (2, 3), (4, 5)]
[(0, 1), (2, 4), (3, 5)]
[(0, 1), (2, 5), (3, 4)]
[(0, 2), (1, 3), (4, 5)]
[(0, 2), (1, 4), (3, 5)]
[(0, 2), (1, 5), (3, 4)]
[(0, 3), (1, 2), (4, 5)]
[(0, 3), (1, 4), (2, 5)]
[(0, 3), (1, 5), (2, 4)]
[(0, 4), (1, 2), (3, 5)]
[(0, 4), (1, 3), (2, 5)]
[(0, 4), (1, 5), (2, 3)]
[(0, 5), (1, 2), (3, 4)]
[(0, 5), (1, 3), (2, 4)]
[(0, 5), (1, 4), (2, 3)]
— ジュール・オレオン
ソース
おっと、同じことをするシャンの答えを見ませんでした...私はこれを削除する必要がありますか？
— ジュール・Olléon
削除する必要はありませんが、shangは実際の変数名を使用する方が適切です。
— gatoatigrado 2012年
1

このコードは、リストの長さが2の倍数でない場合に機能します。それを機能させるためにハックを採用しています。おそらくこれを行うためのより良い方法があります...それはまた、ペアが常にタプルにあり、入力がリストであるかタプルであるかにかかわらず機能することを保証します。

def all_pairs(lst):
    """Return all combinations of pairs of items of ``lst`` where order
    within the pair and order of pairs does not matter.

    Examples
    ========

    >>> for i in range(6):
    ...  list(all_pairs(range(i)))
    ...
    [[()]]
    [[(0,)]]
    [[(0, 1)]]
    [[(0, 1), (2,)], [(0, 2), (1,)], [(0,), (1, 2)]]
    [[(0, 1), (2, 3)], [(0, 2), (1, 3)], [(0, 3), (1, 2)]]
    [[(0, 1), (2, 3), (4,)], [(0, 1), (2, 4), (3,)], [(0, 1), (2,), (3, 4)], [(0, 2)
    , (1, 3), (4,)], [(0, 2), (1, 4), (3,)], [(0, 2), (1,), (3, 4)], [(0, 3), (1, 2)
    , (4,)], [(0, 3), (1, 4), (2,)], [(0, 3), (1,), (2, 4)], [(0, 4), (1, 2), (3,)],
     [(0, 4), (1, 3), (2,)], [(0, 4), (1,), (2, 3)], [(0,), (1, 2), (3, 4)], [(0,),
    (1, 3), (2, 4)], [(0,), (1, 4), (2, 3)]]

    Note that when the list has an odd number of items, one of the
    pairs will be a singleton.

    References
    ==========

    http://stackoverflow.com/questions/5360220/
    how-to-split-a-list-into-pairs-in-all-possible-ways

    """
    if not lst:
        yield [tuple()]
    elif len(lst) == 1:
        yield [tuple(lst)]
    elif len(lst) == 2:
        yield [tuple(lst)]
    else:
        if len(lst) % 2:
            for i in (None, True):
                if i not in lst:
                    lst = list(lst) + [i]
                    PAD = i
                    break
            else:
                while chr(i) in lst:
                    i += 1
                PAD = chr(i)
                lst = list(lst) + [PAD]
        else:
            PAD = False
        a = lst[0]
        for i in range(1, len(lst)):
            pair = (a, lst[i])
            for rest in all_pairs(lst[1:i] + lst[i+1:]):
                rv = [pair] + rest
                if PAD is not False:
                    for i, t in enumerate(rv):
                        if PAD in t:
                            rv[i] = (t[0],)
                            break
                yield rv
— smichr
ソース
1

これが役立つことを願っています：

L = [0、1、2、3、4、5]

[（i、j）for i in L for j in L]

出力：

[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5)]

— キラン・プリゴラ
ソース
(0, 0)リストのペアではありません。(0, 1)そして、(1, 0)等価です
— 穴居人
0 
L = [1, 1, 2, 3, 4]
answer = []
for i in range(len(L)):
    for j in range(i+1, len(L)):
        if (L[i],L[j]) not in answer:
            answer.append((L[i],L[j]))

print answer
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

お役に立てれば

— inspectorG4dget
ソース
-2

最も効率的または最速ではありませんが、おそらく最も簡単です。最後の行は、Pythonでリストを重複排除する簡単な方法です。この場合、（0,1）と（1,0）のようなペアが出力に含まれます。それらの重複を検討するかどうかはわかりません。

l = [0, 1, 2, 3, 4, 5]
pairs = []
for x in l:
    for y in l:
        pairs.append((x,y))
pairs = list(set(pairs))
print(pairs)

出力：

[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5)]
— FrankFcknCastle
ソース
リスト内の重複するペア(0, 1)は、と同じペア(1, 0)です。質問を参照してください
— 穴居人
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.