Pythonic将字典转换为namedtuple的方法，还是另一个Hashable dict-like？

Question

我有一个字典，如：

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() ?

更新：正如评论中所讨论的那样，我想将我的字典转换为一个命名元组的原因是它变得可以清洗，但仍然像dict一样可用。

Answer 1

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

MyTuple = namedtuple('MyTuple', sorted(d))

现在从这个dict或其他具有匹配键的dicts创建实例：

my_tuple = MyTuple(**d)

注意：namedtuples仅对值进行比较（有序）。它们被设计为常规元组的替代品，命名属性访问作为附加功能。进行相等比较时，不会考虑字段名称。这不同于dict平等比较，它考虑到了键，它可能不是你想要的，也不是namedtuple类型的预期！

如果你只有一个dict，而不是一堆dicts共享同一组密钥，那么首先创建这个namedtuple是没有意义的。您应该只使用命名空间对象：

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

对于像食谱一样的可清洗“attrdict”，请查看冷冻的box：

>>> from box import Box
>>> b = Box(d, frozen_box=True)
>>> hash(b)
7686694140185755210
>>> b.a
1
>>> b['a']
1

Answer 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

Answer 3

看一下这个：

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

__init__的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)."

Answer 4

虽然我喜欢@fuggy_yama回答，但在阅读之前我有自己的功能，所以我把它留在这里只是为了展示一种不同的方法。它还处理嵌套的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

Answer 5

from collections import namedtuple
nt = namedtuple('x', d.keys())(*d.values())