Trouver des clés correspondantes dans deux grands dictionnaires et le faire rapidement

Je suis en train d'essayer de trouver des clés correspondantes dans les deux dictionnaires. Chacun a environ 600k entrées.

Dire par exemple:

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

Je veux afficher la valeur pour Actinobacter (8924342) car il correspond à une valeur dans myRDP.

Le code suivant fonctionne, mais c'est très lent:

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

J'ai essayé ce qui suit, mais il en résulte toujours dans un KeyError:

    for key in myRDP:
        print myNames[key]

Est là peut-être une fonction implémentée en C pour le faire? J'ai googlé autour, mais rien ne semble fonctionner.

Grâce.

source d'informationauteur Austin Richardson

bioinformatics python

Utiliser des ensembles, parce qu'ils ont un intersection méthode qui devrait être rapide:

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

38

Vous pourriez faire ceci:
```
for key in myRDP:
    if key in myNames:
        print key, myNames[key]
```
Votre première tentative a été lent car vous avez été en comparant chaque clé dans myRDP avec chaque clé dans myNames. Algorithmique jargon, si myRDP a n éléments et myNames a m éléments, alors que l'algorithme prendrait O(n×m) opérations. Pour 600k éléments de chaque, c'est 360,000,000,000 comparaisons!

Mais de tester si un élément particulier est l'une des clés d'un dictionnaire est rapide -- en fait, c'est l'une des caractéristiques déterminantes de dictionnaires. Algorithmique termes, la key in dict test est O(1), ou constante de temps. Donc, mon algorithme prendra O(n), qui est l'une de 600 000 ème de l'époque.

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

dict.get retourne la valeur par défaut de la donner (dans ce cas, None) si la clé n'existe pas.

5

Vous pourriez commencer par trouver les clés communs et puis en itérant sur eux. Définir les opérations doivent être rapides, car ils sont mis en œuvre en C, au moins dans les versions modernes de Python.
```
common_keys = set(myRDP).intersection(myNames)
for key in common_keys:
    print key, myNames[key]
```
5

en python 3, vous pouvez simplement faire

myNames.keys() & myRDP.keys()

Utiliser le get plutôt la méthode:

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

0

Copier les deux dictionnaires en un dictionnaire/matrice. Cela a un sens, comme vous l'avez 1:1 les valeurs liées. Ensuite, vous avez besoin que d'une recherche, pas de comparaison boucle, et peut accéder à la valeur liée directement.

Exemple Dictionnaire/Tableau:

[Name][Value1][Value2] [Actinobacter][GATCGA...TCA][8924342] [XYZbacter][BCABCA...ABC][43594344]

...

Voici mon code pour faire des intersections, les syndicats, les différences et les autres opérations sur les dictionnaires:

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()

Vous devez vous connecter pour publier un commentaire.