Python 获取两个列表之间值的每一对组合_Python

Python 获取两个列表之间值的每一对组合

python

Python 获取两个列表之间值的每一对组合,python,Python,假设我有两个列表 a = ['A', 'B', 'C', 'D'] b = ['1', '2', '3', '4'] 我知道我可以得到这两个列表的每一个排列，如下所示： for r in itertools.product(a, b): print (r[0] + r[1]) 但我要找的是存储在元组中的每个成对组合。例如，某些组合可能是： [(A, 1), (B, 2), (C, 3), (D, 4)] [(A, 1), (B, 3), (C, 2), (D, 4)] [(A, 1), (

假设我有两个列表

a = ['A', 'B', 'C', 'D']
b  = ['1', '2', '3', '4']

我知道我可以得到这两个列表的每一个排列，如下所示：

for r in itertools.product(a, b): print (r[0] + r[1])

但我要找的是存储在元组中的每个成对组合。例如，某些组合可能是：

[(A, 1), (B, 2), (C, 3), (D, 4)]
[(A, 1), (B, 3), (C, 2), (D, 4)]
[(A, 1), (B, 4), (C, 3), (D, 2)]
[(A, 1), (B, 3), (C, 4), (D, 2)]
[(A, 1), (B, 2), (C, 4), (D, 3)]

因此，它将遍历所有可能的组合，这样就不会有字母具有相同的数值。我无法找到一种有效的方法来实现这一点（特别是因为在我的实际示例中，我需要将其扩展到三个列表）

这可能比您想象的简单得多。那么：

import itertools

a = ['A', 'B', 'C', 'D']
b = ['1', '2', '3', '4']

for aperm in itertools.permutations(a):
    for bperm in itertools.permutations(b):
        print(list(zip(aperm, bperm)))

第一项产出：

[('A', '1'), ('B', '2'), ('C', '3'), ('D', '4')] [('A', '1'), ('B', '2'), ('C', '4'), ('D', '3')] [('A', '1'), ('B', '3'), ('C', '2'), ('D', '4')] [('A', '1'), ('B', '3'), ('C', '4'), ('D', '2')] [('A', '1'), ('B', '4'), ('C', '2'), ('D', '3')] [('A', '1'), ('B', '4'), ('C', '3'), ('D', '2')] [('A', '2'), ('B', '1'), ('C', '3'), ('D', '4')] [('A', '2'), ('B', '1'), ('C', '4'), ('D', '3')] [('A', '2'), ('B', '3'), ('C', '1'), ('D', '4')] ... 输出相同的内容，但可以轻松扩展，例如

import itertools

a = ['A', 'B', 'C', 'D']
b = ['1', '2', '3', '4']
c = ['W', 'X', 'Y', 'Z']

gens = [itertools.permutations(lst) for lst in (a,b,c)]   # add c

for perms in itertools.product(*gens):                    # no change
    print(list(zip(*perms)))                              # ''

这可能比你想象的要容易得多。那么：

import itertools

a = ['A', 'B', 'C', 'D']
b = ['1', '2', '3', '4']

for aperm in itertools.permutations(a):
    for bperm in itertools.permutations(b):
        print(list(zip(aperm, bperm)))

第一项产出：

import itertools

a = ['A', 'B', 'C', 'D']
b = ['1', '2', '3', '4']
c = ['W', 'X', 'Y', 'Z']

gens = [itertools.permutations(lst) for lst in (a,b,c)]   # add c

for perms in itertools.product(*gens):                    # no change
    print(list(zip(*perms)))                              # ''

我们可以对其中一个列表进行排列（例如，这里是后一个列表），然后将每个排列与第一个列表压缩在一起，如：

from functools import partial
from itertools import permutations

def pairwise_comb(xs, ys):
    return map(partial(zip, xs), permutations(ys))

或者在所有子元素都应该是列表的情况下（在这里，当您“具体化”这些子元素时，这些子元素仍然是可以采用特定形状的iterables）：

对于给定的样本输入，我们得到：

>>> for el in pairwise_comb(a, b):
...     print(list(el))
... 
[('A', '1'), ('B', '2'), ('C', '3'), ('D', '4')]
[('A', '1'), ('B', '2'), ('C', '4'), ('D', '3')]
[('A', '1'), ('B', '3'), ('C', '2'), ('D', '4')]
[('A', '1'), ('B', '3'), ('C', '4'), ('D', '2')]
[('A', '1'), ('B', '4'), ('C', '2'), ('D', '3')]
[('A', '1'), ('B', '4'), ('C', '3'), ('D', '2')]
[('A', '2'), ('B', '1'), ('C', '3'), ('D', '4')]
[('A', '2'), ('B', '1'), ('C', '4'), ('D', '3')]
[('A', '2'), ('B', '3'), ('C', '1'), ('D', '4')]
[('A', '2'), ('B', '3'), ('C', '4'), ('D', '1')]
[('A', '2'), ('B', '4'), ('C', '1'), ('D', '3')]
[('A', '2'), ('B', '4'), ('C', '3'), ('D', '1')]
[('A', '3'), ('B', '1'), ('C', '2'), ('D', '4')]
[('A', '3'), ('B', '1'), ('C', '4'), ('D', '2')]
[('A', '3'), ('B', '2'), ('C', '1'), ('D', '4')]
[('A', '3'), ('B', '2'), ('C', '4'), ('D', '1')]
[('A', '3'), ('B', '4'), ('C', '1'), ('D', '2')]
[('A', '3'), ('B', '4'), ('C', '2'), ('D', '1')]
[('A', '4'), ('B', '1'), ('C', '2'), ('D', '3')]
[('A', '4'), ('B', '1'), ('C', '3'), ('D', '2')]
[('A', '4'), ('B', '2'), ('C', '1'), ('D', '3')]
[('A', '4'), ('B', '2'), ('C', '3'), ('D', '1')]
[('A', '4'), ('B', '3'), ('C', '1'), ('D', '2')]
[('A', '4'), ('B', '3'), ('C', '2'), ('D', '1')]

这就产生了24种可能的组合方式，因为

'A'

，

'B'

，

'C'

和

'D'

的顺序保持不变，并且这4个字符可以分配为4个！方法，或4！=4×3×2×1=24。

我们可以对其中一个列表进行排列（例如，这里是后一个列表），然后将每个排列与第一个列表压缩在一起，如：

from functools import partial
from itertools import permutations

def pairwise_comb(xs, ys):
    return map(partial(zip, xs), permutations(ys))

或者在所有子元素都应该是列表的情况下（在这里，当您“具体化”这些子元素时，这些子元素仍然是可以采用特定形状的iterables）：

对于给定的样本输入，我们得到：

>>> for el in pairwise_comb(a, b):
...     print(list(el))
... 
[('A', '1'), ('B', '2'), ('C', '3'), ('D', '4')]
[('A', '1'), ('B', '2'), ('C', '4'), ('D', '3')]
[('A', '1'), ('B', '3'), ('C', '2'), ('D', '4')]
[('A', '1'), ('B', '3'), ('C', '4'), ('D', '2')]
[('A', '1'), ('B', '4'), ('C', '2'), ('D', '3')]
[('A', '1'), ('B', '4'), ('C', '3'), ('D', '2')]
[('A', '2'), ('B', '1'), ('C', '3'), ('D', '4')]
[('A', '2'), ('B', '1'), ('C', '4'), ('D', '3')]
[('A', '2'), ('B', '3'), ('C', '1'), ('D', '4')]
[('A', '2'), ('B', '3'), ('C', '4'), ('D', '1')]
[('A', '2'), ('B', '4'), ('C', '1'), ('D', '3')]
[('A', '2'), ('B', '4'), ('C', '3'), ('D', '1')]
[('A', '3'), ('B', '1'), ('C', '2'), ('D', '4')]
[('A', '3'), ('B', '1'), ('C', '4'), ('D', '2')]
[('A', '3'), ('B', '2'), ('C', '1'), ('D', '4')]
[('A', '3'), ('B', '2'), ('C', '4'), ('D', '1')]
[('A', '3'), ('B', '4'), ('C', '1'), ('D', '2')]
[('A', '3'), ('B', '4'), ('C', '2'), ('D', '1')]
[('A', '4'), ('B', '1'), ('C', '2'), ('D', '3')]
[('A', '4'), ('B', '1'), ('C', '3'), ('D', '2')]
[('A', '4'), ('B', '2'), ('C', '1'), ('D', '3')]
[('A', '4'), ('B', '2'), ('C', '3'), ('D', '1')]
[('A', '4'), ('B', '3'), ('C', '1'), ('D', '2')]
[('A', '4'), ('B', '3'), ('C', '2'), ('D', '1')]

这就产生了24种可能的组合方式，因为

'A'

，

'B'

，

'C'

和

'D'

的顺序保持不变，并且这4个字符可以分配为4个！方法，或4！=4×3×2×1=24。

对于非导入解决方案，您可以使用递归和

收益率

：

a = ['A', 'B', 'C', 'D']
b  = ['1', '2', '3', '4']
def combinations(d, current = []):
  if len(current) == 4:
    yield current
  elif filter(None, d):
    for i in d[0]:
      _d0, _d1 = [c for c in d[0] if c != i], [c for c in d[1] if c != d[1][0]]
      yield from combinations([_d0, _d1] , current+[[i, d[1][0]]])

for i in combinations([a, b]):
  print(i)

输出：

[['A', '1'], ['B', '2'], ['C', '3'], ['D', '4']]
[['A', '1'], ['B', '2'], ['D', '3'], ['C', '4']]
[['A', '1'], ['C', '2'], ['B', '3'], ['D', '4']]
[['A', '1'], ['C', '2'], ['D', '3'], ['B', '4']]
[['A', '1'], ['D', '2'], ['B', '3'], ['C', '4']]
[['A', '1'], ['D', '2'], ['C', '3'], ['B', '4']]
[['B', '1'], ['A', '2'], ['C', '3'], ['D', '4']]
[['B', '1'], ['A', '2'], ['D', '3'], ['C', '4']]
[['B', '1'], ['C', '2'], ['A', '3'], ['D', '4']]
[['B', '1'], ['C', '2'], ['D', '3'], ['A', '4']]
[['B', '1'], ['D', '2'], ['A', '3'], ['C', '4']]
[['B', '1'], ['D', '2'], ['C', '3'], ['A', '4']]
[['C', '1'], ['A', '2'], ['B', '3'], ['D', '4']]
[['C', '1'], ['A', '2'], ['D', '3'], ['B', '4']]
[['C', '1'], ['B', '2'], ['A', '3'], ['D', '4']]
[['C', '1'], ['B', '2'], ['D', '3'], ['A', '4']]
[['C', '1'], ['D', '2'], ['A', '3'], ['B', '4']]
[['C', '1'], ['D', '2'], ['B', '3'], ['A', '4']]
[['D', '1'], ['A', '2'], ['B', '3'], ['C', '4']]
[['D', '1'], ['A', '2'], ['C', '3'], ['B', '4']]
[['D', '1'], ['B', '2'], ['A', '3'], ['C', '4']]
[['D', '1'], ['B', '2'], ['C', '3'], ['A', '4']]
[['D', '1'], ['C', '2'], ['A', '3'], ['B', '4']]
[['D', '1'], ['C', '2'], ['B', '3'], ['A', '4']]

对于无导入解决方案，您可以使用递归和

yield

：

a = ['A', 'B', 'C', 'D']
b  = ['1', '2', '3', '4']
def combinations(d, current = []):
  if len(current) == 4:
    yield current
  elif filter(None, d):
    for i in d[0]:
      _d0, _d1 = [c for c in d[0] if c != i], [c for c in d[1] if c != d[1][0]]
      yield from combinations([_d0, _d1] , current+[[i, d[1][0]]])

for i in combinations([a, b]):
  print(i)

输出：

[['A', '1'], ['B', '2'], ['C', '3'], ['D', '4']]
[['A', '1'], ['B', '2'], ['D', '3'], ['C', '4']]
[['A', '1'], ['C', '2'], ['B', '3'], ['D', '4']]
[['A', '1'], ['C', '2'], ['D', '3'], ['B', '4']]
[['A', '1'], ['D', '2'], ['B', '3'], ['C', '4']]
[['A', '1'], ['D', '2'], ['C', '3'], ['B', '4']]
[['B', '1'], ['A', '2'], ['C', '3'], ['D', '4']]
[['B', '1'], ['A', '2'], ['D', '3'], ['C', '4']]
[['B', '1'], ['C', '2'], ['A', '3'], ['D', '4']]
[['B', '1'], ['C', '2'], ['D', '3'], ['A', '4']]
[['B', '1'], ['D', '2'], ['A', '3'], ['C', '4']]
[['B', '1'], ['D', '2'], ['C', '3'], ['A', '4']]
[['C', '1'], ['A', '2'], ['B', '3'], ['D', '4']]
[['C', '1'], ['A', '2'], ['D', '3'], ['B', '4']]
[['C', '1'], ['B', '2'], ['A', '3'], ['D', '4']]
[['C', '1'], ['B', '2'], ['D', '3'], ['A', '4']]
[['C', '1'], ['D', '2'], ['A', '3'], ['B', '4']]
[['C', '1'], ['D', '2'], ['B', '3'], ['A', '4']]
[['D', '1'], ['A', '2'], ['B', '3'], ['C', '4']]
[['D', '1'], ['A', '2'], ['C', '3'], ['B', '4']]
[['D', '1'], ['B', '2'], ['A', '3'], ['C', '4']]
[['D', '1'], ['B', '2'], ['C', '3'], ['A', '4']]
[['D', '1'], ['C', '2'], ['A', '3'], ['B', '4']]
[['D', '1'], ['C', '2'], ['B', '3'], ['A', '4']]

啊!！这比我做的容易多了。非常感谢。啊！这比我做的容易多了。非常感谢，太棒了！非常感谢。因为你和jedwards同时回答，但他的声望点数较少，所以我必须给他打勾。不过，我从来都不知道部分，所以谢谢你。太棒了！非常感谢。因为你和jedwards同时回答，但他的声望点数较少，所以我必须给他打勾。不过，我从来都不知道部分，所以谢谢你。