Объявление многомерного словаря в python

Ответ 1

Многомерный словарь - это просто словарь, где сами значения также являются словарями, создавая вложенную структуру:

new_dic = {}
new_dic[1] = {}
new_dic[1][2] = 5

Вам придется обнаруживать, что вы уже создали new_dic[1] каждый раз, чтобы не случайно стереть этот вложенный объект для дополнительных клавиш в new_dic[1].

Вы можете упростить создание вложенных словарей с использованием различных методов; используя dict.setdefault(), например:

new_dic.setdefault(1, {})[2] = 5

dict.setdefault() будет устанавливать ключ только по умолчанию, если ключ все еще отсутствует, что избавляет вас от необходимости проверять это каждый раз.

Упрощенное использование collections.defaultdict() типа для создания вложенных словарей автоматически:

from collections import defaultdict

new_dic = defaultdict(dict)
new_dic[1][2] = 5

defaultdict является просто подклассом стандартного типа dict здесь; каждый раз, когда вы пытаетесь получить доступ к ключу, который еще не существует в сопоставлении, вызывается функция factory для создания нового значения. Здесь dict() вызываемый, который выдает пустой словарь при вызове.

Демо:

>>> new_dic_plain = {}
>>> new_dic_plain[1] = {}
>>> new_dic_plain[1][2] = 5
>>> new_dic_plain
{1: {2: 5}}
>>> new_dic_setdefault = {}
>>> new_dic_setdefault.setdefault(1, {})[2] = 5
>>> new_dic_setdefault
{1: {2: 5}}
>>> from collections import defaultdict
>>> new_dic_defaultdict = defaultdict(dict)
>>> new_dic_defaultdict[1][2] = 5
>>> new_dic_defaultdict
defaultdict(<type 'dict'>, {1: {2: 5}})

Ответ 2

Проверьте это:

def nested_dict(n, type):
    if n == 1:
        return defaultdict(type)
    else:
        return defaultdict(lambda: nested_dict(n-1, type))

И затем:

new_dict = nested_dict(2, float)

Теперь вы можете:

new_dict['key1']['key2'] += 5

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

new_dict = nested_dict(3, list)
new_dict['a']['b']['c'].append(5)

Результат будет:

new_dict['a']['b']['c'] = [5]

Ответ 3

Просто вы можете использовать defaultdict

from collections import defaultdict
new_dic = defaultdict(dict)
new_dic[1][2]=5
>>>new_dic
defaultdict(<type 'dict'>, {1: {2: 5}})

Ответ 4

Вот словарь, который содержит другой словарь в качестве значения для ключа 1:

>>> new_dic = {}
>>> new_dic[1] = {2:5}
>>> new_dic
{1: {2: 5}}

Проблема с

new_dic={}
new_dic[1][2]=5

заключается в том, что new_dic[1] не существует, поэтому вы не можете добавить словарь (или что-нибудь в этом отношении).

Ответ 5

Один простой способ - просто использовать кортежи в качестве ключей к обычному словарю. Итак, ваш пример становится следующим:

new_dic[(1, 2)] = 5

Недостатком является то, что все обычаи должны быть с этим немного неловким соглашением, но если все в порядке, это все, что вам нужно.

Ответ 6

Вы имеете в виду dict или list?

И если вы имеете в виду dict, вы хотите, чтобы второй уровень был другим dict? или list?

Для работы dict вам нужно заранее объявить ключи.

Итак, если это dicts в dicts, вам нужно что-то вроде этого:

new_dic = {}
try:
    new_dic[1][2] = 5
except KeyError:
    new_dic[1] = {2:5}

Ответ 7

u может попробовать это, это еще проще, если это строка

new_dic = {}
a = 1
new_dic[a] = {}
b = 2
new_dic[a][b] = {}
c = 5
new_dic[a][b]={c}

type

new_dic[a][b]
>>>'5'

Для строки

new_dic = {}
a = "cat"
new_dic[a] = {}
b = "dog"
new_dic[a][b] = {}
c = 5
new_dic[a][b] = {c}

тип

new_dic["cat"]["dog"]
>>>'5'

Ответ 8

Для проекта мне нужно было иметь двухмерный диктат экземпляров классов, где индексируются числа с плавающей точкой (координаты). Что я сделал, так это создал 2D dict, используя dict по умолчанию, и передал имя моего класса как тип. Например:

class myCoordinates:
    def __init__(self, args)
    self.x = args[0]
    self.y = args[1]

и тогда, когда я попытался создать словарь:

table = mult_dim_dict(2, myCoordinates, (30, 30))

где функция 'mult_dim_dict' определена как:

def mult_dim_dict(dim, dict_type, params):
    if dim == 1:
        if params is not None:
            return defaultdict(lambda: dict_type(params))
        else: 
            return defaultdict(dict_type)
    else:
        return defaultdict(lambda: mult_dim_dict(dim - 1, dict_type, params))

Примечание: вы не можете передать несколько аргументов, вместо этого вы можете передать кортеж, содержащий все ваши аргументы. Если вашему классу при создании не нужно передавать переменные, 3-й аргумент функции будет None:

class myCoors:
def __init__(self, tuple=(0, 0)):
    self.x, self.y = tuple

def printCoors(self):
    print("x = %d, y = %d" %(self.x, self.y))


def mult_dim_dict(dim, dict_type, params):
    if dim == 1:
        if params is not None:
            return defaultdict(lambda: dict_type(params))
        else:
            return defaultdict(dict_type)
    else:
        return defaultdict(lambda: mult_dim_dict(dim - 1, dict_type, params))

dict = mult_dim_dict(2, myCoors, None)
dict['3']['2'].x = 3
dict['3']['2'].y = 2

dict['3']['2'].printCoors()  # x = 3, y = 2 will be printed

dict = mult_dim_dict(2, myCoors, (30, 20))
dict['3']['2'].printCoors()  # x = 30, y = 20 will be printed