Procesamiento XML en Python [cerrado] -- python campo con xml camp Relacionados El problema

XML Processing in Python [closed]


77
vote

problema

Español
cerrado . Esta pregunta es basada en opinión . Actualmente no está aceptando respuestas.

¿Quieres mejorar esta pregunta? Actualizar la pregunta para que pueda responderse con hechos y citas por Edición de este post .

cerrado Hace 4 años .

Mejorar esta pregunta

Estoy a punto de construir una pieza de un proyecto que necesitará construir y publicar un documento XML a un servicio web y me gustaría hacerlo en Python, como un medio para expandir mis habilidades en ella.

Desafortunadamente, mientras que conozco el modelo XML bastante bien en .NET, no estoy seguro de lo que los pros y los contras son de los modelos XML en Python.

¿Alguien tiene experiencia haciendo procesamiento XML en Python? ¿Dónde sugerirías que empiece? Los archivos XML que estaré construyendo será bastante simple.

Original en ingles

I am about to build a piece of a project that will need to construct and post an XML document to a web service and I'd like to do it in Python, as a means to expand my skills in it.

Unfortunately, whilst I know the XML model fairly well in .NET, I'm uncertain what the pros and cons are of the XML models in Python.

Anyone have experience doing XML processing in Python? Where would you suggest I start? The XML files I'll be building will be fairly simple.

</div
     
 
 

Lista de respuestas

31
 
vote
vote
La mejor respuesta
 

Personalmente, he jugado con varias de las opciones incorporadas en un proyecto XML-Heavy y se han establecido en pulldom como la mejor opción para documentos menos complejos.

Especialmente para pequeñas cosas simples, me gusta la teoría impulsada por el evento de analizar en lugar de establecer una gran cantidad de devoluciones de llamada para una estructura relativamente simple. Aquí hay una buena discusión rápida de cómo usar la API .

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

 

Personally, I've played with several of the built-in options on an XML-heavy project and have settled on pulldom as the best choice for less complex documents.

Especially for small simple stuff, I like the event-driven theory of parsing rather than setting up a whole slew of callbacks for a relatively simple structure. Here is a good quick discussion of how to use the API.

What I like: you can handle the parsing in a for loop rather than using callbacks. You also delay full parsing (the "pull" part) and only get additional detail when you call expandNode(). This satisfies my general requirement for "responsible" efficiency without sacrificing ease of use and simplicity.

</div
 
 
 
 
31
 
vote

elementaltree tiene una buena API de Pythony. Creo que incluso se envía como parte de Python 2.5

Está en python puro y, como digo, bastante agradable, pero si terminas necesitando más rendimiento, entonces lxml expone la misma API y utiliza libxml2 debajo de la capucha. Teóricamente puedes intercambiarlo cuando descubres que lo necesitas.

 

ElementTree has a nice pythony API. I think it's even shipped as part of python 2.5

It's in pure python and as I say, pretty nice, but if you wind up needing more performance, then lxml exposes the same API and uses libxml2 under the hood. You can theoretically just swap it in when you discover you need it.

</div
 
 
   
   
6
 
vote

Hay 3 formas principales de tratar con XML, en general: DOM, SAX y XPATH. El modelo DOM es bueno si puede permitirse cargar todo su archivo XML en la memoria a la vez, y no le importa lidiar con las estructuras de datos, y está buscando mucho / la mayor parte del modelo. El modelo SAX es excelente si solo se preocupa por algunas etiquetas, y / o está tratando con archivos grandes y puede procesarlos secuencialmente. El modelo XPATH es un poco de cada uno, puede elegir y elegir rutas a los elementos de datos que necesita, pero requiere más bibliotecas para usar.

Si quieres sencillo y empaquetado con Python, MiniDom es su respuesta, pero es bastante cojo, y la documentación es "Aquí hay documentos en DOM, van a resolverlo". Es realmente molesto.

Personalmente, me gusta CelementTree, que es una implementación más rápida (basada en C) de elementtree, que es un modelo similar a dom.

He usado sistemas SAX, y en muchas maneras son más "Pythonic" en su sentido, pero generalmente termino creando sistemas basados ​​en estados para manejarlos, y de esa manera se encuentra la locura (y los errores). < / p>

Digo que vaya con MiniDom si le gusta la investigación, o el elementalTree si desea un buen código que funcione bien.

 

