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

Question

我有一本像这样的字典：

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

我想将其转换为命名元组。 我目前的方法是使用以下代码

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

产生

myNamedTuple(a=1, b=2, c=3, d=4)

这对我来说很好用（我认为），但是我是否缺少诸如...的内置功能。

nt = namedtuple.from_dict() ?

更新：正如 cmets 中所讨论的，我想要将我的字典转换为命名元组的原因是它变得可散列，但通常仍然可以像字典一样使用。

UPDATE2：在我发布这个问题 4 年后，TLK posts a new answer 推荐使用我认为非常棒的数据类装饰器。我认为这就是我现在将使用的方式。

Answer 1

要创建子类，你可以直接传递字典的键：

MyTuple = namedtuple('MyTuple', d)

现在从这个字典或任何其他具有匹配键的字典创建元组实例：

my_tuple = MyTuple(**d)

注意：namedtuples 仅比较 值（有序）。它们旨在成为常规元组的直接替代品，并将命名属性访问作为附加功能。 进行相等比较时不会考虑字段名称。 namedtuple 类型可能不是您想要或期望的！这与 dict 相等比较不同，后者确实考虑了键并比较顺序不可知。

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

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

我想要将我的字典转换为命名元组的原因是它变得可散列，但通常仍然可以像字典一样使用

对于类似食谱的可散列“属性”，请查看冷冻的box：

>>> from box import Box
>>> b = Box(d, frozen_box=True)
>>> hash(b)
7686694140185755210
>>> b.a
1
>>> b["a"]
1
>>> b["a"] = 2
BoxError: Box is frozen

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

PEP 603 -- Adding a frozenmap type to collections

Answer 2

看看这个：

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 3

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

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

Answer 6

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)

以obj.name.firstName、obj.id 身份访问

这适用于任何数据类型的嵌套字典。

Answer 7

我觉得以下 4-liner 最漂亮。它也支持嵌套字典。

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

Answer 8

如果您想要一种更简单的方法，并且可以灵活地使用 namedtuple 以外的其他方法，我建议您使用 SimpleNamespace (docs)。

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

PS：SimpleNamespace 是一个类型，而不是一个类

Answer 9

我想针对这种情况推荐 dataclass。类似于命名元组，但具有更大的灵活性。

https://docs.python.org/3/library/dataclasses.html

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost(self) -> float:
        return self.unit_price * self.quantity_on_hand

Answer 10

使用字典键作为命名元组的字段名

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

def dict_to_namedtuple(d):
    return namedtuple('GenericDict', d.keys())(**d)

 result=dict_to_namedtuple(d)
 print(result)

输出

  GenericDict(a=1, b=2, c=3, d=4)