我正在研究倒排索引上的搜索程序。索引本身是一个字典，其键是术语，其值本身就是短文档的字典，ID 号作为键，文本内容作为值。
要对两个术语执行“与”搜索，因此我需要将它们的发布列表（字典）相交。在 Python 中执行此操作的一种清晰（不一定过于聪明）的方法是什么？我开始尝试了很长的路要走iter：
p1 = index[term1]
p2 = index[term2]
i1 = iter(p1)
i2 = iter(p2)
while ... # not sure of the 'iter != end 'syntax in this case
...
一个鲜为人知的事实是，您不需要构造sets 来执行此操作：
在 Python 2 中：
In [78]: d1 = {'a': 1, 'b': 2}
In [79]: d2 = {'b': 2, 'c': 3}
In [80]: d1.viewkeys() & d2.viewkeys()
Out[80]: {'b'}
在 Python 3 中替换viewkeys为keys; 这同样适用于viewvalues和viewitems。
从以下文档viewitems：
In [113]: d1.viewitems??
Type: builtin_function_or_method
String Form:<built-in method viewitems of dict object at 0x64a61b0>
Docstring: D.viewitems() -> a set-like object providing a view on D's items
对于较大dict的 s，这也比构造sets 然后与它们相交稍快：
In [122]: d1 = {i: rand() for i in range(10000)}
In [123]: d2 = {i: rand() for i in range(10000)}
In [124]: timeit d1.viewkeys() & d2.viewkeys()
1000 loops, best of 3: 714 µs per loop
In [125]: %%timeit
s1 = set(d1)
s2 = set(d2)
res = s1 & s2
1000 loops, best of 3: 805 µs per loop
For smaller `dict`s `set` construction is faster:
In [126]: d1 = {'a': 1, 'b': 2}
In [127]: d2 = {'b': 2, 'c': 3}
In [128]: timeit d1.viewkeys() & d2.viewkeys()
1000000 loops, best of 3: 591 ns per loop
In [129]: %%timeit
s1 = set(d1)
s2 = set(d2)
res = s1 & s2
1000000 loops, best of 3: 477 ns per loop
我们在这里比较纳秒，这对你来说可能很重要，也可能无关紧要。无论如何，你会得到 a set，所以使用viewkeys/keys消除了一些混乱。
一般来说，要在 Python 中构造字典的交集，您可以首先使用&运算符计算字典键的集合的交集（字典键在 Python 3 中是类似集合的对象）：
dict_a = {"a": 1, "b": 2}
dict_b = {"a": 2, "c": 3}
intersection = dict_a.keys() & dict_b.keys() # {'a'}
在 Python 2 上，您必须自己将字典键转换为集合：
keys_a = set(dict_a.keys())
keys_b = set(dict_b.keys())
intersection = keys_a & keys_b
然后给定键的交集，然后您可以构建您的值的交集，但是需要。您必须在此处做出选择，因为集合交集的概念不会告诉您如果相关值不同时该怎么做。（这大概就是为什么&没有直接为 Python 中的字典定义交集运算符的原因）。
在这种情况下，听起来您对同一键的值是相等的，因此您可以从以下字典之一中选择值：
dict_of_dicts_a = {"a": {"x":1}, "b": {"y":3}}
dict_of_dicts_b = {"a": {"x":1}, "c": {"z":4}}
shared_keys = dict_of_dicts_a.keys() & dict_of_dicts_b.keys()
# values equal so choose values from a:
dict_intersection = {k: dict_of_dicts_a[k] for k in shared_keys } # {"a":{"x":1}}
组合值的其他合理方法取决于字典中值的类型以及它们所代表的内容。例如，您可能还需要字典的字典共享键的值的联合。由于字典的并集不依赖于值，因此定义明确，在 python 中，您可以使用|运算符获取它：
# union of values for each key in the intersection:
dict_intersection_2 = { k: dict_of_dicts_a[k] | dict_of_dicts_b[k] for k in shared_keys }
在这种情况下，两者的键值相同的字典值"a"将是相同的结果。
In [1]: d1 = {'a':1, 'b':4, 'f':3}
In [2]: d2 = {'a':1, 'b':4, 'd':2}
In [3]: d = {x:d1[x] for x in d1 if x in d2}
In [4]: d
Out[4]: {'a': 1, 'b': 4}
在 Python 3 中，您可以使用
intersection = dict(dict1.items() & dict2.items())
union = dict(dict1.items() | dict2.items())
difference = dict(dict1.items() ^ dict2.items())
好的，这是 Python3 中上述代码的通用版本。它经过优化以使用足够快的理解和类似集合的 dict 视图。
函数与任意多个 dicts 相交并返回一个带有公共键的 dict 和每个公共键的一组公共值：
def dict_intersect(*dicts):
comm_keys = dicts[0].keys()
for d in dicts[1:]:
# intersect keys first
comm_keys &= d.keys()
# then build a result dict with nested comprehension
result = {key:{d[key] for d in dicts} for key in comm_keys}
return result
使用示例：
a = {1: 'ba', 2: 'boon', 3: 'spam', 4:'eggs'}
b = {1: 'ham', 2:'baboon', 3: 'sausages'}
c = {1: 'more eggs', 3: 'cabbage'}
res = dict_intersect(a, b, c)
# Here is res (the order of values may vary) :
# {1: {'ham', 'more eggs', 'ba'}, 3: {'spam', 'sausages', 'cabbage'}}
这里的 dict 值必须是可散列的，如果不是，您可以简单地将集合括号 { } 更改为 list [ ]：
result = {key:[d[key] for d in dicts] for key in comm_keys}
到目前为止，没有一个解决方案可以解决相交 N 个字典的一般情况。
N任意字典的交集：from functools import reduce
def dict_intersection(*dict_list):
return reduce(lambda a,b: dict(a.items() & b.items()), dict_list)
a = {k:k for k in range(0,5)} # {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}
b = {k:k for k in range(2,7)} # {2: 2, 3: 3, 4: 4, 5: 5, 6: 6}
c = {k:k for k in range(3,8)} # {3: 3, 4: 4, 5: 5, 6: 6, 7: 7}
dict_intersection(a,b,c) # {3:3, 4:4}
# or if you have a list of dicts
dicts = [{k:k for k in range(0+n,5+n)} for n in (0,2,3)] # == [a,b,c]
dict_intersection(*dicts) # {3:3, 4:4}
使用functools.reduce允许在字典列表上的单次迭代中完成操作，而不是某些解决方案中的多个循环。它也不执行任何额外的条件语句。
更改dict_intersection_v1为dict_intersection_v2我们可以看到它对于更大的字典和/或字典列表执行得更快（设计一个适当的实验来测试哪个是更大的因素超出了这个解决方案的范围）。这种性能提升是由于减少了字典实例化的数量。
def dict_intersection_v1(*dict_list):
return reduce(lambda a,b: dict(a.items() & b.items()), dict_list)
def dict_intersection_v2(*dict_list):
return dict(reduce(lambda a,b: a & b, (d.items() for d in dict_list)))
dict_lst1 = [{k:k for k in range(0+n,5+n)} for n in (0,2,3)] # = [a,b,c]
dict_lst2 = [{k:k for k in range(0,50,n)} for n in range(1,5)]]
dict_lst3 = [{k:k for k in range(0,500,n)} for n in range(40)]
dict_lst4 = [{k:k for k in range(0+n,500+n)} for n in range(400)]
| 字典列表 | kv 对数 | dict_intersection_v1 | dict_intersection_v2 | 相对差异 |
|---|---|---|---|---|
| 1 | 15 | 每个循环 808 ns ± 4.31 ns（平均值 ± 标准偏差。7 次运行，每次 1000000 次循环） | 每个循环 821 ns ± 0.785 ns（平均值 ± 标准偏差。7 次运行，每次 1000000 次循环） | + 1.6% |
| 2 | 105 | 每个循环 3.14 µs ± 11.9 ns（平均值 ± 标准偏差。7 次运行，每次 100000 次循环） | 每个循环 2.38 µs ± 5.76 ns（平均值 ± 标准偏差。7 次运行，每次 100000 次循环） | -24.2% |
| 3 | 2155 | 每个循环 36.9 µs ± 61.9 ns（平均值 ± 标准偏差。7 次运行，每次 10000 次循环） | 每个循环 25.1 µs ± 131 ns（平均值 ± 标准偏差。7 次运行，每次 10000 次循环） | -32.0% |
| 4 | 200_000 | 每个循环 9.08 毫秒 ± 22 微秒（平均值 ± 标准偏差。7 次运行，每次 100 次循环） | 每个循环 4.88 毫秒 ± 5.31 微秒（平均值 ± 标准偏差。7 次运行，每次 100 次循环） | -46.3% |
结果的回归dict_lst1主要是由于在每个交叉点之后创建字典之间的开销dict.items()与生成器内的调用产生的开销（以及 python 的一般函数调用开销）之间的差异。
注意：我确实使用字典的预先计算列表
dict.items()而不是 v2 即时构建生成器进行了测试。我测试了在计时之外和计时内传入预先计算的列表，虽然它具有统计学意义，但分别小于 30 μs 和 10 μs。如果您想获得这些收益，请查看不同的语言或 Cython 可能会更好。
d1 = {'a':1}
d2 = {'b':2, 'a':1}
{x:d1[x] for x in d1 if x in d2 and d1[x] == d2[x]}
>> {'a':1}
只需使用一个简单的类来包装字典实例，该类可以获取您想要的两个值
class DictionaryIntersection(object):
def __init__(self,dictA,dictB):
self.dictA = dictA
self.dictB = dictB
def __getitem__(self,attr):
if attr not in self.dictA or attr not in self.dictB:
raise KeyError('Not in both dictionaries,key: %s' % attr)
return self.dictA[attr],self.dictB[attr]
x = {'foo' : 5, 'bar' :6}
y = {'bar' : 'meow' , 'qux' : 8}
z = DictionaryIntersection(x,y)
print z['bar']
您的问题不够精确，无法给出单一答案。
如果您想ID从帖子中相交 s （致 James），请执行以下操作：
common_ids = p1.keys() & p2.keys()
但是，如果您想迭代文档，则必须考虑哪个帖子具有优先级，我认为它是p1. 迭代文档common_ids,collections.ChainMap将是最有用的：
from collections import ChainMap
intersection = {id: document
for id, document in ChainMap(p1, p2)
if id in common_ids}
for id, document in intersection:
...
或者，如果您不想创建单独的intersection字典：
from collections import ChainMap
posts = ChainMap(p1, p2)
for id in common_ids:
document = posts[id]
如果您想将两个帖子的项目相交，这意味着匹配IDs 和文档，请使用下面的代码（归功于 DCPY）。但是，这仅在您要查找重复项时才有用。
duplicates = dict(p1.items() & p2.items())
for id, document in duplicates:
...
p1'AND' p2。如果通过“ 'AND'搜索”并使用iter您的意思是搜索两个帖子，那么collections.ChainMap最好再次迭代（几乎）多个帖子中的所有项目：
from collections import ChainMap
for id, document in ChainMap(p1, p2):
...
def two_keys(term_a, term_b, index):
doc_ids = set(index[term_a].keys()) & set(index[term_b].keys())
doc_store = index[term_a] # index[term_b] would work also
return {doc_id: doc_store[doc_id] for doc_id in doc_ids}
def n_keys(terms, index):
doc_ids = set.intersection(*[set(index[term].keys()) for term in terms])
doc_store = index[term[0]]
return {doc_id: doc_store[doc_id] for doc_id in doc_ids}
In [0]: index = {'a': {1: 'a b'},
'b': {1: 'a b'}}
In [1]: two_keys('a','b', index)
Out[1]: {1: 'a b'}
In [2]: n_keys(['a','b'], index)
Out[2]: {1: 'a b'}
我建议将您的索引从
index = {term: {doc_id: doc}}
到两个索引，一个是术语，然后是一个单独的索引来保存值
term_index = {term: set([doc_id])}
doc_store = {doc_id: doc}
这样您就不会存储相同数据的多个副本