¿Una forma pitónica de convertir un diccionario en una tupla nombrada u otro dictado hashable?

Tengo un diccionario como:

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

que me gustaría convertir en una tupla con nombre. Mi enfoque actual es con el siguiente código

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

que produce

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

Esto funciona bien para mí (creo), pero me falta un incorporado como…

nt = namedtuple.from_dict() ?

ACTUALIZACIÓN: como se discutió en los comentarios, mi razón para querer convertir mi diccionario a una tupla con nombre es para que se vuelva hashable, pero aún se pueda usar en general como un dictado.

ACTUALIZACIÓN 2: 4 años después de publicar esta pregunta, TLK publica una nueva respuesta que recomienda usar el decorador de clase de datos que creo que es realmente genial. Creo que eso es ahora lo que usaría en el futuro.

Para crear la subclase, puede simplemente pasar las claves de un dict directamente:

MyTuple = namedtuple('MyTuple', d)

Ahora, para crear instancias de tupla a partir de este dictado, o cualquier otro dictado con claves coincidentes:

my_tuple = MyTuple(**d)

Tener cuidado: tuplas nombradas comparar en solo valores (ordenado). Están diseñados para ser un reemplazo directo de las tuplas regulares, con acceso a atributos con nombre como característica adicional. Los nombres de los campos no se tendrán en cuenta al realizar comparaciones de igualdad.. Puede que no sea lo que querías ni esperabas del namedtuple ¡escribe! Esto difiere de dict comparaciones de igualdad, que sí tienen en cuenta las claves y también comparan orden agnóstico.

Para los lectores que realmente no necesitan un tipo que sea una subclase de tupla, probablemente no tenga mucho sentido usar una tupla con nombre en primer lugar. Si solo desea usar la sintaxis de acceso de atributos en los campos, sería más simple y más fácil de crear espacio de nombres objetos en su lugar:

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

mi razón para querer convertir mi diccionario a una tupla con nombre es para que se vuelva hashable, pero aún se pueda usar en general como un dict

Para obtener una receta similar a “attrdict” hashable, echa un vistazo a un congelado caja:

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

También puede haber un tipo de mapeo congelado que viene en una versión posterior de Python, mire este borrador de PEP para aceptación o rechazo:

PEP 603 — Agregar un tipo de mapa congelado a las colecciones

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

Me gustaría recomendar el clase de datos para este tipo de situación. Similar a una tupla con nombre, pero con más flexibilidad.

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

Si desea un enfoque más fácil y tiene la flexibilidad de utilizar otro enfoque que no sea namedtuple Me gustaría sugerir el uso SimpleNamespace (documentos).

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

PD: SimpleNamespace es un tipo, no una clase

Puede usar esta función para manejar diccionarios anidados:

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

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)

Acceder como obj.name.firstName, obj.id

Esto funcionará para el diccionario anidado con cualquier tipo de datos.

Encuentro el siguiente 4-liner el más hermoso. También admite diccionarios anidados.

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

La salida se verá bien también:

>>> nt = dict_to_namedtuple('config', {
...     'path': '/app',
...     'debug': {'level': 'error', 'stream': 'stdout'}
... })

>>> print(nt)
config(path="/app", debug=config_debug(level="error", stream='stdout'))