将字典转换为 namedtuple 或其他类似哈希的字典的 Pythonic 方法？
Posted
技术标签:
【中文标题】将字典转换为 namedtuple 或其他类似哈希的字典的 Pythonic 方法？【英文标题】：Pythonic way to convert a dictionary into namedtuple or another hashable dict-like? 【发布时间】：2017-10-10 19:12:12 【问题描述】：我有一本像这样的字典：
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 推荐使用我认为非常棒的数据类装饰器。我认为这就是我现在将使用的方式。
【问题讨论】：
使用 namedtuple，你应该创建一次 namedtuple 类型并重复使用它，而不是每次都生成一个新的 namedtuple 类型。每次生成一个新的 namedtuple 类型都很慢，而且会破坏任何空间优势。 @user2357112 大概，用户有许多具有相同键的字典。 不会有一个内置的同时构造类型和元组，因为你应该重用类型。 要另辟蹊径（namedtuple 进入字典），请看这里：***.com/q/26180528/674039 【参考方案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
【讨论】：
对于单行，你需要： MyNamedTuple = namedtuple('MyNamedTuple', d.keys())(**d) 有趣，命名空间是否可散列？这就是我想要将 dict 转换为 namedtuple 的最初原因 @MaxPower：你知道你从'a': 1 和'b': 1 构造的namedtuples 将是相等的，并且具有相等的哈希码吗？像tuple(sorted(d.items())) 或frozenset(d.items()) 这样的东西可能更合适。它们还将处理不是有效 Python 标识符的键，例如 'for' 或 3。
@MaxPower: tuple(sorted(d.items())) 会构造不同的元组，因为它包含实际元组中的键。 （请注意，它要求键是可排序的，这对于字符串来说很好，并且您已经依赖它。frozenset 事物将处理不可排序的键。）您正在构建的命名元组不包括键元组本身。
如果只有 1 个字典，为什么“应该”使用 SimpleNamespace 而不是 namedtuple？【参考方案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)."
【讨论】：
【参考方案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
【讨论】：
【参考方案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
【讨论】：
【参考方案5】：from collections import namedtuple
nt = namedtuple('x', d.keys())(*d.values())
【讨论】：
【参考方案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 身份访问
这适用于任何数据类型的嵌套字典。
【讨论】：
【参考方案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'))
【讨论】：
【参考方案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 是一个类型，而不是一个类
【讨论】：
是否有一种可散列的方式来做到这一点【参考方案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
【讨论】：
嘿，谢谢你添加这个，我真的很喜欢这个答案。将更新链接到我的问题，以便人们看到这一点。 很棒的答案。请注意，dataclasses 有一个asdict 帮助函数，以确保可以根据需要对 dataclass 实例进行序列化。
对于更复杂的用例 - 例如。如果你想在反序列化时重新映射键，需要使用嵌套数据类，或者在序列化时排除默认值，我建议使用像dataclass-wizard 这样的快速序列化库。【参考方案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)
【讨论】：
你可以通过d 迭代 d 无论如何都会产生密钥。以上是关于将字典转换为 namedtuple 或其他类似哈希的字典的 Pythonic 方法？的主要内容，如果未能解决你的问题，请参考以下文章