Domanda

Io sto per costruire un pezzo di un progetto che sarà necessario per costruire e pubblicare un documento XML a un servizio web e mi piacerebbe farlo in Python, come un mezzo per espandere le mie conoscenze in esso.

Purtroppo, anche se so che il modello XML abbastanza bene .NET, io sono incerto su che cosa i pro e i contro dei modelli in formato XML in Python.

Qualcuno ha esperienza di elaborazione XML in Python?Dove ti suggerisco di iniziare?Il file XML sarò edificio sarà abbastanza semplice.

È stato utile?

Soluzione

Personalmente, ho giocato con diverse del built-in opzioni di XML-heavy project e si sono insediati su pulldom come la scelta migliore per meno di documenti complessi.

In particolare per le piccole cose semplici, mi piace l'event-driven teoria di analisi, piuttosto che la creazione di tutta una serie di funzioni di callback per una struttura relativamente semplice. Qui è un buon rapida discussione di come utilizzare l'API.

Quello che mi piace:è in grado di gestire l'analisi in un for loop piuttosto che usare il callback.Si anche ritardare il pieno di analisi ("pull") e, solo per ottenere ulteriori dettagli quando si chiama expandNode().Questo soddisfa i miei requisiti generali per "responsabile" efficienza senza sacrificare la facilità d'uso e semplicità.

Altri suggerimenti

ElementTree ha un bel pythony API.Penso che sia anche fornito come parte di python 2.5

E ' in puro python e, come dicevo, molto bello, ma se si finisce bisogno di maggiori prestazioni, quindi lxml espone la stessa API e utilizza libxml2 sotto il cofano.In teoria è possibile scambiare solo in quando scopri che hai bisogno.

Ci sono 3 modi principali di trattare con XML, in generale:dom, sax, e xpath.Il modello di dom è un bene, se si può permettere di caricare il vostro intero file xml in memoria in una sola volta, e non la mente di negoziazione con le strutture di dati, e si cerca di " molto/più di un modello.Il sax modello è grande se si preoccupano solo di un paio di tag, e/o avete a che fare con file di grandi dimensioni e in grado di elaborarli in modo sequenziale.Xpath modello è un po ' di ciascuno-è possibile selezionare e scegliere i percorsi per gli elementi di dati di cui avete bisogno, ma richiede più librerie da utilizzare.

Se volete semplice e confezionato con Python, minidom è la vostra risposta, ma è abbastanza zoppo, e la documentazione è "ecco docs sul dom, vai a capire".È davvero fastidioso.

Personalmente, mi piace cElementTree, che è più veloce (c) l'attuazione di ElementTree, che è un dom-come modello.

Ho usato sax sistemi, e in molti modi sono più "divinatori" nel loro sentire, ma io di solito finiscono per creare uno stato basato su sistemi per la loro gestione, e via che si trova follia (e degli errori).

Dico andare con minidom se ti piace la ricerca, o ElementTree se si vuole un buon codice che funziona bene.

Ho usato ElementTree per diversi progetti e lo consiglio.

È divinatori, arriva 'nella casella' con Python 2.5, tra cui la versione di c cElementTree (xml.albero.cElementTree), che è 20 volte più veloce rispetto alla pura versione di Python, e è molto facile da usare.

lxml ha alcune perfomance vantaggi, ma sono irregolari e si dovrebbe verificare i parametri di riferimento primo per il vostro caso d'uso.

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

Dipende un po ' su quanto sia complicato il documento deve essere.

Ho usato minidom un sacco di scrittura XML, ma che di solito è stata proprio la lettura di documenti, facendo alcune semplici trasformazioni, e la scrittura.Che ha funzionato abbastanza bene fino a quando ho bisogno la capacità di ordinare gli attributi degli elementi (per soddisfare un antico applicazione che non parse XML correttamente).A quel punto ho rinunciato e ha scritto XML di me.

Se si sta solo lavorando su documenti semplici, quindi farlo da soli può essere più veloce e più semplice che imparare un quadro.Se si può in teoria, scrivere l'XML a mano, allora si può probabilmente il codice a mano (si ricorda correttamente l'escape dei caratteri speciali, e l'uso str.encode(codec, errors="xmlcharrefreplace")).Oltre a questi snafus, XML è sufficientemente regolare, che non bisogno una speciale raccolta di scrivere.Se il documento è troppo complicato da scrivere con la mano, quindi probabilmente si dovrebbe guardare in una delle strutture già menzionate.In nessun punto è necessario scrivere un generale XML writer.

