将字典转换为namedtuple或其他可哈希的dict-like的Python方法?


72

我有一本字典,例如:

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

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


根据文档,没有更短的方法。但是,您可以扩展该类并实现该方法。
blasrodri

使用namedtuple,您应该一次创建一次namedtuple类型并重复使用它,而不是每次都生成一个新的namedtuple类型。每次生成新的namedtuple类型的速度都很慢,并且无法充分利用空间。
user2357112支持Monica's

1
@ user2357112大概是,用户有许多使用相同键的字典。
wim

2
不会有同时构造类型和元组的内置方法,因为您应该重用类型。
user2357112支持Monica's

完全同意@ user2357112。从字典定义命名元组是一种单行代码,nt = namedTupleConstructor(** d)。第一行是新类的定义,应该重新使用。
FLab

Answers:


111

要创建子类,您可以直接传递字典的键:

MyTuple = namedtuple('MyTuple', d)

现在要根据此字典或任何其他具有匹配键的字典创建元组实例:

my_tuple = MyTuple(**d)

当心: namedtuple比较(有序)。它们旨在替代常规元组,并具有命名属性访问作为附加功能。进行相等比较时,将不考虑字段名称。它可能不是您想要的,也不是您期望的namedtuple那种!这不同于dict相等性比较,后者不但考虑了键而且还比较了不可知顺序。

对于真正不需要类型是tuple子类的读者,首先使用namedtuple可能没有多大意义。如果只想在字段上使用属性访问语法,则创建名称空间对象将变得更加简单:

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

我想将字典转换为namedtuple的原因是它变得可散列,但仍然像字典一样仍然可用

对于像食谱这样的可散列的“ attrdict”,请检查一个冻结的

>>> 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-将冻结地图类型添加到集合中


5
对于单行代码,您需要:MyNamedTuple = namedtuple('MyNamedTuple',d.keys())(** d)
FLab

有趣的是,命名空间是否可哈希化?这是我当初之所以想要一个字典转换为namedtuple
最大功率

3
@MaxPower:你知道你从构建namedtuples{'a': 1}{'b': 1}将是平等的,并且具有相同的哈希码?类似tuple(sorted(d.items()))frozenset(d.items())可能更合适。他们还将处理不是有效的Python标识符的键,例如'for'3
user2357112支持Monica's

1
@MaxPower:tuple(sorted(d.items()))将构造不同的元组,因为它在实际元组中包含键。(请注意,它要求键必须是可排序的,这对于字符串来说是很好的,并且您已经在依赖该frozenset键。该事物将处理无序键。)正在构造的namedtuple不将键包含在元组本身中。
user2357112支持Monica

1
如果只有1个字典,为什么“应该”使用SimpleNamespace而不是namedtuple?
马特·威尔基

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

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

2
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.firstNameobj.id

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


1

我发现以下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'))

0

看一下这个:

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__of处理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)."

0

尽管我喜欢@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

0

如果您想要一种更简单的方法,并且可以灵活使用其他方法,而不是namedtuple我建议使用SimpleNamespacedocs)。

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是类型,而不是类

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.