查找匹配的密钥在两个大字典，做快

Question

我想找到两个不同的字典相应的键。每个具有大约600K的条目。

说，例如：

    myRDP = { 'Actinobacter': 'GATCGA...TCA', 'subtilus sp.': 'ATCGATT...ACT' }
    myNames = { 'Actinobacter': '8924342' }

我想打印出来Actinobacter（8924342）中的值，因为它在一个myRDP值相匹配。

下面的代码的工作，但是很慢的：

    for key in myRDP:
        for jey in myNames:
            if key == jey:
                print key, myNames[key]

我已经尝试了以下但它总是导致KeyError异常：

    for key in myRDP:
        print myNames[key]

是否有可能用C做这个实现的功能？我GOOGLE了四周，但似乎没有任何工作。

感谢。

Answer 1

使用套，因为它们具有内置intersection方法，该方法应当是快速的：

myRDP = { 'Actinobacter': 'GATCGA...TCA', 'subtilus sp.': 'ATCGATT...ACT' }
myNames = { 'Actinobacter': '8924342' }

rdpSet = set(myRDP)
namesSet = set(myNames)

for name in rdpSet.intersection(namesSet):
    print name, myNames[name]

# Prints: Actinobacter 8924342

Answer 2

您可以这样做：

for key in myRDP:
    if key in myNames:
        print key, myNames[key]

您第一次尝试是缓慢的，因为你比较的在myRDP每的关键用的每一个的在myNames关键。在算法行话，如果myRDP具有<强>名词元素和myNames具有的米元素，那么该算法将需要O（<强>名词×的米）操作。对于600K元件各自，这是3600亿个比较！

但是测试特定元素是否是一个字典的一个关键是快速 - 事实上，这是字典的定义性特征之一。在算法方面，key in dict测试是O（1），或固定时间。因此，我的算法将需要O（<强>名词）的时间，这是其中的一次第六十○万。

Answer 3

在Python 3，你可以做

myNames.keys() & myRDP.keys()

Answer 4

for key in myRDP:
    name = myNames.get(key, None)
    if name:
        print key, name

dict.get如果键不存在，将返回给它的默认值（在这种情况下，None）。

Answer 5

您可以通过找到共同的键，然后遍历它们开始。 Set操作要快，因为它们是用C语言实现，至少在Python的现代版本。

common_keys = set(myRDP).intersection(myNames)
for key in common_keys:
    print key, myNames[key]

Answer 6

使用get方法来代替：

 for key in myRDP:
    value = myNames.get(key)
    if value != None:
      print key, "=", value

Answer 7

最佳和最简单的方法将被简单地执行共同的一组操作（Python 3中）。

a = {"a": 1, "b":2, "c":3, "d":4}
b = {"t1": 1, "b":2, "e":5, "c":3}
res = a.items() & b.items() # {('b', 2), ('c', 3)} For common Key and Value
res = {i[0]:i[1] for i in res}  # In dict format
common_keys = a.keys() & b.keys()  # {'b', 'c'}

干杯！

Answer 8

两个字典复制到的一个字典/阵列。这是有道理的，你有1：1的相关值。然后，你只需要一个搜索，没有比较回路，并可以直接访问相关的值。

实施例所得的字典/阵列：

[Name][Value1][Value2]

[Actinobacter][GATCGA...TCA][8924342]

[XYZbacter][BCABCA...ABC][43594344]

...

Answer 9

下面是我的字典做相交，差异以及其他设置操作代码：

class DictDiffer(object):
    """
    Calculate the difference between two dictionaries as:
    (1) items added
    (2) items removed
    (3) keys same in both but changed values
    (4) keys same in both and unchanged values
    """
    def __init__(self, current_dict, past_dict):
        self.current_dict, self.past_dict = current_dict, past_dict
        self.set_current, self.set_past = set(current_dict.keys()), set(past_dict.keys())
        self.intersect = self.set_current.intersection(self.set_past)
    def added(self):
        return self.set_current - self.intersect 
    def removed(self):
        return self.set_past - self.intersect 
    def changed(self):
        return set(o for o in self.intersect if self.past_dict[o] != self.current_dict[o])
    def unchanged(self):
        return set(o for o in self.intersect if self.past_dict[o] == self.current_dict[o])

if __name__ == '__main__':
    import unittest
    class TestDictDifferNoChanged(unittest.TestCase):
        def setUp(self):
            self.past = dict((k, 2*k) for k in range(5))
            self.current = dict((k, 2*k) for k in range(3,8))
            self.d = DictDiffer(self.current, self.past)
        def testAdded(self):
            self.assertEqual(self.d.added(), set((5,6,7)))
        def testRemoved(self):      
            self.assertEqual(self.d.removed(), set((0,1,2)))
        def testChanged(self):
            self.assertEqual(self.d.changed(), set())
        def testUnchanged(self):
            self.assertEqual(self.d.unchanged(), set((3,4)))
    class TestDictDifferNoCUnchanged(unittest.TestCase):
        def setUp(self):
            self.past = dict((k, 2*k) for k in range(5))
            self.current = dict((k, 2*k+1) for k in range(3,8))
            self.d = DictDiffer(self.current, self.past)
        def testAdded(self):
            self.assertEqual(self.d.added(), set((5,6,7)))
        def testRemoved(self):      
            self.assertEqual(self.d.removed(), set((0,1,2)))
        def testChanged(self):
            self.assertEqual(self.d.changed(), set((3,4)))
        def testUnchanged(self):
            self.assertEqual(self.d.unchanged(), set())
    unittest.main()