Question

让我说我有：

dict_listA = [
    {'id':0, 'b':1},
    {'id':1, 'b':2},
    {'id':2, 'b':3},
]

和

dict_listB = [
    {'id':1, 'b':1},
    {'id':2, 'b':3},
    {'id':3, 'b':2},
]

我如何得到一个id的列表，其中我们有基于'id'的交集，但基于b的对称差异？

same_a_different_b = [
    {'id':1, 'b':2},
]

目前这是我的解决方案：

for d1 in list_dictA:
    same_a_different_b = filter(lambda d2: d2['id'] == d1['id'] and d2['b'] != d1['b'], list_dictB)

我问，因为这是我程序中最大的时间下沉，我希望有一些方法可以更快地完成它。结果（same_a_different_b）通常为0或非常小，一个列表有大约900个条目，另一个列表大约1400个。目前需要9秒。

Answer 1

试试这个：

hashed = {e['id']: e['b'] for e in dict_listB}
same_a_different_b2 = [e for e in dict_listA if e['id'] in hashed and hashed[e['id']] != e['b']]

我认为算法的复杂性等于O（len（a）+ len（b））。例如，在您的解决方案中，它等于O（len（a）* len（b））。

如果列表可以有重复项：

hashed = defaultdict(set)
for e in dict_listB:
    hashed[e['id']].add(e['b'])
same_a_different_b2 = [e for e in dict_listA if e['id'] in hashed and e['b'] not in hashed[e['id']]]

比较速度（len（a）== len（b）== 2000）：

from collections import defaultdict

import time
from itertools import product

dict_listA = [
    {'id': 0, 'b': 1},
    {'id': 1, 'b': 2},
    {'id': 2, 'b': 3},
    *[{'id': i, 'b': 1} for i in range(10000, 10000 + 2000)]
]

dict_listB = [
    {'id': 1, 'b': 1},
    {'id': 2, 'b': 3},
    {'id': 3, 'b': 2},
    *[{'id': i, 'b': 1} for i in range(20000, 20000 + 2000)]
]

same_a_different_b = [
    {'id': 1, 'b': 2},
]
start_time = time.clock()


def previous_solution():
    new_same_a_different_b = []
    for d1 in dict_listA:
        new_same_a_different_b.extend(filter(lambda d2: d2['id'] == d1['id'] and d2['b'] != d1['b'], dict_listB))
    return new_same_a_different_b


def new_solution():
    hashed = {e['id']: e['b'] for e in dict_listB}
    return [e for e in dict_listA if e['id'] in hashed and hashed[e['id']] != e['b']]


def other_solution():
    return [d1 for d1, d2 in product(dict_listA, dict_listB) if d2['id'] == d1['id'] and d2['b'] != d1['b']]


for func, name in [
    (previous_solution, 'previous_solution'),
    (new_solution, 'new_solution'),
    (other_solution, 'other_solution')
]:
    start_time = time.clock()
    new_result = func()
    print('{:20}: {:.5f}'.format(name, time.clock() - start_time))
    assert new_result, same_a_different_b

结果：

previous_solution   : 1.06517
new_solution        : 0.00073
other_solution      : 0.60582

Answer 2

以下是使用列表理解和itertools.prodcut的一种方式：

In [41]: from itertools import product
In [42]: [d1 for d1, d2 in product(dict_listA, dict_listB) if d2['id'] == d1['id'] and d2['b'] != d1['b']]
Out[42]: [{'id': 1, 'b': 2}]

但请注意，如果dict_listB中有多个匹配的项目，则会产生重复的结果。如果您不想保留所有重复的内容，则可以使用集合理解。

字典列表，如何获取：基于一个值的交集和基于另一个值的对称差异

2 个答案: