Disabilita Adblock

Adblock sta bloccando alcuni contenuti sul sito

ADBlock errore

Domanda

Sto per costruire un pezzo di un progetto che dovrà costruire e pubblicare un documento XML su un servizio web e mi piacerebbe farlo in Python, come mezzo per espandere le mie capacità in esso.

Sfortunatamente, mentre conosco abbastanza bene il modello XML in .NET, non sono sicuro di quali siano i pro e i contro dei modelli XML in Python.

Qualcuno ha esperienza nell'elaborazione XML in Python? Dove mi consigli di iniziare? I file XML che costruirò saranno abbastanza semplici.

Soluzione

Personalmente, ho giocato con molte delle opzioni integrate in un progetto pesante di XML e ho optato per pulldom come la scelta migliore per documenti meno complessi.

Soprattutto per le piccole cose semplici, mi piace la teoria dell'analisi guidata dagli eventi piuttosto che impostare un'intera serie di callback per una struttura relativamente semplice. Ecco una buona breve discussione su come usare l'API .

Cosa mi piace: puoi gestire l'analisi in un ciclo for anziché usare i callback. Ritardi anche l'analisi completa (la & Quot; pull & Quot; parte) e ottieni ulteriori dettagli solo quando chiami expandNode(). Questo soddisfa il mio requisito generale per & Quot; responsabile & Quot; efficienza senza sacrificare la facilità d'uso e la semplicità.

Altri suggerimenti

ElementTree ha una bella API Pythony. Penso che sia persino distribuito come parte di Python 2.5

È in puro pitone e, come ho detto, abbastanza carino, ma se finisci per aver bisogno di più prestazioni, allora lxml espone la stessa API e usa libxml2 sotto il cofano. Teoricamente puoi semplicemente scambiarlo quando scopri di averne bisogno.

Esistono 3 modi principali di trattare con XML, in generale: dom, sax e xpath. Il modello dom è buono se puoi permetterti di caricare l'intero file xml in memoria in una volta, e non ti dispiace occuparti delle strutture di dati e stai guardando gran parte del modello. Il modello sax è ottimo se ti interessano solo alcuni tag e / o hai a che fare con file di grandi dimensioni e puoi elaborarli in sequenza. Il modello xpath è un po 'ciascuno: puoi scegliere e scegliere i percorsi per gli elementi di dati che ti servono, ma richiede più librerie da utilizzare.

Se vuoi essere semplice e impacchettato con Python, minidom è la tua risposta, ma è piuttosto zoppo, e la documentazione è " ecco i documenti su dom, vai a scoprirlo " ;. È davvero fastidioso.

Personalmente, mi piace cElementTree, che è un'implementazione più rapida (basata su c) di ElementTree, che è un modello simile a dom.

Ho usato i sistemi sax, e per molti versi sono più " pythonic " nel loro sentire, ma di solito finisco per creare sistemi basati sullo stato per gestirli, e in questo modo risiede la follia (e i bug).

Dico di andare con Minidom se ti piace la ricerca, o ElementTree se vuoi un buon codice che funzioni bene.

Ho usato ElementTree per diversi progetti e lo consiglio.

È pythonic, viene fornito 'in the box' con Python 2.5, inclusa la versione c cElementTree (xml.etree.cElementTree) che è 20 volte più veloce della versione pura di Python ed è molto facile da usare.

lxml ha alcuni vantaggi in termini di prestazioni, ma sono irregolari e dovresti prima controllare i parametri di riferimento per il tuo caso d'uso.

A quanto ho capito, il codice ElementTree può essere facilmente portato su lxml.

Dipende un po 'da quanto deve essere complicato il documento.

Ho usato molto minidom per scrivere XML, ma di solito è stato solo leggere documenti, fare alcune semplici trasformazioni e riscriverli. Ha funzionato abbastanza bene fino a quando non ho avuto bisogno della capacità di ordinare gli attributi degli elementi (per soddisfare un'applicazione antica che non analizza correttamente l'XML). A quel punto ho rinunciato e ho scritto l'XML da solo.

Se stai lavorando solo su documenti semplici, farlo da solo può essere più veloce e più semplice dell'apprendimento di un framework. Se puoi concepibilmente scrivere l'XML a mano, allora puoi probabilmente codificarlo anche a mano (ricorda solo di sfuggire correttamente ai caratteri speciali e usa str.encode(codec, errors="xmlcharrefreplace")). Oltre a questi snafus, XML è abbastanza regolare da non bisogno di una libreria speciale per scriverlo. Se il documento è troppo complicato per essere scritto a mano, probabilmente dovresti esaminare uno dei framework già menzionati. Non dovresti mai scrivere uno scrittore XML generico.

Puoi anche provare districare per analizzare semplici documenti XML.

Dato che hai detto che costruirai " abbastanza semplice " XML, il modulo minidom (parte del Python Standard Library) probabilmente soddisferà le tue esigenze. Se hai esperienza con la rappresentazione DOM di XML, dovresti trovare l'API piuttosto semplice.

Scrivo un server SOAP che riceve richieste XML e crea risposte XML. (Sfortunatamente, non è il mio progetto, quindi è chiuso, ma questo è un altro problema).

Ho scoperto che la creazione di documenti XML (SOAP) è abbastanza semplice se si dispone di una struttura dati che " si adatta a " lo schema.

Conservo la busta poiché la busta della risposta è (quasi) la stessa della busta della richiesta. Quindi, poiché la mia struttura di dati è un dizionario (possibilmente nidificato), creo una stringa che trasforma questo dizionario in & Lt; key & Gt; value & Lt; / key & Gt; elementi.

Questo è un compito che la ricorsione rende semplice e finisco con la giusta struttura. Tutto questo è fatto in codice Python ed è attualmente abbastanza veloce per l'uso in produzione.

Puoi anche (relativamente) facilmente creare elenchi, anche se a seconda del tuo cliente, potresti avere problemi a meno che tu non dia suggerimenti sulla lunghezza.

Per me, questo è stato molto più semplice, dal momento che un dizionario è un modo di lavorare molto più semplice rispetto ad alcune classi personalizzate. Per i libri, generare XML è molto più semplice dell'analisi!

Per un serio lavoro con XML in Python usa lxml

Python viene fornito con la libreria integrata ElementTree, ma lxml lo estende in termini di velocità e funzionalità (convalida dello schema, analisi del sax, XPath, vari tipi di iteratori e molte altre funzionalità).

Devi installarlo, ma in molti punti si presume che faccia già parte di un'apparecchiatura standard (ad esempio Google AppEngine non consente pacchetti Python basati su C, ma fa un'eccezione per lxml, pyyaml ​​e pochi altri) .

Creazione di documenti XML con E-factory (da lxml)

La tua domanda riguarda la costruzione di documenti XML.

Con lxml ci sono molti metodi e mi ci è voluto un po 'per trovare quello, che sembra essere facile da usare e anche facile da leggere.

Codice di esempio da documento lxml sull'uso di E-factory (leggermente semplificato ):


E-factory fornisce una sintassi semplice e compatta per la generazione di XML e 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>

Apprezzo su E-factory le cose seguenti

Il codice legge quasi come il documento XML risultante

Contabilità.

Consente la creazione di qualsiasi contenuto XML

Supporta cose come:

  • uso degli spazi dei nomi
  • inizio e fine dei nodi di testo all'interno di un elemento
  • contenuto degli attributi di formattazione delle funzioni (vedi func CLASS in full lxml sample )

Consente costrutti molto leggibili con elenchi

per esempio:.

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)

risultante in:

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

Conclusioni

Consiglio vivamente di leggere il tutorial di lxml: è scritto molto bene e ti darà molti altri motivi per usare questa potente libreria.

L'unico svantaggio di lxml è che deve essere compilato. Vedi SO risposta per ulteriori suggerimenti come installare lxml dal pacchetto formato ruota in una frazione di secondo.

Se stai per creare messaggi SOAP, controlla soaplib . Utilizza ElementTree sotto il cofano, ma fornisce un'interfaccia molto più pulita per serializzare e deserializzare i messaggi.

Consiglio vivamente SAX - Simple API for XML - implementazione nelle librerie Python. Sono abbastanza facili da configurare ed elaborare XML in modo uniforme anche guidati API, come discusso dai precedenti poster qui, e hanno un ingombro di memoria ridotto a differenza della validazione di DOM stile <=> parser.

Suppongo che il modo .Net di elaborare XML si basi su una versione di MSXML e in quel caso presumo che l'uso ad esempio di minidom ti faccia sentire un po 'a casa. Tuttavia, se si tratta di una semplice elaborazione, probabilmente lo farai qualsiasi libreria.

Preferisco anche lavorare con ElementTree quando ho a che fare con XML in Python, è una libreria molto accurata.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow