Как сделать словарь с несколькими ключами одним значением?

Ответ 1

Ваш код работает только:

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 

Обратите внимание, что приведенный выше код был выполнен с использованием Python 2.7.8.

Ответ 2

Я думаю, вы имеете в виду это:

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

• Строки и числа Python являются неизменяемыми объектами,
• Итак, если вы хотите, чтобы d['a'] и d['b'] указывали на одно и то же значение, которое "обновляется" по мере его изменения, сделайте это значение ссылкой на изменяемый объект (пользовательский класс, например выше, или dict, list, set).
• Затем, когда вы изменяете объект в d['a'], d['b'] изменяется в одно и то же время, потому что оба они указывают на один и тот же объект.

Ответ 3

В вашем примере создается несколько пар ключ: значение, если используется fromkeys. Если вы этого не хотите, вы можете использовать один ключ и создать псевдоним для ключа. Например, если вы используете карту регистров, ваш ключ может быть адресом регистра, и псевдоним может быть именем регистра. Таким образом, вы можете выполнять операции чтения/записи в правильном регистре.

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

Ответ 4

Если вы собираетесь добавлять в этот словарь часто, вам нужно использовать подход, основанный на классах, что-то похожее на ответ @Latty в этом вопросе SO 2d-dictionary-with-many-keys-that-will-return-the то же значение

Тем не менее, если у вас есть статический словарь, и вам нужен доступ к значениям только по нескольким ключам, тогда вы можете просто пойти по очень простому пути использования двух словарей. Один для хранения связи с псевдонимом и один для хранения ваших фактических данных:

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

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

dictionary[alias['a']]

Если вам нужно добавить в словарь, вы можете написать такую функцию для использования обоих словарей:

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

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

Хотя это работает, я думаю, что в конечном итоге, если вы захотите сделать что-то подобное, написание собственной структуры данных, вероятно, будет правильным решением, хотя она может использовать аналогичную структуру.

Ответ 5

Это просто. Первое, что вам нужно понять, дизайн интерпретатора Python. Он не выделяет память для всех переменных в основном, если какая-либо из двух или более переменных имеет то же значение, что и для этого значения.

отпустите пример кода,

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

Из вышесказанного, переменные a и b имеют одну и ту же память, c и d имеют разную память, когда я создаю новую переменную e и сохраняю значение (11), которое уже присутствует в переменной c, поэтому оно сопоставлено с этим памяти и не создает новую память, когда я изменяю значение, присутствующее в переменной e до 21, которое уже присутствует в переменной d, поэтому теперь переменные d и e используют одну и ту же ячейку памяти. Наконец, я изменяю значение в переменной e до 30, которое не сохраняется ни в одной другой переменной, поэтому создает новую память для e.

поэтому любая переменная, имеющая одно и то же значение, разделяет память.

Не для объектов списка и словаря

позвольте прийти к вашему вопросу.

когда несколько ключей имеют одинаковое значение, тогда все они используют одну и ту же память, поэтому ожидаемая вещь уже существует в python.

вы можете просто использовать его так

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

Из вышеприведенного вывода ключ k1 и k2 сопоставляется с тем же адресом, который означает значение, которое хранится только один раз в памяти, который является многократным одноразовым словарем, это то, что вы хотите.: P