XML-verwerking in Python [gesluit]
https://stackoverflow.com/questions/337
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianVra
Ek is op die punt om 'n stuk van 'n projek te bou wat 'n XML-dokument op 'n webdiens moet bou en plaas en ek wil dit graag in Python doen, as 'n manier om my vaardighede daarin uit te brei.
Ongelukkig, terwyl ek die XML-model redelik goed in .NET ken, is ek onseker wat die voor- en nadele van die XML-modelle in Python is.
Het enige iemand ervaring met XML-verwerking in Python?Waar sou jy voorstel ek begin?Die XML-lêers wat ek sal bou, sal redelik eenvoudig wees.
Oplossing
Persoonlik het ek met verskeie van die ingeboude opsies op 'n XML-swaar projek gespeel en het besluit om pulldom as die beste keuse vir minder komplekse dokumente.
Veral vir klein eenvoudige goed hou ek van die gebeurtenisgedrewe teorie van ontleding eerder as om 'n hele rits terugbelopings vir 'n relatief eenvoudige struktuur op te stel. Hier is 'n goeie vinnige bespreking van hoe om die API te gebruik.
Waarvan ek hou:jy kan die ontleding hanteer in 'n for lus eerder as om terugbelle te gebruik.Jy vertraag ook volle ontleding (die "trek" deel) en kry net bykomende detail wanneer jy bel expandNode().Dit voldoen aan my algemene vereiste vir "verantwoordelike" doeltreffendheid sonder om die gebruiksgemak en eenvoud in te boet.
Ander wenke
ElementTree het 'n lekker pythonie API.Ek dink dit word selfs as deel van python 2.5 gestuur
Dit is in pure luislang en soos ek sê, redelik mooi, maar as jy uiteindelik meer prestasie benodig, dan lxml stel dieselfde API bloot en gebruik libxml2 onder die kap.Jy kan dit teoreties net inruil wanneer jy ontdek dat jy dit nodig het.
Daar is 3 hoof maniere om XML te hanteer, in die algemeen:dom, sax en xpath.Die dom-model is goed as jy dit kan bekostig om jou hele xml-lêer gelyktydig in die geheue te laai, en jy gee nie om om met datastrukture om te gaan nie, en jy kyk na baie/die meeste van die model.Die sax-model is wonderlik as jy net omgee vir 'n paar etikette, en/of jy het met groot lêers te doen en dit opeenvolgend kan verwerk.Die xpath-model is 'n bietjie van elk -- jy kan paaie kies en kies na die data-elemente wat jy nodig het, maar dit verg meer biblioteke om te gebruik.
As jy eenvoudig en verpak wil hê met Python, is minidom jou antwoord, maar dit is redelik lam, en die dokumentasie is "hier is dokumente op dom, gaan vind dit uit".Dit is regtig irriterend.
Persoonlik hou ek van cElementTree, wat 'n vinniger (c-gebaseerde) implementering van ElementTree is, wat 'n dom-agtige model is.
Ek het al sax-stelsels gebruik, en op baie maniere is hulle meer "pytonies" in hul gevoel, maar ek skep gewoonlik staatsgebaseerde stelsels om dit te hanteer, en op dié manier lê waansin (en foute).
Ek sê gaan met minidom as jy van navorsing hou, of ElementTree as jy goeie kode wil hê wat goed werk.
Ek het ElementTree vir verskeie projekte gebruik en beveel dit aan.
Dit is luislang, kom 'in die boks' met Python 2.5, insluitend die c-weergawe cElementTree (xml.etree.cElementTree) wat 20 keer vinniger is as die suiwer Python-weergawe, en is baie maklik om te gebruik.
lxml het 'n paar prestasievoordele, maar hulle is ongelyk en jy moet eers die maatstawwe vir jou gebruiksgeval nagaan.
Soos ek dit verstaan, kan ElementTree-kode maklik na lxml oorgedra word.
Dit hang bietjie af van hoe ingewikkeld die dokument moet wees.
Ek het minidom baie gebruik om XML te skryf, maar dit was gewoonlik net om dokumente te lees, 'n paar eenvoudige transformasies te maak en dit terug te skryf.Dit het goed genoeg gewerk totdat ek die vermoë nodig gehad het om elementeienskappe te bestel (om 'n ou toepassing te bevredig wat nie XML behoorlik ontleed nie).Op daardie stadium het ek opgegee en self die XML geskryf.
As jy net aan eenvoudige dokumente werk, kan dit vinniger en makliker wees om dit self te doen as om 'n raamwerk te leer.As jy moontlik die XML met die hand kan skryf, dan kan jy dit waarskynlik ook met die hand kodeer (onthou net om spesiale karakters behoorlik te ontsnap, en gebruik str.encode(codec, errors="xmlcharrefreplace")).Afgesien van hierdie nasies, is XML gereeld genoeg dat jy dit nie doen nie behoefte 'n spesiale biblioteek om dit te skryf.As die dokument te ingewikkeld is om met die hand te skryf, moet jy waarskynlik na een van die raamwerke wat reeds genoem is, kyk.Op geen stadium hoef jy 'n algemene XML-skrywer te skryf nie.
Jy kan ook probeer ontknoop om eenvoudige XML-dokumente te ontleed.
Aangesien jy genoem het dat jy "redelik eenvoudige" XML sal bou, sal die minidom module (deel van die Python Standard Library) sal waarskynlik by u behoeftes pas.As u enige ervaring het met die DOM-voorstelling van XML, moet u die API redelik reguit vind.
Ek skryf 'n SOAP-bediener wat XML-versoeke ontvang en XML-antwoorde skep.(Ongelukkig is dit nie my projek nie, so dit is geslote bron, maar dit is 'n ander probleem).
Dit het vir my geblyk dat die skep van (SOAP) XML-dokumente redelik eenvoudig is as jy 'n datastruktuur het wat die skema "pas".
Ek hou die koevert aangesien die antwoordkoevert (amper) dieselfde is as die versoekkoevert.Dan, aangesien my datastruktuur 'n (moontlik geneste) woordeboek is, skep ek 'n string wat hierdie woordeboek in <sleutel>waarde</sleutel>-items verander.
Dit is 'n taak wat rekursie eenvoudig maak, en ek eindig met die regte struktuur.Dit word alles in python-kode gedoen en is tans vinnig genoeg vir produksiegebruik.
Jy kan ook (relatief) maklik lyste bou, maar afhangende van jou kliënt, kan jy probleme ondervind tensy jy lengtewenke gee.
Vir my was dit baie eenvoudiger, aangesien 'n woordeboek 'n baie makliker manier van werk is as 'n pasgemaakte klas.Vir die boeke is die generering van XML baie makliker as om te ontleed!
Vir ernstige werk met XML in Python gebruik lxml
Python kom met ElementTree ingeboude biblioteek, maar lxml brei dit uit in terme van spoed en funksionaliteit (skemavalidering, saxofoonontleding, XPath, verskeie soorte iterators en baie ander kenmerke).
Jy moet dit installeer, maar op baie plekke word dit reeds aanvaar dat dit deel is van standaardtoerusting (bv.Google AppEngine laat nie C-gebaseerde Python-pakkette toe nie, maar maak 'n uitsondering vir lxml, pyyaml en min ander).
Bou XML-dokumente met E-factory (vanaf lxml)
Jou vraag gaan oor die bou van XML-dokument.
Met lxml is daar baie metodes en dit het my 'n rukkie geneem om die een te vind, wat blykbaar maklik is om te gebruik en ook maklik om te lees.
Voorbeeldkode van lxml doc oor die gebruik van E-factory (effens vereenvoudig):
Die E-fabriek bied 'n eenvoudige en kompakte sintaksis vir die generering van XML en 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: <spam&egg>.</p>
</body>
</html>
Ek waardeer op E-factory dit volgende dinge
Kode lees amper soos die resulterende XML-dokument
Leesbaarheid tel.
Laat die skepping van enige XML-inhoud toe
Ondersteun goed soos:
- gebruik van naamruimtes
- begin en eindig teks nodusse binne een element
- funksies formatering kenmerk inhoud (sien funk KLAS in volledige lxml-monster)
Laat baie leesbare konstrukte met lyste toe
bv.:
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)
wat lei tot:
<root>
<record>alfa</record>
<record>beta</record>
<record>gama</record>
</root>
Gevolgtrekkings
Ek beveel sterk aan om lxml-tutoriaal te lees - dit is baie goed geskryf en sal jou baie meer redes gee om hierdie kragtige biblioteek te gebruik.
Die enigste nadeel van lxml is dat dit saamgestel moet word.Sien SO antwoord vir meer wenke hoe om lxml vanaf wielformaatpakket binne 'n breukdeel van 'n sekonde te installeer.
As jy SOAP-boodskappe gaan bou, gaan kyk seep lib.Dit gebruik ElementTree onder die enjinkap, maar dit bied 'n baie skoner koppelvlak vir die serialisering en deserialisering van boodskappe.
Ek beveel sterk aan SAX - Simple API for XML - implementering in die Python-biblioteke.Hulle is redelik maklik om op te stel en groot te verwerk XML deur selfs gedryf API, soos bespreek deur vorige plakkate hier, en het 'n lae geheue-voetspoor in teenstelling met validering DOM styl XML ontleders.
Ek neem aan dat die .Net-manier om XML te verwerk bou op een of ander weergawe van MSXML en in daardie geval neem ek aan dat die gebruik van byvoorbeeld minidom jou ietwat tuis sal laat voel.As dit egter eenvoudige verwerking is wat jy doen, sal enige biblioteek waarskynlik doen.
Ek verkies ook om met ElementTree te werk wanneer ek met xml in Python te doen het, dit is 'n baie netjiese biblioteek.
