Accediendo a python dict con cadena de búsqueda de claves múltiples

Question

Estoy buscando crear un mecanismo simple de "búsqueda" en python, y quería asegurarme de que no había algo escondido en las vastas bibliotecas de python que aún no funciona esto antes de crearlo.

Busco a tomar un diccionario que tiene el formato algo como esto

my_dict = { 
    "root": { 
    "secondary": { 
     "user1": { 
      "name": "jim", 
      "age": 24 
     }, 
     "user2": { 
     "name": "fred", 
     "age": 25 
     } 
    } 
    } 
} 

y yo estoy tratando de tener una forma de acceder a los datos mediante el uso de una notación decimal que sería algo similar a

root.secondary.user2 

y devolver esa respuesta resultante como respuesta. Estoy pensando que debe haber algo que haga esto y que podría escribir uno sin mucha dificultad, pero quiero asegurarme de que no estoy recreando algo que pueda faltar en la documentación. Gracias

Answer 1

No hay nada en la biblioteca estándar para este propósito, pero es bastante fácil de codificar esto por sí mismo:

>>> key = "root.secondary.user2" 
>>> reduce(dict.get, key.split("."), my_dict) 
{'age': 25, 'name': 'fred'} 

Esto explota el hecho de que la consulta para la clave k en el diccionario d se puede escribir como dict.get(d, k). Aplicar esto iterativamente usando reduce() conduce al resultado deseado.

Editar: Para completar tres funciones para obtener, establecer o eliminar claves del diccionario utilizando este método:

def get_key(my_dict, key): 
    return reduce(dict.get, key.split("."), my_dict) 

def set_key(my_dict, key, value): 
    key = key.split(".") 
    my_dict = reduce(dict.get, key[:-1], my_dict) 
    my_dict[key[-1]] = value 

def del_key(my_dict, key): 
    key = key.split(".") 
    my_dict = reduce(dict.get, key[:-1], my_dict) 
    del my_dict[key[-1]] 

Answer 2

recursividad todavía funciona.

def walk_into(dict, key): 
    head, _, tail = key.partition('.') 
    if tail: 
     return walk_into(dict[head], tail) 
    return dict, key 
d, k = walk_into(my_dict, "root.secondary.user2") 

d[k] se puede utilizar para obtener o poner un nuevo valor.

Answer 3

Puede tener eso. Puede subclasificar dict, agregar la búsqueda de claves (e incluso conservar el nombre dict) utilizando un código similar al siguiente. Sin embargo, el formulario {...} seguirá utilizando la clase dict incorporada (ahora llamada orig_dict), por lo que debe adjuntarla, como el siguiente: Dict({...}). Esta implementación recursivamente convierte diccionarios a la nueva forma, por lo que no tiene que usar el método anterior para las entradas de diccionario que son simples diccionarios.

orig_dict = dict 
class Dict(orig_dict): 
    def __init__(self, *args, **kwargs): 
     super(Dict, self).__init__(*args, **kwargs) 
     for k, v in self.iteritems(): 
      if type(v) == orig_dict and not isinstance(v, Dict): 
       super(Dict, self).__setitem__(k, Dict(v)) 
    def __getattribute__(self, k): 
     try: return super(Dict, self).__getattribute__(k) 
     except: return self.__getitem__(k) 
    def __setattr__(self, k, v): 
     if self.has_key(k): self.__setitem__(k, v) 
     else: return super(Dict, self).__setattr__(k, v) 
    def __delattr__(self, k): 
     try: self.__delitem__(k) 
     except: super(Dict, self).__delattr__(k) 
    def __setitem__(self, k, v): 
     toconvert = type(v) == orig_dict and not isinstance(v, Dict) 
     super(Dict, self).__setitem__(k, Dict(v) if toconvert else v) 

# dict = Dict <-- you can even do this but I advise against it 

# testing: 
b = Dict(a=1, b=Dict(c=2, d=3)) 
c = Dict({'a': 1, 'b': {'c': 2, 'd': 3}}) 
d = Dict(a=1, b={'c': 2, 'd': {'e': 3, 'f': {'g': 4}}}) 

b.a = b.b 
b.b = 1 
d.b.d.f.g = 40 
del d.b.d.e 
d.b.c += d.b.d.f.g 
c.b.c += c.a 
del c.a 
print b 
print c 
print d