There are 3 major ways of dealing with XML, in general: dom, sax, and xpath. The dom model is good if you can afford to load your entire xml file into memory at once, and you don't mind dealing with data structures, and you are looking at much/most of the model. The sax model is great if you only care about a few tags, and/or you are dealing with big files and can process them sequentially. The xpath model is a little bit of each -- you can pick and choose paths to the data elements you need, but it requires more libraries to use.

If you want straightforward and packaged with Python, minidom is your answer, but it's pretty lame, and the documentation is "here's docs on dom, go figure it out". It's really annoying.

Personally, I like cElementTree, which is a faster (c-based) implementation of ElementTree, which is a dom-like model.

I've used sax systems, and in many ways they're more "pythonic" in their feel, but I usually end up creating state-based systems to handle them, and that way lies madness (and bugs).

I say go with minidom if you like research, or ElementTree if you want good code that works well.

</div
 
 
 
 
6
 
vote

He usado elementtree para varios proyectos y lo recomiendo.

Es Pythonic, viene 'en la caja' con Python 2.5, incluida la versión C CelementTree (xml.etree.celementtree), que es 20 veces más rápido que la versión pure python, y es muy fácil de usar.

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

Como lo entiendo, el código ELEMENTETEE puede ser fácilmente portado a LXML.

 

I've used ElementTree for several projects and recommend it.

It's pythonic, comes 'in the box' with Python 2.5, including the c version cElementTree (xml.etree.cElementTree) which is 20 times faster than the pure Python version, and is very easy to use.

lxml has some perfomance advantages, but they are uneven and you should check the benchmarks first for your use case.

As I understand it, ElementTree code can easily be ported to lxml.

</div
 
 
6
 
vote

Depende de un poco de cuán complicado debe ser el documento.

He usado Minidom mucho para escribir XML, pero eso suele haber estado leyendo documentos, haciendo algunas transformaciones simples y que se retiran. Eso funcionó lo suficientemente bien hasta que necesitaba la capacidad de pedir atributos de elementos (para satisfacer una aplicación antigua que no analiza XML correctamente). En ese momento me rendí y escribí el XML.

Si solo está trabajando en documentos simples, entonces hacerlo usted mismo puede ser más rápido y más simple que aprender un marco. Si puede, posiblemente, puede escribir el XML a mano, entonces probablemente puede codificarlo a mano también (recuerde escapar correctamente los caracteres especiales y usar str.encode(codec, errors="xmlcharrefreplace") ). Aparte de estos SNAFUS, XML es lo suficientemente regular de que usted no lo haga, necesito una biblioteca especial para escribirla. Si el documento es demasiado complicado de escribir a mano, entonces probablemente debería examinar uno de los marcos ya mencionados. A ningún momento debe necesitar escribir un escritor general XML.

 

It depends a bit on how complicated the document needs to be.

