Python 嵌套循环数组比较 - 优化的可能性？

Question

我正在尝试优化嵌套的 for 循环，该循环将数组中的元素与数组中的其余元素进行比较。

有两部分，第一部分例如，一个Array有3个元素，每个元素是一个字典：

[{"someKey_1":"a"}, {"someKey_1":"b"}, {"somekey_1":"a"}]

---

第一次迭代（第一个元素与第二个元素比较）：

两个元素的 "someKey" 的测试键，因为 a != b，那么我们什么也不做

---

第二次迭代（第一个元素与第三个元素比较）：

两个元素的“someKey”的测试键，因为a == a，我们做一些逻辑

---

代码：

for idx, val in enumerate(set_of_pk_values):
    for idx_2, val_2 in enumerate(set_of_pk_values):
        if (val['someKey'] == val_2['someKey'] and idx != idx_2):
                #Some Logic

---

第二部分与前面的例子非常相似（列表中的 3 项），在同一个字典中，我们有一个与键关联的数组（现在有一个字典，数组的每个元素中都有两个键） ，比方说：

[{"someKey_1":[b,f]}{"someKey_2":a}, 
{"someKey_1":[e,f]}{"someKey_2":b}, 
{"somekey_1":[h,k]}{"someKey_2":c}]

---

第一次迭代（第一个元素与第二个元素比较）：

使用键循环遍历数组：someKey_1

b==b（第二个元素的 someKey_2），然后做一些逻辑

f!=b（第二个元素的 someKey_2），没有做任何逻辑

---

第二次迭代（第一个元素与第三个元素比较）：

使用键循环遍历数组：someKey_1

b==c（第三个元素的 someKey_2），然后做一些逻辑

f!=c（第三个元素的 someKey_2），没有做任何逻辑

---

代码：

for idx, val in enumerate(set_of_pk_values):
    for idx_2, val_2 in enumerate(set_of_pk_values):
        for pred in val['someKey_1']:
            if(val_2['someKey_2'] == pred):
                #Some Logic

---

目前第一个嵌套循环的运行时间：21 秒，第二个嵌套循环约为 19 秒。与其他进程相比，1-2 秒不等，这部分显然是一个瓶颈。

谁能指出我如何优化这段简单但极其耗时的代码的正确方向？

Answer 1

首先，我认为这应该发布在 CodeReview 上，而不是 StackOverflow 上。

StackOverflow 用于获取有关不起作用的代码的帮助。
CodeReview 是为了获得关于确实有效的代码的帮助，但你想让它变得更好。

其次，这里有一些优化建议：

• 不要在循环内enumerate()。
• 在第一种情况下使用切片以避免无意义的比较。

以下是我将如何重写您的第一个场景：

# Check if two dictionary with the key 'predecessor' are the same,
# and they are NOT the same index (otherwise it would be comparing themselves)
# set_of_pk_values is an array of dictionaries.
for idx, val in enumerate(set_of_pk_values):
    for val_2 in set_of_pk_values[idx+1:]:  # Note the slice and lack of enumerate
        if (val['predecessor'] == val_2['predecessor']):  # Don't waste time checking indexes
            # Do Something Here, also we don't want to compare itself, because it will be true

用if in代替for\if：

for idx, val in enumerate(set_of_pk_values):
    if val in set_of_pk_values[idx+1:]:
        # Do Something Here, also we don't want to compare itself, because it will be true.

如果你真的想枚举，因为你只是想要多次相同的枚举，我只会在循环外执行一次并将它存储在一个变量中，然后循环它。这就是我的意思：

我错了，下面的不行，看cmets。

# Doesn't work, see comments.
# from itertools import islice
# whatIEnumerate = enumerate(set_of_pk_values)
# for idx, val in whatIEnumerate:
    # for idx_2, val_2 in islice(whatIEnumerate, idx+1, None):
        # ...

Answer 2

第一部分的优化

原创

伙计，这很糟糕：

for idx, val in enumerate(set_of_pk_values):
    for idx_2, val_2 in enumerate(set_of_pk_values):
        if (val['someKey'] == val_2['someKey'] and idx != idx_2):
            do_stuff()

第一步

只需跳过您已经尝试过的元素的索引（== 是可交换的）：

for idx, val in enumerate(set_of_pk_values[:-1]):
    for val_2 in set_of_pk_values[idx+1:]
        if (val['someKey'] == val_2['someKey']):
            do_stuff()

步骤 0.1

重命名。它很丑。

for idx, first_dic in enumerate(set_of_pk_values[:-1]):
    for second_dic in set_of_pk_values[idx+1:]
        if (first_dic['someKey'] == second_dic['someKey']):
            do_stuff()

第 2 步

现在，每次循环迭代中的if 都很麻烦。通过过滤缩减列表来替换它：

hits = []
for idx, first_dic in enumerate(set_of_pk_values[:-1]):
    hits += (first_dic['someKey'], filter(lambda dic: dic['someKey'] == first_dic['someKey'], set_of_pk_values[idx:1]) ) 

hits 现在包含一个匹配元组列表：hits[i] = ( mathing first element , list of match that has idx > first element)。

第三步

字典查找成本很高。使用operator.itemgetter替换它们：

from operator import itemgetter
getter = itemgetter("someKey")
hits = []
for idx, first_dic in enumerate(set_of_pk_values[:-1]):
    hits += (getter(first_dic), filter(lambda dic: getter(dic) == getter(first_dic), set_of_pk_values[idx:1]) )

第四步

坐下来看看。 for 循环的迭代并不真正依赖于上次迭代的状态。是时候进行列表推导了。

from operator import itemgetter
getter = itemgetter("someKey")
hits = [ ( getter(first_dic), filter(lambda dic: getter(dic) == getter(first_dic), set_of_pk_values[idx:-1]) ) for idx, first_dic in enumerate(set_of_pk_values[:-1])]

Answer 3

Python 中的迭代比 C 中的迭代慢。最好使用 Python 库在 C 中进行迭代。有趣的是这里没有人提到itertools...

itertools.combinations 在 C 中创建唯一的组合，然后返回组合的生成器：

import itertools
import operator
getter = operator.itemgetter('someKey_1')

for a, b in itertools.combinations(set_of_pk_values, 2):
    if getter(a) == getter(b):
        # logic?