Pregunta

Estoy a punto de crear una parte de un proyecto que necesitará construir y publicar un documento XML en un servicio web y me gustaría hacerlo en Python, como un medio para ampliar mis habilidades en él.

Desafortunadamente, aunque conozco bastante bien el modelo XML en .NET, no estoy seguro de cuáles son los pros y los contras de los modelos XML en Python.

¿Alguien tiene experiencia en el procesamiento XML en Python?¿Por dónde me sugerirías empezar?Los archivos XML que crearé serán bastante simples.

¿Fue útil?

Solución

Personalmente, he jugado con varias de las opciones integradas en un proyecto con mucho XML y me he decidido por dominación como la mejor opción para documentos menos complejos.

Especialmente para cosas pequeñas y simples, me gusta la teoría de análisis basada en eventos en lugar de configurar una gran cantidad de devoluciones de llamadas para una estructura relativamente simple. Aquí hay una buena discusión rápida sobre cómo usar la API..

Lo que me gusta:puedes manejar el análisis en un for bucle en lugar de utilizar devoluciones de llamada.También retrasa el análisis completo (la parte "pull") y solo obtiene detalles adicionales cuando llama expandNode().Esto satisface mi requisito general de eficiencia "responsable" sin sacrificar la facilidad de uso y la simplicidad.

Otros consejos

ElementoÁrbol tiene una buena API de Python.Creo que incluso se envía como parte de Python 2.5.

Está en Python puro y, como digo, es bastante bueno, pero si terminas necesitando más rendimiento, entonces lxml expone la misma API y usa libxml2 bajo el capó.En teoría, puedes cambiarlo cuando descubras que lo necesitas.

Hay tres formas principales de trabajar con XML, en general:dom, saxo y xpath.El modelo dom es bueno si puede permitirse el lujo de cargar todo el archivo xml en la memoria a la vez, no le importa tratar con estructuras de datos y está viendo gran parte o la mayor parte del modelo.El modelo saxofón es excelente si solo le importan unas pocas etiquetas y/o si trabaja con archivos grandes y puede procesarlos secuencialmente.El modelo xpath es un poco de cada uno: puede elegir rutas a los elementos de datos que necesita, pero requiere más bibliotecas para usar.

Si quiere algo sencillo y empaquetado con Python, minidom es su respuesta, pero es bastante aburrido, y la documentación es "aquí hay documentos sobre dom, descúbralo".Es muy molesto.

Personalmente, me gusta cElementTree, que es una implementación más rápida (basada en C) de ElementTree, que es un modelo tipo dom.

He usado sistemas saxo, y en muchos sentidos tienen una sensación más "pitónica", pero normalmente termino creando sistemas basados ​​en estados para manejarlos, y en eso radica la locura (y los errores).

Yo digo que elijas minidom si te gusta la investigación, o ElementTree si quieres un buen código que funcione bien.

He utilizado ElementTree para varios proyectos y lo recomiendo.

Es pitónico, viene "en la caja" con Python 2.5, incluida la versión c cElementTree (xml.etree.cElementTree), que es 20 veces más rápida que la versión pura de Python y es muy fácil de usar.

lxml tiene algunas ventajas de rendimiento, pero son desiguales y primero debe verificar los puntos de referencia para su caso de uso.

Según tengo entendido, el código de ElementTree se puede portar fácilmente a lxml.

Depende un poco de lo complicado que deba ser el documento.

He usado mucho minidom para escribir XML, pero normalmente solo se trata de leer documentos, realizar algunas transformaciones simples y volver a escribirlos.Eso funcionó bastante bien hasta que necesité la capacidad de ordenar atributos de elementos (para satisfacer una aplicación antigua que no analiza XML correctamente).En ese momento me di por vencido y escribí el XML yo mismo.

Si solo está trabajando en documentos simples, hacerlo usted mismo puede ser más rápido y sencillo que aprender un marco.Si es posible escribir el XML a mano, entonces probablemente también pueda codificarlo a mano (sólo recuerde escapar correctamente los caracteres especiales y utilizar str.encode(codec, errors="xmlcharrefreplace")).Aparte de estos problemas, XML es lo suficientemente regular como para que no necesidad una biblioteca especial para escribirlo.Si el documento es demasiado complicado para escribirlo a mano, entonces probablemente deberías buscar uno de los marcos ya mencionados.En ningún momento debería necesitar escribir un escritor XML general.

También puedes probar desenredar para analizar documentos XML simples.

Como mencionaste que crearás XML "bastante simple", el módulo minidom (parte de la biblioteca estándar de Python) probablemente se adapte a sus necesidades.Si tiene alguna experiencia con la representación DOM de XML, la API le resultará bastante sencilla.

