Plusieurs clés par valeur

Question

Est-il possible d'attribuer plusieurs clés par valeur dans un dictionnaire Python. Une solution possible est d'assigner une valeur à chaque clé:

dict = {'k1':'v1', 'k2':'v1', 'k3':'v1', 'k4':'v2'}

mais cela n'est pas efficace en termes de mémoire car mon fichier de données fait > 2 Go. Autrement, vous pourriez créer un dictionnaire de clés de dictionnaire:

key_dic = {'k1':'k1', 'k2':'k1', 'k3':'k1', 'k4':'k4'}
dict = {'k1':'v1', 'k4':'v2'}
main_key = key_dict['k2']
valeur = dict[main_key]

Cela demande également beaucoup de temps et d'efforts car je dois parcourir tout le dictionnaire/fichier deux fois. Existe-t-il une autre solution facile et intégrée en Python?

Note: mes valeurs de dictionnaire ne sont pas des chaînes simples (comme dans la question 'v1', 'v2') mais plutôt des objets complexes (contenant différents autres dictionnaires/listes, etc. et il n'est pas possible de les pickler)

Note: la question semble similaire à Comment puis-je utiliser à la fois une clé et un index pour la même valeur de dictionnaire? Mais je ne cherche pas un dictionnaire ordonné/indexé et je recherche d'autres solutions efficaces (si elles existent) autres que les deux mentionnées dans cette question.

Answer 1

De quels types sont les valeurs ?

dict = {'k1':MyClass(1), 'k2':MyClass(1)}

donnera des objets de valeurs en double, mais

v1 = MyClass(1)
dict = {'k1':v1, 'k2':v1}

résulte en ce que les deux clés font référence au même objet réel.

Dans la question originale, vos valeurs sont des chaînes de caractères : même si vous déclarez la même chaîne de caractères deux fois, je pense qu'elles seront internées vers le même objet dans ce cas

---

NB. si vous n'êtes pas sûr d'avoir obtenu des doublons, vous pouvez le vérifier comme suit :

if dict['k1'] is dict['k2']:
    print("bon : k1 et k2 réfèrent au même instance")
else:
    print("mauvais : k1 et k2 réfèrent à des instances différentes")

(vérification du is grâce à J.F.Sebastian, remplaçant id())

Answer 2

Consultez ceci - c'est une implémentation exacte de ce que vous demandez : multi_key_dict(ionary)

https://pypi.python.org/pypi/multi_key_dict (sources at https://github.com/formiaczek/python_data_structures/tree/master/multi_key_dict)

(sur les plateformes Unix, il est possible qu'il soit fourni en tant que package et vous pouvez essayer de l'installer avec quelque chose comme :

sudo apt-get install python-multi-key-dict

pour Debian, ou un équivalent pour votre distribution)

Vous pouvez utilisez différents types de clés mais aussi des clés du même type. Vous pouvez également itérer sur les éléments en utilisant les types de clés de votre choix, par exemple :

m = multi_key_dict()
m['aa', 12] = 12
m['bb', 1] = 'cc et 1'
m['cc', 13] = 'quelque chose d'autre'

print m['aa']   # affichera '12'
print m[12]     # affichera également '12'

# mais aussi :
for key, value in m.iteritems(int):
    print key, ':', value
# affichera :
# 1 : cc et 1
# 12 : 12
# 13 : quelque chose d'autre

# et en itérant sur des clés de type string :
for key, value in m.iteritems(str):
    print key, ':', value
# affichera:
# aa : 12
# cc : quelque chose d'autre
# bb : cc et 1

m[12] = 20 # maintenant mettre à jour la valeur
print m[12]   # affichera '20' (valeur mise à jour)
print m['aa']   # affichera également '20' (il se réfère au même élément)

Il n'y a pas de limite au nombre de clés, donc du code comme :

m['a', 3, 5, 'bb', 33] = 'quelque chose' 

est valide, et l'un des clés peut être utilisée pour se référer à la valeur ainsi créée (pour la lire / écrire ou la supprimer).

Édition : À partir de la version 2.0, cela devrait également fonctionner avec python3.

Answer 3

En utilisant python 2.7/3, vous pouvez combiner une paire de tuple, valeur avec une compréhension de dictionnaire.

keys_values = ( (('k1','k2'), 0), (('k3','k4','k5'), 1) )

d = { key : value for keys, value in keys_values for key in keys }

Vous pouvez également mettre à jour le dictionnaire de manière similaire.

keys_values = ( (('k1',), int), (('k3','k4','k6'), int) )

d.update({ key : value for keys, value in keys_values for key in keys })

Je ne pense pas que cela réponde vraiment à votre question, mais compte tenu du titre, je pense que cela a sa place ici.

Answer 4

La manière la plus simple de le faire est de construire votre dictionnaire en utilisant la méthode dict.fromkeys(). Elle prend une séquence de clés et une valeur en entrée, puis attribue la valeur à chaque clé.
Votre code serait :

dict = dict.fromkeys(['k1', 'k2', 'k3'], 'v1')
dict.update(dict.fromkeys(['k4'], 'v2'))

Et la sortie est :

print(dict)
{'k1': 'v1', 'k2': 'v1', 'k3': 'v1', 'k4': 'v2'}

Answer 5

J'ai pu obtenir une fonctionnalité similaire en utilisant pandas MultiIndex, bien que dans mon cas les valeurs soient scalaires :

>>> import numpy
>>> import pandas
>>> keys = [numpy.array(['a', 'b', 'c']), numpy.array([1, 2, 3])]
>>> df = pandas.DataFrame(['val1', 'val2', 'val3'], index=keys)
>>> df.index.names = ['str', 'int']
>>> df.xs('b', axis=0, level='str')
        0
int      
2    val2

>>> df.xs(3, axis=0, level='int')
        0
str      
c    val3