Pythonic Moyen de Convertir Dictionnaire namedtuple, ou un Autre Hashable dict-like?

J'ai un dictionnaire comme:

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

que je voudrais convertir en namedtuple.
Ma démarche actuelle est, avec le code suivant

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

qui produit

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

Cela fonctionne très bien pour moi (je pense), mais je manque un intégré tel que... 

nt = namedtuple.from_dict() ?

Mise à JOUR: comme expliqué dans les commentaires, ma raison de vouloir convertir mon dictionnaire à un namedtuple est de sorte qu'il devient hashable, mais encore utilisable d'une manière générale comme un dict.

  • Selon la documentation, il n'y a pas un moyen plus court. Cependant, vous pouvez étendre la classe et de mettre en œuvre la méthode.
  • Avec namedtuples, vous êtes censé créer de la namedtuple type une fois et l'utiliser à plusieurs reprises, de ne pas générer un nouveau namedtuple taper à chaque fois. La génération d'une nouvelle namedtuple type de tous les temps est lent et l'emporte sur tout l'espace de prestations.
  • sans doute, l'utilisateur dispose de nombreuses dicts avec les mêmes touches.
  • Il ne va pas être intégré dans des constructions du type et de la n-uplet dans le même temps, parce que vous êtes censé pour réutiliser le type.
  • Totalement d'accord avec @user2357112. La définition d'un nommé tuple du dictionnaire est un one-liner, nt= namedTupleConstructor(**d). La première ligne est la définition d'une nouvelle classe, qui est censé être ré-utilisé.
InformationsquelleAutor Max Power | 2017-05-11
  1. 50

    Pour créer la sous-classe, vous pouvez simplement passer les clés d'une dict directement:

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

    Maintenant de créer des instances de ce dict, ou d'autres dicts avec les touches correspondantes:

    my_tuple = MyTuple(**d)

    Attention: namedtuples comparer sur uniquement les valeurs de (ordonnée). Ils sont conçus pour être une baisse-dans le remplacement régulier de n-uplets, avec attribut nommé d'accès comme une fonction supplémentaire. Les noms de champ ne seront pas considérés lors de la prise de l'égalité des comparaisons. Ce qui diffère de l' dict de comparaison d'égalité, qui prennent en compte les clés, et il peut ne pas être ce que vous avez voulu ni prévu à partir de la namedtuple type!

    Si vous avez seulement une dict, plutôt que d'un tas de dicts partage le même jeu de clés, alors il est inutile de créer ce namedtuple en premier lieu. Vous devriez utiliser un espace de noms de l'objet à la place:

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

    Pour un hashable "attrdict" comme recette, découvrez une gelée boîte:

    >>> from box import Box
>>> b = Box(d, frozen_box=True)
>>> hash(b)
7686694140185755210
>>> b.a
1
>>> b['a']
1
    • Pour le one-liner, vous devez: MyNamedTuple = namedtuple('MyNamedTuple', d.keys())(**d)
    • Intéressant, est un espace de Noms hashable? C'était ma raison de vouloir convertir un dict pour un namedtuple
    • Savez-vous que le namedtuples vous construisez à partir de {'a': 1} et {'b': 1} vont être l'égalité, et l'égalité des codes de hachage? Quelque chose comme tuple(sorted(d.items())) ou frozenset(d.items()) peut être plus approprié. Ils vont également gérer les clés qui ne sont pas valide identifiants Python, comme 'for' ou 3.
    • Je n'étais pas au courant de ça, merci pour l'info. Donc, {'a':1} et {'b':1} allait devenir différents de n-uplets (tuples avec les différents hachages), mais ils deviendraient égaux namedtuples?
    • construire différents tuples, car il comprend les clés dans le réel n-uplets. (À noter qu'elle a besoin de clés pour être sortable, ce qui est bien pour les chaînes, et que vous êtes déjà en s'appuyant sur. Le frozenset chose serait en mesure de gérer unorderable clés.) Le namedtuples vous êtes la construction ne comprennent pas les clés dans les tuples eux-mêmes.
    • Juste pour élargir sur @Graisse du commentaire--si vous utilisez 3.5+, à l'aide de la namedtuple constructeur crée une nouvelle sous-classe à chaque fois que vous prenez un énorme gain de performance sur la définition d'une sous-classe de première avec typing.NamedTuple et ensuite de faire MyTuple(**d) si vous le faites plusieurs fois

    InformationsquelleAutor wim
  2. 1

    Vous pouvez utiliser cette fonction pour gérer imbriqués les dictionnaires:

    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
    InformationsquelleAutor fuggy_yama
  3. 0

    Check this out:

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

    Exceptions pour les noms incorrects ou invalid argument de comptage est assuré par __init__ de namedtuple.

    Test avec 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)."
    InformationsquelleAutor Mikaelblomkvistsson
  4. 0

    Bien que j'aime @fuggy_yama réponse, avant de le lire j'ai obtenu mon propre fonction, donc, je laisse ici de montrer qu'une approche différente. Il gère aussi imbriquée 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
    InformationsquelleAutor Rodrigo E. Principe
  5. 0
    from collections import namedtuple
nt = namedtuple('x', d.keys())(*d.values())
    InformationsquelleAutor Mitendra
  6. 0
    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)

    Accès obj.name.firstName, obj.id

    Cela fonctionne pour imbriquée dictionnaire avec tous les types de données.

    InformationsquelleAutor Ritesh Dubey