I've used minidom a lot for writing XML, but that's usually been just reading documents, making some simple transformations, and writing them back out. That worked well enough until I needed the ability to order element attributes (to satisfy an ancient application that doesn't parse XML properly). At that point I gave up and wrote the XML myself.

If you're only working on simple documents, then doing it yourself can be quicker and simpler than learning a framework. If you can conceivably write the XML by hand, then you can probably code it by hand as well (just remember to properly escape special characters, and use str.encode(codec, errors="xmlcharrefreplace")). Apart from these snafus, XML is regular enough that you don't need a special library to write it. If the document is too complicated to write by hand, then you should probably look into one of the frameworks already mentioned. At no point should you need to write a general XML writer.

</div
 
 
5
 
vote

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

 

You can also try untangle to parse simple XML documents.

</div
 
 
4
 
vote

Desde que mencionó que estará construyendo "Fairly Simple" XML, el Minidom Module (parte de la biblioteca estándar de Python) probablemente se adapte a sus necesidades. Si tiene alguna experiencia con la representación de DOM de XML, debe encontrar la API bastante directa.

 

Since you mentioned that you'll be building "fairly simple" XML, the minidom module (part of the Python Standard Library) will likely suit your needs. If you have any experience with the DOM representation of XML, you should find the API quite straight forward.

</div
 
 
4
 
vote

Escribo un servidor SOAP que recibe solicitudes de XML y crea respuestas XML. (Desafortunadamente, no es mi proyecto, por lo que es una fuente cerrada, pero ese es otro problema).

Resultó que la creación de documentos XML de la creación es bastante simple si tiene una estructura de datos que "se ajusta" al esquema.

Mantener el sobre ya que la envoltura de respuesta es (casi) la misma que la envoltura de solicitud. Luego, dado que mi estructura de datos es un diccionario (posiblemente anidado), creo una cadena que convierte este diccionario en & lt; Key & GT; Value & lt; / Key & GT; artículos.

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

También puede (relativamente) también construir en listas fácilmente, aunque dependiendo de su cliente, puede presionar problemas a menos que dé sugerencias de longitud.

Para mí, esto fue mucho más simple, ya que un diccionario es una forma mucho más fácil de trabajar que alguna clase personalizada. ¡Para los libros, generar XML es mucho más fácil que el análisis!

 

I write a SOAP server that receives XML requests and creates XML responses. (Unfortunately, it's not my project, so it's closed source, but that's another problem).

It turned out for me that creating (SOAP) XML documents is fairly simple if you have a data structure that "fits" the schema.

I keep the envelope since the response envelope is (almost) the same as the request envelope. Then, since my data structure is a (possibly nested) dictionary, I create a string that turns this dictionary into <key>value</key> items.

This is a task that recursion makes simple, and I end up with the right structure. This is all done in python code and is currently fast enough for production use.

You can also (relatively) easily build lists as well, although depending upon your client, you may hit problems unless you give length hints.

For me, this was much simpler, since a dictionary is a much easier way of working than some custom class. For the books, generating XML is much easier than parsing!

</div
 
 
3
 
vote

Para trabajos serios con XML en Python Use LXML

Python viene con elementTree Biblioteca incorporada, pero LXML lo extiende en términos de velocidad y funcionalidad (validación de esquemas, análisis de SAX, XPATH, varios tipos de iteradores y muchas otras características).

Tienes que instalarlo, pero en muchos lugares, ya se asume que forma parte del equipo estándar (por ejemplo, Google AppEngine no permite paquetes de Python basados ​​en C, pero hace una excepción para LXML, PYYAML y pocos otros) .

Edificio de documentos XML con E-Factory (de LXML)

Su pregunta es sobre la construcción del documento XML.

Con LXML Hay muchos métodos y me tomó un tiempo encontrar el que parece ser fácil de usar y también fácil de leer.

Código de muestra de Doc de LXML en el uso de E-Factory (ligeramente simplificado ):


La 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", "       ", ...         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 la fábrica electrónica que sigue a las cosas

El código

lee casi como el documento XML resultante

Recuento de legibilidad.

Permite la creación de cualquier contenido XML

soporta cosas como:

  • uso de espacios de nombres
  • Nodos de texto de inicio y finalización dentro de un elemento
  • Funciones Formateo de contenido del atributo (consulte la clase FUNC en muestra llena de lxml )

permite construcciones muy legibles con listas

e.g.:

  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 tutorial LXML: está muy bien escrito y le brindará muchas más razones para usar esta poderosa biblioteca.

La única desventaja de LXML es, que debe ser compilada. Consulte Entonces, responda para obtener más consejos cómo instalar LXML del paquete de formato de rueda dentro de una fracción de segundo.

 

For serious work with XML in Python use lxml

Python comes with ElementTree built-in library, but lxml extends it in terms of speed and functionality (schema validation, sax parsing, XPath, various sorts of iterators and many other features).

You have to install it, but in many places, it is already assumed to be part of standard equipment (e.g. Google AppEngine does not allow C-based Python packages, but makes an exception for lxml, pyyaml, and few others).

Building XML documents with E-factory (from lxml)

Your question is about building XML document.

With lxml there are many methods and it took me a while to find the one, which seems to be easy to use and also easy to read.

Sample code from lxml doc on using E-factory (slightly simplified):


The E-factory provides a simple and compact syntax for generating XML and 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", "       ", ...         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> 

I appreciate on E-factory it following things

Code reads almost as the resulting XML document

Readability counts.

Allows creation of any XML content

Supports stuff like:

  • use of namespaces
  • starting and ending text nodes within one element
  • functions formatting attribute content (see func CLASS in full lxml sample)

Allows very readable constructs with lists

e.g.:

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) 

resulting in:

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

Conclusions

I highly recommend reading lxml tutorial - it is very well written and will give you many more reasons to use this powerful library.

The only disadvantage of lxml is, that it must be compiled. See SO answer for more tips how to install lxml from wheel format package within a fraction of a second.

</div
 
 
1
 
vote

Si va a estar construyendo mensajes de jabón, visite soaplib . Utiliza elementTree debajo del capó, pero proporciona una interfaz mucho más limpia para los mensajes de serialización y deserialización.

 

If you're going to be building SOAP messages, check out soaplib. It uses ElementTree under the hood, but it provides a much cleaner interface for serializing and deserializing messages.

</div
 
 
1
 
vote

Recomiendo encarecidamente SAX - Simple API for XML - Implementación en las bibliotecas de Python. Son bastante fáciles de configurar y procesar gráficos XML por incluso accionados API , como se explica por los carteles anteriores aquí, y tenga una huella de memoria baja, a diferencia de la validación DOM6 Estilo XML POSSERS.

 

I strongly recommend SAX - Simple API for XML - implementation in the Python libraries. They are fairly easy to setup and process large XML by even driven API, as discussed by previous posters here, and have low memory footprint unlike validating DOM style XML parsers.

</div
 
 
1
 
vote

Supongo que la forma de procesamiento de .NET XML se basa en alguna versión de MSXML y, en ese caso, asumo que usando, por ejemplo, MiniDOM lo haría sentir un poco en casa. Sin embargo, si es un procesamiento simple que está haciendo, cualquier biblioteca probablemente lo haga.

También prefiero trabajar con elementtree cuando se trata de XML en Python porque es una biblioteca muy ordenada.

 

I assume that the .NET way of processing XML builds on some version of MSXML and in that case I assume that using, for example, minidom would make you feel somewhat at home. However, if it is simple processing you are doing, any library will probably do.

I also prefer working with ElementTree when dealing with XML in Python because it is a very neat library.

</div
 
 

Relacionados problema

1  Oracle: Cómo agregar un nodo de texto a un elemento existente  ( Oracle how to add a text node into an existing element ) 
en Oracle, puedes escribir: update t set xml = updateXML(xml, '/a/b/text()', 'gaga') Esto funciona solo si ya tiene algún texto en el elemento <b> . C...

77  Procesamiento XML en Python [cerrado]  ( Xml processing in python ) 
cerrado . Esta pregunta es basada en opinión . Actualmente no está aceptando respuestas. ¿...

43  Mapas de sitio ASP.NET  ( Asp net site maps ) 
¿Alguien tiene experiencia en la creación de proveedores de mapas de sitio ASP.NET basados ​​en SQL? Tengo el archivo XML predeterminado web.sitemap Traba...

116  Java LIB o APP para convertir el archivo CSV a XML? [cerrado]  ( Java lib or app to convert csv to xml file ) 
cerrado. Esta pregunta no cumple con pautas de desbordamiento de pila . Actualmente no está aceptando respuestas. ...

1  Parámetro webmethod permanecer nulo  ( Webmethod parameter stay null ) 
Estoy desarrollando una aplicación de iPhone que envía mensajes de jabón a un servicio web .NET para llamar a varios webmethods. Estos métodos obtienen datos ...

1  Oracle: Cómo crear un elemento en un espacio de nombres específico con XMLelement ()  ( Oracle how to create an element in a specific namespace with xmlelement ) 
En Oracle, puede usar el XMlelement () Función para crear un elemento, como en: XMLElement('name', 'John') ¿Pero cómo crear un elemento en un espacio...

36  Comparando XML en una prueba de unidad en Python  ( Comparing xml in a unit test in python ) 
Tengo un objeto que puede construirse de una cadena XML y se escribe a una cadena XML. Me gustaría escribir una prueba de unidad para probar el tropezar con X...

1  poner matriz de clase personalizada en un conjunto de datos o XML (C #)  ( Put custom class array into a dataset or xml c ) 
Estoy haciendo un pequeño juego de cartas que requiere una lista de puntuación más alta que se guarda en un archivo externo, y están cargados de ella al comie...

32  ¿Alguna experiencia con buffers de protocolo?  ( Any experiences with protocol buffers ) 
Estaba mirando por alguna información sobre la buffers de protocolo Formato de intercambio de datos. ¿Alguien ha jugado con el código o incluso creó un proy...

40  Edición / Software de visualización XML [CERRADO]  ( Xml editing viewing software ) 
Según lo que actualmente representa, esta pregunta no es un buen ajuste para nuestro Q & Amp; un formato. Esperamos que las...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos