将字典转换为namedtuple或其他类似hashable dict的Pythonic方法？

我有一本字典，像：

d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

我想将其转换为namedtuple。 我当前的方法是使用以下代码

namedTupleConstructor = namedtuple('myNamedTuple', ' '.join(sorted(d.keys())))
nt= namedTupleConstructor(**d)

产生

myNamedTuple（a=1，b=2，c=3，d=4）

这对我来说很好（我想），但我是否错过了一个内置的，如

nt = namedtuple.from_dict() ?

---

更新：正如评论中所讨论的，我希望将字典转换为namedtuple的原因是它可以散列，但仍然可以像dict一样使用。

要创建子类，您可以直接传递dict的键：

MyTuple = namedtuple('MyTuple', d)

现在，要从该dict或任何其他具有匹配键的dict创建元组实例：

my_tuple = MyTuple(**d)

注意：namedtuples仅对值进行比较（有序）。它们被设计成常规元组的替代品，添加了命名属性访问功能进行相等比较时，将不考虑字段名。它可能不是您想要的，也不是您期望的

namedtuple

类型！这与

dict

相等比较不同，相等比较考虑了键，并且比较顺序不可知

对于真正不需要tuple子类类型的读者来说，首先使用namedtuple可能没有多大意义。如果您只想在字段上使用属性访问语法，那么创建对象会更简单、更容易：

>>> from types import SimpleNamespace
>>> SimpleNamespace(**d)
namespace(a=1, b=2, c=3, d=4)

我希望将字典转换为namedtuple的原因是，它可以散列，但仍然可以像dict一样使用

对于类似散列“attrdict”的配方，请查看冻结：

在Python的更高版本中也可能会出现冻结映射类型，请查看此PEP草案以了解接受或拒绝情况：

查看以下内容：

def fill_tuple(NamedTupleType, container):
    if container is None:
        args = [None] * len(NamedTupleType._fields)
        return NamedTupleType(*args)
    if isinstance(container, (list, tuple)):
        return NamedTupleType(*container)
    elif isinstance(container, dict):
        return NamedTupleType(**container)
    else:
        raise TypeError("Cannot create '{}' tuple out of {} ({}).".format(NamedTupleType.__name__, type(container).__name__, container))

名称不正确或参数计数无效的异常由

namedtuple

的

初始化处理

使用py.Test进行测试：

def test_fill_tuple():
    A = namedtuple("A", "aa, bb, cc")

    assert fill_tuple(A, None) == A(aa=None, bb=None, cc=None)
    assert fill_tuple(A, [None, None, None]) == A(aa=None, bb=None, cc=None)
    assert fill_tuple(A, [1, 2, 3]) == A(aa=1, bb=2, cc=3)
    assert fill_tuple(A, dict(aa=1, bb=2, cc=3)) == A(aa=1, bb=2, cc=3)
    with pytest.raises(TypeError) as e:
        fill_tuple(A, 2)
    assert e.value.message == "Cannot create 'A' tuple out of int (2)."

您可以使用此函数处理嵌套字典：

def create_namedtuple_from_dict(obj):
    if isinstance(obj, dict):
        fields = sorted(obj.keys())
        namedtuple_type = namedtuple(
            typename='GenericObject',
            field_names=fields,
            rename=True,
        )
        field_value_pairs = OrderedDict(
            (str(field), create_namedtuple_from_dict(obj[field]))
            for field in fields
        )
        try:
            return namedtuple_type(**field_value_pairs)
        except TypeError:
            # Cannot create namedtuple instance so fallback to dict (invalid attribute names)
            return dict(**field_value_pairs)
    elif isinstance(obj, (list, set, tuple, frozenset)):
        return [create_namedtuple_from_dict(item) for item in obj]
    else:
        return obj

虽然我喜欢@fuggy_yama answer，但在阅读之前我有了自己的函数，所以我把它放在这里只是为了展示一种不同的方法。它还处理嵌套的
namedtuples

def dict2namedtuple(thedict, name):

    thenametuple = namedtuple(name, [])

    for key, val in thedict.items():
        if not isinstance(key, str):
            msg = 'dict keys must be strings not {}'
            raise ValueError(msg.format(key.__class__))

        if not isinstance(val, dict):
            setattr(thenametuple, key, val)
        else:
            newname = dict2namedtuple(val, key)
            setattr(thenametuple, key, newname)

    return thenametuple

以
obj.name.firstName
，
obj.id

这将适用于任何数据类型的嵌套字典。
我发现以下4行最漂亮。它还支持嵌套字典

def dict_to_namedtuple(typename, data):
    return namedtuple(typename, data.keys())(
        *(dict_to_namedtuple(typename + '_' + k, v) if isinstance(v, dict) else v for k, v in data.items())
    )

输出看起来也不错：

>>> nt = dict_to_namedtuple('config', {
...     'path': '/app',
...     'debug': {'level': 'error', 'stream': 'stdout'}
... })

>>> print(nt)
config(path='/app', debug=config_debug(level='error', stream='stdout'))

如果您想要一种更简单的方法，并且您可以灵活地使用除
namedtuple
之外的另一种方法，我建议您使用
SimpleNamespace
（）

PS：SimpleNamespace是一种类型，而不是一个类
根据文档，没有更短的方法。但是，您可以扩展该类并实现该方法。对于namedtuples，您应该创建一次namedtuples类型并重复使用它，而不是每次都生成一个新的namedtuples类型。每次生成一个新的namedtuple类型的速度很慢，并且会破坏任何空间优势。@user2357112推测，用户有许多DICT具有相同的键。不会有一个内置的DICT同时构造类型和元组，因为您应该重用该类型。完全同意@user2357112。从字典定义命名元组是一个单行程序，nt=namedTupleConstructor（**d）。第一行是一个新类的定义，它应该被重用。对于一行，您需要：MyNamedTuple=namedtuple（'MyNamedTuple'，d.keys（））（**d）有趣的是，名称空间是可哈希的吗？这就是我想把口述转换成口述的最初原因namedtuple@MaxPower：您是否知道从
{'a'：1}
和
{'b'：1}
构造的namedtuple将相等，并且具有相等的哈希代码？类似于
tuple（排序的（d.items（））
或
frozenset（d.items（））
可能更合适。它们还将处理不是有效Python标识符的键，如
'for'
或
3
@MaxPower:
元组（排序的（d.items（））
将构造不同的元组，因为它包含实际元组中的键。（请注意，它要求键是可排序的，这对字符串很好，而且您已经依赖于它。
frozenset
东西将处理无序键。）您正在构造的命名元组本身不包括元组中的键。如果只有一个dict，为什么“应该”使用SimpleNamespace而不是namedtuple？
def toNametuple(dict_data):
    return namedtuple(
        "X", dict_data.keys()
    )(*tuple(map(lambda x: x if not isinstance(x, dict) else toNametuple(x), dict_data.values())))

d = {
    'id': 1,
    'name': {'firstName': 'Ritesh', 'lastName':'Dubey'},
    'list_data': [1, 2],
}

obj = toNametuple(d)

def dict_to_namedtuple(typename, data):
    return namedtuple(typename, data.keys())(
        *(dict_to_namedtuple(typename + '_' + k, v) if isinstance(v, dict) else v for k, v in data.items())
    )

>>> nt = dict_to_namedtuple('config', {
...     'path': '/app',
...     'debug': {'level': 'error', 'stream': 'stdout'}
... })

>>> print(nt)
config(path='/app', debug=config_debug(level='error', stream='stdout'))

from types import SimpleNamespace as sn

d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dd= sn(**d)
# dd.a>>1

# add new property
dd.s = 5
#dd.s>>5