python-使用哪种数据结构作为DICT数组？

我需要构建这样的数据结构：

{
    key: {k: v for k in range(fixed_small_number)}
    for key in range(fixed_large_number)
}

问题是，我正在以一种“折衷”的方式构建它，在这种方式下，每次都会有一个项目放入一个随机k作为一个随机键，也就是说，我需要随机访问，我需要内部dict是可变的

因此，我的问题分为两部分：

外部目录的建议类型

内部目录的建议类型

对我来说，“最好”的解决方案是一个可变名称的数组，只是它不存在

我可以使用一个名为tuples的列表，然后用新数据重新创建每一个，但这听起来非常浪费，因为这些列表没有随机访问效率，而且所有数据都被重写了

有没有我不知道的神奇的新结构

编辑： 用法示例：

for key, k, v in [('a', 1, 2), ('b', 1, 3), ('a', 2, 1), ('a', 3, 1), ('b', 3, 1) ...]:
    my_structre[key][k] = v

编辑2：

---

事实证明，列表确实可以

您可以构建一个自定义类，使用

\uuuuuu插槽\uuuuuuu

来限制使用的内存量：

class MutableEfficientNamedList(object):
    __slots__ = ('field1', 'field2', 'field3')

    def __init__(self, *values):
        for k, v in zip(self.__slots__, values):
            setattr(self, k, v)

    def __getitem__(self, i):
        return getattr(self, self.__slots__[i])

    def __setitem__(self, i, v):
        return setattr(self, self.__slots__[i], v)

    def __repr__(self):
        return '{}({})'.format(type(self).__name__, 
            ', '.join(repr(getattr(self, s)) for s in self.__slots__))

然后在你的结构中使用这些。它们可以像命名元组一样使用（允许通过索引和名称进行访问），但它们允许变异。通过使用

\uuuuu插槽

每个实例的内存占用率保持较低：

>>> menl = MutableEfficientNamedList('foo', 'bar', 'baz')
>>> menl
MutableEfficientNamedList('foo', 'bar', 'baz')
>>> menl.field1
'foo'
>>> menl[0]
'foo'
>>> menl[1]
'bar'
>>> menl[1] = 'spam'
>>> menl.field2
'spam'

当然，您会给插槽起一个有意义的名称，请为您的类选择一个比我在示例中使用的名称更好的名称。：-）

要扩展

namedtuple（）

模式，这里有一个通用的工厂函数：

def namedlist(name, *attrs):
    """Create a named list class named `name` with attributes `attrs`.
       `attrs` must be strings representing valid Python identifiers.
    """
    class MutableEfficientNamedList(object):
        __slots__ = attrs

        def __init__(self, *values):
            for k, v in zip(self.__slots__, values):
                setattr(self, k, v)

        def __getitem__(self, i):
            return getattr(self, self.__slots__[i])

        def __setitem__(self, i, v):
            return setattr(self, self.__slots__[i], v)

        def __repr__(self):
            return '{}({})'.format(type(self).__name__, 
                ', '.join(repr(getattr(self, s)) for s in self.__slots__))

    MutableEfficientNamedList.__name__ = name
    return MutableEfficientNamedList

MyList = namedlist('MyList', 'foo', 'bar', 'baz')
nl = MyList(1, 2, 3)
print nl  # MyList(1, 2, 3)
print nl.bar  # 2
print nl[1]  # 2

def method(iter_of_3_item_iters):
    d = defaultdict(dict)
    for (a, b, c) in iter_of_3_item_iters:
        d[a][b] = c
    return d

---

defaultdict

感觉就在这里：

from collections import defaultdict

d = defaultdict(lambda: defaultdict(int))

d[3][4] = 10

如果您想要固定大小的列表，

defaultdict

是否涵盖：

d = defaultdict(lambda: [None]*fixed_small_number)

d[3][4] = 10
# d[3] is now [None, None, None, None, 10, None, None, ...]

举个例子：

for key, k, v in [('a', 1, 2), ('b', 1, 3), ('a', 2, 1), ('a', 3, 1), ('b', 3, 1) ...]:
    my_structre[key][k] = v

解决办法确实是使用

答复:

{'a': {1: 2, 2: 1, 3: 1}, 'b': {1: 3, 3: 1}}

作为一项功能：

def namedlist(name, *attrs):
    """Create a named list class named `name` with attributes `attrs`.
       `attrs` must be strings representing valid Python identifiers.
    """
    class MutableEfficientNamedList(object):
        __slots__ = attrs

        def __init__(self, *values):
            for k, v in zip(self.__slots__, values):
                setattr(self, k, v)

        def __getitem__(self, i):
            return getattr(self, self.__slots__[i])

        def __setitem__(self, i, v):
            return setattr(self, self.__slots__[i], v)

        def __repr__(self):
            return '{}({})'.format(type(self).__name__, 
                ', '.join(repr(getattr(self, s)) for s in self.__slots__))

    MutableEfficientNamedList.__name__ = name
    return MutableEfficientNamedList

MyList = namedlist('MyList', 'foo', 'bar', 'baz')
nl = MyList(1, 2, 3)
print nl  # MyList(1, 2, 3)
print nl.bar  # 2
print nl[1]  # 2

def method(iter_of_3_item_iters):
    d = defaultdict(dict)
    for (a, b, c) in iter_of_3_item_iters:
        d[a][b] = c
    return d

---

如果我正确理解这个问题，我不确定这是否可行。诸如

dict

s之类的可变对象不能是字典键。无论如何，不清楚您要实现什么。您能否举例说明如何“折衷地”构建此数据结构？例如，给定单个更新的前后状态？我不确定我是否理解。。我建议dict作为键的作用在哪里？嵌套dict是从哪里来的？TBH一开始看起来不像是有效的Python，您应该真正扩展您的代码示例以显示您正在尝试做什么。写出实际的虚拟数据？或者

\uuu slots\uuu=['field{}'。在xrange（3）]中为i设置格式（i+1）

（当有更多字段时很有用）@nneonno:我应该使用

foo

、

bar

和

baz

作为字段名；它们是说明性的。