python: serializar un diccionario en una salida html simple

usando el motor de aplicaciones, sí, lo sé todo acerca de las plantillas django y otros motores de plantillas.

Digamos que tengo un diccionario o un objeto simple, no conozco su estructura y quiero serializarlo en html.

así que si tuviera

{'data':{'id':1,'title':'home','address':{'street':'some road','city':'anycity','postal':'somepostal'}}} 

el deseo que quiero es que se represente en alguna forma de html legible usando listas o tablas;

 data: id:1 title:home address: street: some road city: anycity postal:somepostal 

ahora sé que puedo hacer

 for key in dict.items print dict[key] 

pero eso no se sumerge en los valores secundarios y enumera cada clave, par de valores cuando la clave / valor es un diccionario, es decir, la dirección dict.

Es un módulo para python que es ligero / rápido que hará esto muy bien. o ¿alguien tiene algún código simple que pueda pegar que pueda hacer esto?

Solución Todas las soluciones aquí fueron útiles. pprint es sin duda el medio más estable de imprimir el diccionario, aunque no llega a devolver nada cerca de html. Aunque todavía se puede imprimir.

Terminé con esto por ahora:

 def printitems(dictObj, indent=0): p=[] p.append('
    \n') for k,v in dictObj.iteritems(): if isinstance(v, dict): p.append('
  • '+ k+ ':') p.append(printitems(v)) p.append('
  • ') else: p.append('
  • '+ k+ ':'+ v+ '
  • ') p.append('
\n') return '\n'.join(p)

Convierte el dictado en listas desordenadas, lo que está bien por ahora. algunos css y quizás un poco de retoque deberían hacerlo legible.

Voy a recompensar la respuesta a la persona que escribió el código anterior. Hice un par de pequeños cambios ya que las listas desordenadas no estaban anidando. Espero que todos estén de acuerdo en que muchas de las soluciones ofrecidas resultaron ser útiles, pero el código anterior representa una verdadera representación html de un diccionario, incluso si es crudo.

El ejemplo hecho por pyfunc podría modificarse fácilmente para generar listas html anidadas simples.

 z = {'data':{'id':1,'title':'home','address':{'street':'some road','city':'anycity','postal':'somepostal'}}} def printItems(dictObj, indent): print ' '*indent + '
    \n' for k,v in dictObj.iteritems(): if isinstance(v, dict): print ' '*indent , '
  • ', k, ':', '
  • ' printItems(v, indent+1) else: print ' '*indent , '
  • ', k, ':', v, '
  • ' print ' '*indent + '
\n' printItems(z,0)

No terriblemente bonito, por supuesto, pero un lugar para comenzar tal vez. Si todo lo que quiere hacer es visualizar datos, el módulo de impresión realmente es lo suficientemente bueno. Puede usar la etiqueta “pre” en el resultado de pprint y colocarla en su página web.

La versión pprint se vería así:

 import pprint z = {'data':{'id':1,'title':'home','address':{'street':'some road','city':'anycity','postal':'somepostal'}}} print '
', pprint.pformat(z), '

'

Y la salida html se ve algo como esto:

 {'data': {'address': {'city': 'anycity', 'postal': 'somepostal', 'street': 'some road'}, 'id': 1, 'title': 'home'}} 

Lo que no es tan bonito, pero al menos muestra los datos de una manera más estructurada.

 import pprint pprint.pprint(yourDict) 

Bueno, no HTML, pero similar a su enfoque for/print .

EDITAR: o utilizar:

 niceText = pprint.pformat(yourDict) 

esto le dará el mismo resultado agradable con todas las sangrías, etc. Ahora puede iterar sobre líneas y formatearlo en HTML:

 htmlLines = [] for textLine in pprint.pformat(yourDict).splitlines(): htmlLines.append('
%s' % textLine) # or something even nicer htmlText = '\n'.join(htmlLines)

Mira mi implementación:

 def pretty_items(r, d, nametag="%s: ", itemtag='
  • %s
  • ', valuetag="%s", blocktag=('
      ', '
    ')): if isinstance(d, dict): r.append(blocktag[0]) for k, v in d.iteritems(): name = nametag % k if isinstance(v, dict) or isinstance(v, list): r.append(itemtag % name) pretty_items(r, v) else: value = valuetag % v r.append(itemtag % (name + value)) r.append(blocktag[1]) elif isinstance(d, list): r.append(blocktag[0]) for i in d: if isinstance(i, dict) or isinstance(i, list): r.append(itemtag % " - ") pretty_items(r, i) else: r.append(itemtag % i) r.append(blocktag[1])

    Enviará todos los elementos en formato HTML utilizando las tags

      y

    • . Y también es opcional para cambiar las tags. Y luego, solo usa CSS para manejar con la sangría.

      Podrías usar bonito print (pprint)

      o si desea realizar un procesamiento adicional de la pantalla, debe ejecutar el dictado usted mismo.

      Tenga en cuenta que el código es burdo y requerirá numerosos refinamientos. La solución también usa la recursión, lo cual es malo si la profundidad de la recursión es mayor.

       z = {'data':{'id':1,'title':'home','address':{'street':'some road','city':'anycity','postal':'somepostal', 'telephone':{'home':'xxx','offie':'yyy'}}}} def printItems(dictObj, indent): it = dictObj.iteritems() for k,v in it: if isinstance(v, dict): print ' '*indent , k, ':' printItems(v, indent+1) else: print ' '*indent , k, ':', v printItems(z,0) 

      Salida:

        data : address : city : anycity postal : somepostal street : some road telephone : home : xxx offie : yyy id : 1 title : home 

      Necesitaba algo similar, pero también quería imprimir bonitas listas y listas dentro del dict. Esto es lo que se me ocurrió:

       def format(self, obj, indent = 1): if isinstance(obj, list): htmls = [] for k in obj: htmls.append(self.format(k,indent+1)) return '[
      %s
      ]' % (indent, ',
      '.join(htmls)) if isinstance(obj, dict): htmls = [] for k,v in obj.iteritems(): htmls.append("%s: %s" % (k,self.format(v,indent+1))) return '{
      %s
      }' % (indent, ',
      '.join(htmls)) return str(obj)

      Luego, si está usando la aplicación web en appengine, puede hacer lo siguiente:

       self.response.out.write(self.format(obj)) 

      Este es un ejemplo de la salida:

      introduzca la descripción de la imagen aquí

      Ninguno de los ejemplos anteriores da buenos resultados, por lo que escribí dos de mis propias funciones que crean resultados html de apariencia hermosa para los diccionarios.

       def dict_to_html(dd, level=0): """ Convert dict to html using basic html tags """ import simplejson text = '' for k, v in dd.iteritems(): text += '
      ' + ' '*(4*level) + '%s: %s' % (k, dict_to_html(v, level+1) if isinstance(v, dict) else (simplejson.dumps(v) if isinstance(v, list) else v)) return text def dict_to_html_ul(dd, level=0): """ Convert dict to html using ul/li tags """ import simplejson text = '
        ' for k, v in dd.iteritems(): text += '
      • %s: %s
      • ' % (k, dict_to_html_ul(v, level+1) if isinstance(v, dict) else (simplejson.dumps(v) if isinstance(v, list) else v)) text += '
      ' return text

      Aquí está mi versión con soporte de listas (las labels son nombres detallados de claves en el diccionario):

       def render_value(value, labels): if isinstance(value, (list, tuple)): return render_list(value, labels) elif isinstance(value, dict): return render_dict(value, labels) else: return value def render_list(lst, labels): items = [ '
    • %s
    • ' % render_value(value, labels) for value in lst ] return '\n'.join(['\n
        '] + items + ['
      \n']) def render_dict(dct, labels): items = [] for key, value in dct.items(): if not value: continue key = labels.get(key, key) value = render_value(value, labels) items.append('
    • %s: %s
    • ' % (key, value)) return '\n'.join(['\n
        '] + items + ['
      \n'])

      imagina que tenemos esto: {name: "a", children:[{name: "b", children: [] },{..},{..}]

       def ConvertDictToUlLi(): jsonResult = GetSomeRecursiveDict() def CreateHtml(DictItem, output): output = "
    • "+DictItem["name"] if jsonResult.has_key("name") else " " if len(DictItem["children"]) > 0: output = output + "
        " for item in DictItem["children"]: output = output + " "+CreateHtml(item, output)+" " output = output + "
      " return output+"
    • " result = "
        "+CreateHtml(jsonResult, "")+"
      " return result