对列表中的每对元素进行操作

Question

我想使用 Python 比较列表中的每个可能的对。

假设我

my_list = [1,2,3,4]

想对列表中 2 个元素的每个组合执行一个操作（我们称之为 foo）。

相同，但这看起来不太Pythonic。

foo(1,1)
foo(1,2)
...
foo(4,3)
foo(4,4)

最终结果应该与我的第一个想法是手动迭代列表两次

Answer 1

查看 product() 中的 <代码>itertools模块。 它的作用正是你所描述的。

import itertools

my_list = [1,2,3,4]
for pair in itertools.product(my_list, repeat=2):
    foo(*pair)

这相当于：

my_list = [1,2,3,4]
for x in my_list:
    for y in my_list:
        foo(x, y)

编辑：还有两个非常相似的函数，permutations() 和 combinations()。 为了说明它们有何不同：

product() 生成所有可能的元素配对，包括所有重复项：

1,1  1,2  1,3  1,4
2,1  2,2  2,3  2,4
3,1  3,2  3,3  3,4
4,1  4,2  4,3  4,4

permutations() 生成每个唯一元素对的所有唯一排序，从而消除了x,x 重复：

 .   1,2  1,3  1,4
2,1   .   2,3  2,4
3,1  3,2   .   3,4
4,1  4,2  4,3   .

最后，combinations() 仅按字典顺序生成每个唯一的元素对：

 .   1,2  1,3  1,4
 .    .   2,3  2,4
 .    .    .   3,4
 .    .    .    .

所有这三个函数都是在 Python 2.6 中引入的。

Answer 2

我遇到了类似的问题，并在此处找到了解决方案。 它无需导入任何模块即可工作。

假设一个列表如下：

people = ["Lisa","Pam","Phil","John"]

简化的单行解决方案如下所示。

所有可能的对，包括重复项：

result = [foo(p1, p2) for p1 in people for p2 in people]

所有可能的对，不包括重复项：

result = [foo(p1, p2) for p1 in people for p2 in people if p1 != p2]

唯一对，其中顺序无关：

result = [foo(people[p1], people[p2]) for p1 in range(len(people)) for p2 in range(p1+1,len(people))]

---

如果您不想要操作但只是为了获取对，删除函数 foo 并仅使用元组就足够了。

所有可能的对，包括重复项：

list_of_pairs = [(p1, p2) for p1 in people for p2 in people]

结果：

('Lisa', 'Lisa')
('Lisa', 'Pam')
('Lisa', 'Phil')
('Lisa', 'John')
('Pam', 'Lisa')
('Pam', 'Pam')
('Pam', 'Phil')
('Pam', 'John')
('Phil', 'Lisa')
('Phil', 'Pam')
('Phil', 'Phil')
('Phil', 'John')
('John', 'Lisa')
('John', 'Pam')
('John', 'Phil')
('John', 'John')

所有可能的对，不包括重复项：

list_of_pairs = [(p1, p2) for p1 in people for p2 in people if p1 != p2]

结果：

('Lisa', 'Pam')
('Lisa', 'Phil')
('Lisa', 'John')
('Pam', 'Lisa')
('Pam', 'Phil')
('Pam', 'John')
('Phil', 'Lisa')
('Phil', 'Pam')
('Phil', 'John')
('John', 'Lisa')
('John', 'Pam')
('John', 'Phil')

唯一对，其中顺序无关：

list_of_pairs = [(people[p1], people[p2]) for p1 in range(len(people)) for p2 in range(p1+1,len(people))]

结果：

('Lisa', 'Pam')
('Lisa', 'Phil')
('Lisa', 'John')
('Pam', 'Phil')
('Pam', 'John')
('Phil', 'John')

< em>编辑：在重新设计以简化此解决方案后，我意识到它与 Adam Rosenfield 的方法相同。 我希望更详细的解释可以帮助一些人更好地理解它。

Answer 3

如果您只是调用一个函数，那么您实际上不能做得比以下更好：

for i in my_list:
    for j in my_list:
        foo(i, j)

如果您想收集调用该函数的结果列表，您可以这样做：

[foo(i, j) for i in my_list for j in my_list]

这将返回应用 < 的结果列表code>foo(i, j) 到每个可能的对 (i, j)。

Answer 4

my_list = [1,2,3,4]

pairs=[[x,y] for x in my_list for y in my_list]
print (pairs)

Answer 5

如果您希望组合按字典顺序排序，Ben Bank 的答案效果很好。 但是，如果您希望组合随机排序，这里有一个解决方案：

import random
from math import comb


def cgen(i,n,k):
    """
    returns the i-th combination of k numbers chosen from 0,1,...,n-1
    
    forked from: https://math.stackexchange.com/a/1227692
    changed from 1-indexed to 0-indexed.
    """
    # 1-index
    i += 1
    
    c = []
    r = i+0
    j = 0
    for s in range(1,k+1):
        cs = j+1
        while r-comb(n-cs,k-s)>0:
            r -= comb(n-cs,k-s)
            cs += 1
        c.append(cs-1)
        j = cs
    return c


def generate_random_combinations(n, k, shuffle=random.shuffle):
    """
    Generate combinations in random order of k numbers chosen from 0,1,...,n-1.
    
    :param shuffle: Function to in-place shuffle the indices of the combinations. Use for seeding.
    """
    total_combinations = comb(n, k)
    combination_indices = list(range(total_combinations))
    shuffle(combination_indices)
    
    for i in combination_indices:
        yield cgen(i, n, k)

示例用法

N=100 和 k=4 的

gen_combos = generate_random_combinations(100, 4)

for i in range(3):
    print(next(gen_combos))

：结果为：

[4, 9, 55, 79]
[11, 49, 58, 64]
[75, 82, 83, 91]

用例

对于我的用例，我正在实现一种算法，该算法正在搜索单个（或几个）组合，并在找到有效组合时停止。 平均而言，它遍历所有可能组合的一个非常小的子集，因此不需要预先构建所有可能的组合，然后进行洗牌（无论如何，总体规模太大，无法容纳内存中的所有组合）。

随机性对于快速找到解决方案至关重要，因为字典顺序会导致总体中的单个值包含在所有组合中，直到耗尽为止。 例如，如果我们有 n=100 和 k=4，那么结果将类似于：

索引	组合
0	(0, 1, 2, 3)
1	(0 , 1, 2, 4)
2	(0, 1, 2, 5)
...
156848	(0, 97, 98, 99)
156849	(1, 2, 3, 4)

如果 0 不是有效解的一部分，那么我们将无缘无故地搜索 156849 个组合。 随机化顺序有助于缓解此问题（请参阅上面的示例输出）。