Python 如何在包含字典的列表列表中查找交集

现在，我正在使用上找到的方法2，代码如下：

# Python3 code to demonstrate  
# common element extraction form N lists  
# using map() + intersection() 
  
# initializing list of lists 
test_list = [[2, 3, 5, 8], [2, 6, 7, 3], [10, 9, 2, 3]] 
  
# printing original list 
print ("The original list is : " + str(test_list)) 
  
# common element extraction form N lists 
# using map() + intersection() 
res = list(set.intersection(*map(set, test_list))) 
  
# printing result 
print ("The common elements from N lists : " + str(res)) 

原始列表是：[[2,3,5,8]，[2,6,7,3]，[10,9,2,3]]

N个列表中的公共元素：[2,3]

我想做同样的事情，除了使用

test_list = [[dict2,dict3,dict5,dict8],[dict2,dict6,dict7,dict3],[dict10,dict9,dict2,dict3]]

在哪里,

原来的名单是：

test_list = [[dict2,dict3,dict5,dict8],[dict2,dict6,dict7,dict3],[dict10,dict9,dict2,dict3]]

---

N列表中的公共元素：[dict2，dict3]

您不能使用

set

技术，因为集合中的元素需要是可散列的，而dicts则不是。您可以在DICT之间进行相等性比较测试，但必须“手动”进行。下面是一个示例解决方案，您可以通过从第一个子列表的副本开始，然后删除不在其余子列表中的项目来获得交集

dict2 = {"foo": [2]}
dict3 = {"foo": 3}
dict5 = {"bar": 5}
dict6 = {"bar": []}
dict7 = {"bar": 7}
dict8 = {"bar": 8}
dict9 = {"baz": 9}
dict10 = {"quux": 10}

test_list = [[dict2,dict3,dict5,dict8],
             [dict2,dict6,dict7,dict3],
             [dict10,dict9,dict2,dict3]]

answer = test_list[0].copy()
for lst in test_list[1:]:
    remove_indices = [i for i, item in enumerate(answer) if item not in lst]
    for i in remove_indices[::-1]:
        answer.pop(i)

print(answer)

印刷品：

[{'foo': [2]}, {'foo': 3}]

---

不能使用

set

技术，因为集合的元素需要是可散列的，而dict则不是。您可以在DICT之间进行相等性比较测试，但必须“手动”进行。下面是一个示例解决方案，您可以通过从第一个子列表的副本开始，然后删除不在其余子列表中的项目来获得交集

dict2 = {"foo": [2]}
dict3 = {"foo": 3}
dict5 = {"bar": 5}
dict6 = {"bar": []}
dict7 = {"bar": 7}
dict8 = {"bar": 8}
dict9 = {"baz": 9}
dict10 = {"quux": 10}

test_list = [[dict2,dict3,dict5,dict8],
             [dict2,dict6,dict7,dict3],
             [dict10,dict9,dict2,dict3]]

answer = test_list[0].copy()
for lst in test_list[1:]:
    remove_indices = [i for i, item in enumerate(answer) if item not in lst]
    for i in remove_indices[::-1]:
        answer.pop(i)

print(answer)

印刷品：

[{'foo': [2]}, {'foo': 3}]

---

dict是不可散列的，因此

set（一个dict）

不起作用

定义

class my_dict(dict):

     @classmethod
     def freeze(cls, obj):
          if isinstance(obj, dict):
              obj_with_frozen_values = {k: cls.freeze(v) for k, v in obj.items()}
              # sort on keys to get one specific order
              return frozenset(sorted(obj_with_frozen_values.items(), key=lambda k: k[0]))
          if isinstance(obj, (set, tuple, list)):
              obj_type = str(type(obj))
              frozen_obj = tuple([cls.freeze(v) for v in obj])
              return frozenset((obj_type, frozen_obj))  # add extra info obj type
          return obj

     def __hash__(self):
          return hash(self.freeze(self))

（这应考虑dict/列表等本身的内部值）

---

然后将所有dict映射到我的dict。希望这能解决问题。

dict是不可散列的，因此

set（a_dict）

不起作用

定义

class my_dict(dict):

     @classmethod
     def freeze(cls, obj):
          if isinstance(obj, dict):
              obj_with_frozen_values = {k: cls.freeze(v) for k, v in obj.items()}
              # sort on keys to get one specific order
              return frozenset(sorted(obj_with_frozen_values.items(), key=lambda k: k[0]))
          if isinstance(obj, (set, tuple, list)):
              obj_type = str(type(obj))
              frozen_obj = tuple([cls.freeze(v) for v in obj])
              return frozenset((obj_type, frozen_obj))  # add extra info obj type
          return obj

     def __hash__(self):
          return hash(self.freeze(self))

（这应考虑dict/列表等本身的内部值）

---

然后将所有dict映射到我的dict。希望这能解决这个问题。

一组dict需要可散列的项，但dict不是。 让我们定义一个自定义的

dict

类hashable。（我指的是这篇文章。）

导入json
课堂用语（dict）：
“”“自定义dict类哈希表”“”
定义散列（自我）：
返回散列（frozenset（json.dumps（self，sort\u keys=True）））
dict2=dictem（{“foo”：[2]}）
dict3=dictem（{“foo”：3}）
dict5=dictem（{“bar”：5}）
dict6=DICTTEM（{“条”：[]}）
dict7=dictem（{“bar”：7}）
dict8=dictem（{“bar”：8}）
dict9=dictem（{“baz”：9}）
dict10=dictem（{“quox”：10}）
测试列表=[[dict2，dict3，dict5，dict8]，
[dict2，dict6，dict7，dict3]，
[dict10，dict9，dict2，dict3]]
res=列表（集合交叉点（*地图（集合，测试列表）））
#打印结果
打印（“N个列表中的公共元素：“+str（res））

集合需要可散列的项，但DICT不需要。 让我们定义一个自定义的

dict

类hashable。（我指的是这篇文章。）

导入json
课堂用语（dict）：
“”“自定义dict类哈希表”“”
定义散列（自我）：
返回散列（frozenset（json.dumps（self，sort\u keys=True）））
dict2=dictem（{“foo”：[2]}）
dict3=dictem（{“foo”：3}）
dict5=dictem（{“bar”：5}）
dict6=DICTTEM（{“条”：[]}）
dict7=dictem（{“bar”：7}）
dict8=dictem（{“bar”：8}）
dict9=dictem（{“baz”：9}）
dict10=dictem（{“quox”：10}）
测试列表=[[dict2，dict3，dict5，dict8]，
[dict2，dict6，dict7，dict3]，
[dict10，dict9，dict2，dict3]]
res=列表（集合交叉点（*地图（集合，测试列表）））
#打印结果
打印（“N个列表中的公共元素：“+str（res））

这似乎只适用于长度为2的词典您可以将其应用于任何类型的词典。这似乎只适用于长度为2的词典您可以将其应用于任何类型的词典。您可以保留原始解决方案，您只需使用字典的集合操作即可。您可以保留原始解决方案，只需使用字典的集合操作即可。