¿Cómo puedo hacer un diccionario con varias claves para un valor?

Question

Tengo una pregunta sobre un diccionario que quiero hacer. Mi objetivo es tener varias claves para un único valor, como a continuación:

dictionary = {('a', 'b'): 1, ('c', 'd'): 2} 
assert dictionary['a'] == 1 
assert dictionary['b'] == 1 

¿Alguna idea?

Answer 1

Su código sólo funciona:

In [1]: mydict ={('a','b'):1,('c','d'):2} 

In [2]: mydict 
Out[2]: {('a', 'b'): 1, ('c', 'd'): 2} 

In [3]: mydict['a', 'b'] 
Out[3]: 1 

In [4]: mydict[('a', 'b')] 
Out[4]: 1 

Tenga en cuenta que el código anterior se ejecutó usando Python 2.7.8.

Answer 2

supongo que quiere decir esto:

class Value: 
    def __init__(self, v=None): 
     self.v = v 

v1 = Value(1) 
v2 = Value(2) 

d = {'a': v1, 'b': v1, 'c': v2, 'd': v2} 
d['a'].v += 1 

d['b'].v == 2 # True 

• cadenas y números de Python son inmutables objetos,
• Por lo tanto, si desea d['a'] y d['b'] para apuntar a el mismo valor que " actualiza "a medida que cambia, haga que el valor se refiera a un objeto mutable (clase definida por el usuario como la anterior, o dict, list, set).
• Luego, cuando modifica el objeto en d['a'], d['b'] cambia al mismo tiempo porque ambos apuntan al mismo objeto.

Answer 3

Su ejemplo crea varios pares clave: valor si usa fromkeys. Si no quiere esto, puede usar una clave y crear un alias para la clave. Por ejemplo, si está utilizando un mapa de registro, su clave puede ser la dirección de registro y el alias puede ser el nombre de registro. De esta forma puede realizar operaciones de lectura/escritura en el registro correcto.

>>> mydict = {} 
>>> mydict[(1,2)] = [30, 20] 
>>> alias1 = (1,2) 
>>> print mydict[alias1] 
[30, 20] 
>>> mydict[(1,3)] = [30, 30] 
>>> print mydict 
{(1, 2): [30, 20], (1, 3): [30, 30]} 
>>> alias1 in mydict 
True 

Answer 4

Si vas a añadir a este diccionario con frecuencia te gustaría tomar un enfoque basado en la clase, algo similar a la respuesta de @ Latty en esta cuestión de forma 2d-dictionary-with-many-keys-that-will-return-the-same-value.

Sin embargo, si tiene un diccionario estático, y solo necesita acceder a los valores mediante varias teclas, entonces puede utilizar la sencilla ruta de dos diccionarios. Uno para almacenar la asociación de clave alias y uno para almacenar sus datos reales:

alias = { 
    'a': 'id1', 
    'b': 'id1', 
    'c': 'id2', 
    'd': 'id2' 
} 

dict = { 
    'id1': 1, 
    'id2': 2 
} 

dict[alias['a']] 

Si es necesario agregar al diccionario se podría escribir una función como esta para el uso de los dos diccionarios:

def add(key, id, value=None) 
    if id in dict: 
     if key in alias: 
      # Do nothing 
      pass 
     else: 
      alias[key] = id 
    else: 
     dict[id] = value 
     alias[key] = id 

add('e', 'id2') 
add('f', 'id3', 3) 

Mientras que Esto funciona, creo que, en última instancia, si quieres hacer algo como esto, escribir tu propia estructura de datos es probablemente el camino a seguir, aunque podría usar una estructura similar.

Answer 5

Es simple. Lo primero que debes entender es el diseño del intérprete de Python. No asigna memoria para todas las variables básicamente si dos o más variables tienen el mismo valor que solo asigna a ese valor.

vamos al ejemplo de código,

In [6]: a = 10 

In [7]: id(a) 
Out[7]: 10914656 

In [8]: b = 10 

In [9]: id(b) 
Out[9]: 10914656 

In [10]: c = 11 

In [11]: id(c) 
Out[11]: 10914688 

In [12]: d = 21 

In [13]: id(d) 
Out[13]: 10915008 

In [14]: e = 11 

In [15]: id(e) 
Out[15]: 10914688 

In [16]: e = 21 

In [17]: id(e) 
Out[17]: 10915008 

In [18]: e is d 
Out[18]: True 
In [19]: e = 30 

In [20]: id(e) 
Out[20]: 10915296 

Desde la salida anterior, las variables de Acciones A y B la misma memoria, cyd tiene memoria diferente cuando se crea una nueva variable electrónico y almacenar un valor (11) que ya está presente en la variable c, por lo que se asignó a esa ubicación de memoria y no crea una nueva memoria cuando cambio el valor presente en la variable e a 21 que ya está presente en la variable d, por lo que ahora las variables dy e comparte la misma ubicación de memoria. Por último, cambio el valor de la variable e a 30 que no está almacenado en ninguna otra variable, por lo que crea una nueva memoria para e.

por lo que cualquier variable que tenga el mismo valor comparte la memoria.

Not for list and dictionary objects

vamos a hacer su pregunta.

cuando varias teclas tienen el mismo valor, todas comparten la misma memoria, por lo que lo que usted espera ya está en python.

simplemente puede utilizar de esta manera

In [49]: dictionary = { 
    ...:  'k1':1, 
    ...:  'k2':1, 
    ...:  'k3':2, 
    ...:  'k4':2} 
    ...:  
    ...:  

In [50]: id(dictionary['k1']) 
Out[50]: 10914368 

In [51]: id(dictionary['k2']) 
Out[51]: 10914368 

In [52]: id(dictionary['k3']) 
Out[52]: 10914400 

In [53]: id(dictionary['k4']) 
Out[53]: 10914400 

A partir del resultado anterior, la clave k1 y k2 mapeado en la misma dirección de lo que significa el valor que se almacena sólo una vez en la memoria, que es el diccionario de valor única llave múltiple esto es lo que quieres : P