Питонический способ преобразования словаря в namedtuple или другой Хэшируемый dict-подобный?

у меня есть словарь, как:

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

UPDATE: как обсуждалось в комментариях, моя причина желания преобразовать мой словарь в namedtuple так что она становится hashable, но еще в целом полезная, как дикт.

18
dictionary namedtuple python

4 ответов

чтобы создать подкласс, вы можете просто передать ключи dict напрямую:

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

теперь, чтобы создать экземпляры из этого Дикта или других диктовок с соответствующими ключами:

my_tuple = MyTuple(**d)

внимание: namedtuples сравнить на значения (заказал). Они предназначены для замены обычных кортежей с доступом к именованному атрибуту в качестве добавленной функции. имена полей не будут учитываться при равенстве сравнения. Это отличается от dict сравнения равенства, которые учитывают ключи, и это может быть не то, что вы хотели и не ожидали от namedtuple тип!

если у вас есть только один дикт, а не куча диктов, разделяющих один и тот же набор ключей, то нет смысла создавать этот 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
22

вы можете использовать эту функцию для обработки вложенных словарей:

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
1

зацени вот это:

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.тест:

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