Carte bidirectionnelle / inversée

Question

Je suis en train de faire cette centrale chose en python où j'ai besoin de garder une trace de qui parle à qui, donc, si Alice --> Bob, alors cela implique que Bob --> Alice.

Oui, j'ai pu remplir deux hachage des cartes, mais je me demandais si quelqu'un a une idée pour le faire avec un.

Ou suggérer une autre structure de données.

Il n'y a pas plusieurs conversations. Disons que c'est pour un service à la clientèle centre d'appel, de sorte que lorsque Alice cadrans dans la centrale, elle va parler à Bob. Ses réponses vont également à lui.

Answer 1

Vous pouvez créer votre propre type de dictionnaire en sous-classant dict et en ajoutant la logique de votre choix. Voici un exemple de base:

 class TwoWayDict(dict):
    def __setitem__(self, key, value):
        # Remove any previous connections with these values
        if key in self:
            del self[key]
        if value in self:
            del self[value]
        dict.__setitem__(self, key, value)
        dict.__setitem__(self, value, key)

    def __delitem__(self, key):
        dict.__delitem__(self, self[key])
        dict.__delitem__(self, key)

    def __len__(self):
        """Returns the number of connections"""
        return dict.__len__(self) // 2
 

Et ça marche comme ça:

 >>> d = TwoWayDict()
>>> d['foo'] = 'bar'
>>> d['foo']
'bar'
>>> d['bar']
'foo'
>>> len(d)
1
>>> del d['foo']
>>> d['bar']
Traceback (most recent call last):
  File "<stdin>", line 7, in <module>
KeyError: 'bar'
 

Je suis sûr que je n'ai pas couvert tous les cas, mais cela devrait vous aider à commencer.

Answer 2

Dans votre cas particulier, vous pouvez stocker les deux dans un seul dictionnaire:

 relation = {}
relation['Alice'] = 'Bob'
relation['Bob'] = 'Alice'
 

Puisque ce que vous décrivez est une relation symétrique. A -> B => B -> A

Answer 3

Je voudrais juste peupler un deuxième hash, avec

 reverse_map = dict((reversed(item) for item in forward_map.items()))
 

Answer 4

Deux cartes de hachage est probablement la solution la plus rapide, en supposant que vous puissiez économiser de la mémoire. Je voudrais envelopper ceux-ci dans une seule classe - le fardeau pour le programmeur est de s'assurer que deux cartes de hachage se synchronisent correctement.

Answer 5

Vous avez deux problèmes distincts.

1. Vous avez un objet "Conversation". Il fait référence à deux personnes. Puisqu'une personne peut avoir plusieurs conversations, vous avez une relation plusieurs à plusieurs.

2. Vous avez une carte de personne à une liste de conversations. Une conversion aura une paire de personnes.

Faire quelque chose comme ça

 from collections import defaultdict
switchboard= defaultdict( list )

x = Conversation( "Alice", "Bob" )
y = Conversation( "Alice", "Charlie" )

for c in ( x, y ):
    switchboard[c.p1].append( c )
    switchboard[c.p2].append( c )