Si può anche provare districare per analizzare i documenti XML semplici.

Dal momento che lei ha detto che per costruire "abbastanza semplice" XML modulo minidom (parte di Python Standard Library) sarà probabilmente soddisfare le vostre esigenze.Se avete qualche esperienza con il DOM rappresentazione di XML, si dovrebbe trovare le API abbastanza dritto in avanti.

Scrivo una SOAP server che riceve le richieste XML e crea XML risposte.(Purtroppo, non è un mio progetto, quindi, è closed source, ma questo è un altro problema).

Si è rivelato per me che la creazione (SOAP) documenti XML è abbastanza semplice se si dispone di una struttura di dati che "si adatta" lo schema.

Tengo la busta, dato che la risposta busta è (quasi) la stessa richiesta busta.Quindi, visto che la mia struttura dati è un (forse nidificati) dizionario, mi crea una stringa che gira in questo dizionario in <key>valore</key> elementi.

Questo è un compito che la ricorsione rende semplice, e io alla fine con la struttura.Questo è tutto fatto in codice python ed è attualmente abbastanza veloce per l'uso in produzione.

Si può anche (relativamente) facile creazione di elenchi, anche se, a seconda del vostro client, si può colpire problemi a meno che non si dia lunghezza suggerimenti.

Per me, questo è stato molto più semplice, dal momento che un dizionario è un modo molto più semplice di lavorare rispetto a una classe personalizzata.Per i libri, la generazione di XML è molto più facile che l'analisi di!

Per un lavoro serio con XML in uso Python lxml

Python viene fornito con ElementTree built-in libreria, ma lxml estende in termini di velocità e funzionalità (schema di convalida, il sax di analisi, XPath, vari tipi di iteratori e molte altre caratteristiche).

Devi installarlo, ma in molti luoghi, è già assunte da parte dell'equipaggiamento standard (ad es.Google AppEngine non permettono C a base di pacchetti di Python, ma fa un'eccezione per lxml, pyyaml, e pochi altri).

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

La tua domanda riguarda la costruzione di un documento XML.

Con lxml ci sono molti metodi e mi ci è voluto un po ' per trovare quello, che sembra essere di facile utilizzo e di facile lettura.

Il codice di esempio lxml doc sull'utilizzo di E-factory (leggermente semplificata):


E-fabbrica fornisce un semplice e compatto, la sintassi 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 E-fabbrica seguenti cose

Il codice si legge quasi come documento XML risultante

Leggibilità conta.

Permette la creazione di qualsiasi contenuto XML

Supporta roba del genere:

  • uso di spazi dei nomi
  • di inizio e di fine i nodi di testo all'interno di un elemento
  • le funzioni di formattazione del contenuto di un attributo (vedi func CLASSE completa lxml campione)

Permette molto leggibile costruisce con le liste

ad 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)

risultato:

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

Conclusioni

Consiglio vivamente la lettura lxml - tutorial è molto ben scritto e vi darà molti più motivi per utilizzare questo potente libreria.

L'unico svantaggio di lxml è, che deve essere compilato.Vedere In MODO da rispondere per ulteriori consigli come installare lxml dalla ruota formato del pacchetto all'interno di una frazione di secondo.

Se si sta andando ad essere la costruzione di messaggi SOAP, check-out soaplib.Utilizza ElementTree sotto il cofano, ma fornisce un interfaccia molto più pulita per la serializzazione e la deserializzazione di messaggi.

Mi consiglia di SAX - Simple API for XML - implementazione di Python e le librerie.Sono abbastanza facile per l'installazione e il processo di grandi dimensioni XML anche guidato API, come discusso da precedenti manifesti qui, e hanno una bassa occupazione di memoria a differenza di convalida DOM stile XML il parser.

Presumo che l' .Net-il modo di elaborazione XML si basa su alcuni versione di MSXML e in quel caso presumo che utilizzando, per esempio, minidom ti fa sentire un po ' a casa.Tuttavia, se è semplice elaborazione stai facendo una qualsiasi biblioteca sarà probabilmente fare.

Anche io preferisco lavorare con ElementTree quando ha a che fare con xml in Python, è molto pulito biblioteca.

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