Escribo un servidor SOAP que recibe solicitudes XML y crea respuestas XML.(Desafortunadamente, no es mi proyecto, por lo que es de código cerrado, pero ese es otro problema).

Resultó para mí que crear documentos XML (SOAP) es bastante sencillo si tienes una estructura de datos que "se ajusta" al esquema.

Conservo el sobre ya que el sobre de respuesta es (casi) igual que el sobre de solicitud.Luego, dado que mi estructura de datos es un diccionario (posiblemente anidado), creo una cadena que convierte este diccionario en elementos <key>value</key>.

Esta es una tarea que la recursividad simplifica y termino con la estructura correcta.Todo esto se hace en código Python y actualmente es lo suficientemente rápido para uso en producción.

También puede crear listas (relativamente) fácilmente, aunque dependiendo de su cliente, puede tener problemas a menos que dé sugerencias extensas.

Para mí, esto fue mucho más sencillo, ya que un diccionario es una forma de trabajar mucho más sencilla que alguna clase personalizada.Para los libros, generar XML es mucho más fácil que analizar.

Para un trabajo serio con XML en Python utilice lxml

Python viene con la biblioteca incorporada ElementTree, pero lxml la amplía en términos de velocidad y funcionalidad (validación de esquemas, análisis sax, XPath, varios tipos de iteradores y muchas otras características).

Tienes que instalarlo, pero en muchos lugares ya se supone que forma parte del equipamiento estándar (p. ej.Google AppEngine no permite paquetes Python basados ​​en C, pero hace una excepción para lxml, pyyaml ​​y algunos otros).

Creación de documentos XML con E-factory (desde lxml)

Su pregunta es sobre la creación de documentos XML.

Con lxml hay muchos métodos y me tomó un tiempo encontrar uno que parezca fácil de usar y también fácil de leer.

Código de muestra de documento lxml sobre el uso de E-factory (ligeramente simplificado):


E-factory proporciona una sintaxis simple y compacta para generar XML y HTML:

>>> from lxml.builder import E

>>> html = page = (
...   E.html(       # create an Element called "html"
...     E.head(
...       E.title("This is a sample document")
...     ),
...     E.body(
...       E.h1("Hello!"),
...       E.p("This is a paragraph with ", E.b("bold"), " text in it!"),
...       E.p("This is another paragraph, with a", "\n      ",
...         E.a("link", href="http://www.python.org"), "."),
...       E.p("Here are some reserved characters: <spam&egg>."),
...     )
...   )
... )

>>> print(etree.tostring(page, pretty_print=True))
<html>
  <head>
    <title>This is a sample document</title>
  </head>
  <body>
    <h1>Hello!</h1>
    <p>This is a paragraph with <b>bold</b> text in it!</p>
    <p>This is another paragraph, with a
      <a href="http://www.python.org">link</a>.</p>
    <p>Here are some reserved characters: &lt;spam&amp;egg&gt;.</p>
  </body>
</html>

Aprecio en E-factory que siga las cosas

El código se lee casi como el documento XML resultante.

La legibilidad cuenta.

Permite la creación de cualquier contenido XML.

Admite cosas como:

  • uso de espacios de nombres
  • nodos de texto iniciales y finales dentro de un elemento
  • funciones que dan formato al contenido del atributo (consulte func CLASS en muestra lxml completa)

Permite construcciones muy legibles con listas.

p.ej.:

from lxml import etree
from lxml.builder import E
lst = ["alfa", "beta", "gama"]
xml = E.root(*[E.record(itm) for itm in lst])
etree.tostring(xml, pretty_print=True)

Resultando en:

<root>
  <record>alfa</record>
  <record>beta</record>
  <record>gama</record>
</root>

Conclusiones

Recomiendo encarecidamente leer el tutorial lxml; está muy bien escrito y le dará muchas más razones para utilizar esta poderosa biblioteca.

La única desventaja de lxml es que debe compilarse.Ver Así que responde para más consejos. cómo instalar lxml desde el paquete de formato wheel en una fracción de segundo.

Si va a crear mensajes SOAP, consulte jabonlib.Utiliza ElementTree internamente, pero proporciona una interfaz mucho más limpia para serializar y deserializar mensajes.

Lo recomiendo SAX - Simple API for XML - implementación en las bibliotecas de Python.Son bastante fáciles de configurar y procesar grandes XML por incluso conducido API, como se discutió en carteles anteriores aquí, y ocupan poca memoria a diferencia de la validación DOM estilo XML analizadores.

Supongo que la forma .Net de procesar XML se basa en alguna versión de MSXML y en ese caso supongo que usar, por ejemplo, minidom te haría sentir como en casa.Sin embargo, si lo que está haciendo es un procesamiento simple, probablemente cualquier biblioteca sea suficiente.

También prefiero trabajar con ElementTree cuando trato con xml en Python, es una biblioteca muy ordenada.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top