XML Verwerking in Python

stemmen
61

Ik sta op het punt om een ​​stuk van een project dat zal moeten bouwen en plaatsen een XML-document naar een web service en ik zou graag om het te doen in Python, als een middel om mijn vaardigheden uit te breiden in het te bouwen.

Helaas, terwijl ik weet dat de XML-model vrij goed in .NET, ik ben niet zeker wat de voor- en nadelen zijn van het XML-modellen in Python.

Iedereen heeft ervaring doet XML verwerking in Python? Waar zou u voorstellen ik beginnen? De XML-bestanden Ik zal bouwen zal vrij eenvoudig zijn.

De vraag is gesteld op 02/08/2008 om 04:35
bron van user
In andere talen...                            


16 antwoorden

stemmen
6

Dive Into Python heeft een hoofdstuk. Kan niet instaan voor hoe goed het wel zou zijn.

antwoordde op 02/08/2008 om 04:43
bron van user

stemmen
22

Persoonlijk heb ik met een aantal van de ingebouwde opties op een XML-heavy project gespeeld en hebben zich gevestigd op pulldom als de beste keuze voor minder complexe documenten.

Vooral voor kleine eenvoudige dingen, ik de event-driven theorie ontleden plaats instelling van een hele hoop callbacks een relatief eenvoudige constructie. Hier is een goede korte discussie over hoe de API gebruiken .

Wat ik leuk vind: je kunt het interpreteren in een handvat forlus in plaats van callbacks. Je vertraging ook vol parsing (de "pull" deel) en alleen maar extra detail wanneer u belt expandNode(). Dit komt tegemoet aan mijn algemene eis voor "verantwoorde" efficiëntie zonder in te boeten gebruiksgemak en eenvoud.

antwoordde op 02/08/2008 om 05:01
bron van user

stemmen
30

Elementtree heeft een mooie pythony API. Ik denk dat het zelfs geleverd als onderdeel van de python 2,5

Het is in pure python en zoals ik al zei, erg mooi, maar als je de wind die meer prestaties, dan lxml bloot dezelfde API en maakt gebruik van libxml2 onder de motorkap. U kunt in theorie gewoon ruilen in wanneer je ontdekt u het nodig hebt.

antwoordde op 02/08/2008 om 16:21
bron van user

stemmen
3

Aangezien u zei dat u zult het opbouwen van "vrij eenvoudig" XML, de minidom module (onderdeel van de Python Standard Library) zal waarschijnlijk aan uw wensen voldoet. Heeft u ervaring met de DOM vertegenwoordiging van XML, moet u de API vrij rechttoe rechtaan vinden.

antwoordde op 02/08/2008 om 19:04
bron van user

stemmen
4

Ik schrijf een SOAP server die XML verzoeken ontvangt, en creëert XML reacties. (Helaas, het is niet mijn project, dus het is closed source, maar dat is een ander probleem).

Het bleek voor mij dat het creëren van (SOAP) XML-documenten is vrij eenvoudig, als je een datastructuur die "past" het schema.

Ik blijf de envelop, aangezien de respons envelop is (bijna) gelijk aan het verzoek envelop. Dan, omdat mijn datastructuur is een (mogelijk geneste) woordenboek, creëer ik een string die dit woordenboek in <toets> waarde </ key> items draait.

Dit is een taak die recursie maakt eenvoudig, en ik eindigen met de juiste structuur. Dit alles gebeurt in python code, en is momenteel snel genoeg voor de productie van het gebruik.

U kunt ook (relatief) gemakkelijk lijsten op te bouwen als goed, maar afhankelijk van uw klant, kunt u problemen raken, tenzij je hints lengte te geven.

Voor mij was dit veel eenvoudiger, omdat een woordenboek is een veel gemakkelijkere manier van werken dan sommige aangepaste klasse. Voor de boeken, het genereren van XML is veel gemakkelijker dan het ontleden!

antwoordde op 03/08/2008 om 09:34
bron van user

stemmen
3

Ik denk persoonlijk dat hoofdstuk uit een duik in Python is groot. Controleer of eerst - het maakt gebruik van de minidom module en is een vrij goede stukje schrijven.

antwoordde op 11/08/2008 om 19:02
bron van user

stemmen
1

Ik heb onlangs begonnen met behulp van Amara met succes.

antwoordde op 11/08/2008 om 23:40
bron van user

stemmen
5

Er zijn 3 belangrijke manieren van omgaan met XML, in het algemeen: dom, saxofoon, en xpath. De dom model is goed als je kunt veroorloven om uw gehele XML-bestand tegelijk kan laden in het geheugen, en je het niet erg te maken met datastructuren, en u op zoek bent naar veel / de meeste van het model. De sax model is geweldig als je alleen de zorg over een paar labels en / of u te maken met grote bestanden en kan ze sequentieel verwerken. De xpath model is een beetje van elk - u kunt kiezen paden naar de data-elementen die u nodig heeft, maar het vereist meer bibliotheken te gebruiken.

Als u eenvoudig en verpakt met Python wilt, minidom is uw antwoord, maar het is vrij zwak, en de documentatie "hier is docs op dom, go figure it out". Het is erg vervelend.

Persoonlijk vind ik celementtree, dat is een snellere (-c-based) uitvoering van elementtree, dat is een dom-achtig model.

Ik heb sax systemen die worden gebruikt, en in veel opzichten zijn ze meer "pythonic" in hun gevoel, maar ik meestal uiteindelijk het creëren van state-based systemen om te gaan, en op die manier ligt waanzin (en bugs).

Ik zeg gaan met minidom als je wilt onderzoek, of elementtree als je goed code die goed werkt maar wilt.

antwoordde op 16/09/2008 om 05:35
bron van user

stemmen
1

Ik neem aan dat de .Net-manier van verwerking XML bouwt voort op'som versie van MSXML en dat geval neem ik aan dat het gebruik van bijvoorbeeld minidom zou voelt u zich een beetje thuis. Echter, als het is eenvoudig verwerken je doet elke bibliotheek zal waarschijnlijk doen.

Ik ook werkt het liefst met elementtree bij het omgaan met xml in Python, het is een zeer nette bibliotheek.

antwoordde op 16/09/2008 om 07:20
bron van user

stemmen
5

Ik heb elementtree gebruikt voor verschillende projecten en het aanbevelen.

Het is pythonic, komt 'in the box' met Python 2.5, met inbegrip van de c-versie celementtree (xml.etree.cElementTree) die 20 keer sneller dan de pure Python-versie, en is zeer makkelijk te gebruiken.

lxml heeft een aantal perfomance voordelen, maar ze zijn onregelmatig en je moet de benchmarks eerst te controleren voor uw use case.

Zoals ik het begrijp, kan elementtree code eenvoudig worden overgezet naar lxml.

antwoordde op 23/09/2008 om 20:42
bron van user

stemmen
1

Als je gaat bouwen SOAP-berichten, check out soaplib . Het maakt gebruik van elementtree onder de motorkap, maar het biedt een veel schonere interface voor het serialiseren en deserialize berichten.

antwoordde op 13/10/2008 om 23:17
bron van user

stemmen
5

Het hangt een beetje aan hoe ingewikkeld het document moet zijn.

Ik heb minidom veel gebruikt voor het schrijven van XML, maar dat is meestal al gewoon het lezen van documenten, het maken van enkele eenvoudige transformaties, en schrijven ze weer naar buiten. Dat werkte goed genoeg totdat ik de mogelijkheid om element attributen bestellen (een oude toepassing die niet XML naar behoren te analyseren voldoet) nodig is. Op dat moment gaf ik op en schreef de XML-mijzelf.

Als je alleen werkt op eenvoudige documenten, dan is het zelf te doen kan sneller en eenvoudiger dan een raamwerk te leren zijn. Als u de XML denkbaar kan schrijven met de hand, dan kun je waarschijnlijk coderen met de hand ook (alleen niet vergeten om goed te ontsnappen speciale tekens, en gebruik str.encode(codec, errors="xmlcharrefreplace")). Afgezien van deze snafus, XML is regelmatig genoeg dat je niet nodig hebt een speciale bibliotheek om het te schrijven. Als het document is te ingewikkeld om te schrijven met de hand, dan moet je waarschijnlijk kijken naar een van de reeds genoemde kaders. Op geen enkel moment moet je nodig hebt om een algemene XML schrijver te schrijven.

antwoordde op 14/10/2008 om 19:26
bron van user

stemmen
4

U kunt ook proberen Untangle om eenvoudige XML-documenten te parsen.

antwoordde op 31/10/2011 om 15:05
bron van user

stemmen
1

Ik adviseer sterk SAX - Simple API voor XML - implementatie in de Python bibliotheken. Ze zijn vrij eenvoudig te installeren en verwerken van grote XML zelfs door gedreven API, zoals besproken door de vorige posters hier, en hebben weinig geheugen footprint in tegenstelling tot het valideren van DOM stijl XML parsers.

antwoordde op 12/12/2012 om 04:25
bron van user

stemmen
3

Voor ernstige werken met XML in Python gebruik lxml

Python wordt geleverd met elementtree gebouwd in de bibliotheek, maar lxml breidt het in termen van snelheid en functionaliteit (schemavalidatie, sax parsing, XPath, verschillende soorten iterators en vele andere functies).

Je moet het installeren, maar op veel plaatsen al wordt aangenomen dat het onderdeel van de standaard uitrusting (bijvoorbeeld Google AppEngine staat niet toe dat C-gebaseerde Python pakketten, maar maakt uitzondering voor lxml, pyyaml ​​en enkele anderen).

Het bouwen van XML-documenten met E-factory (uit lxml)

Uw vraag gaat over het bouwen van XML-document.

Met lxml er zijn vele methoden en het kostte me een tijdje om de een, dat lijkt gemakkelijk te gebruiken en ook gemakkelijk te lezen te vinden.

Steekproefcode van lxml doc on behulp E-fabriek (licht vereenvoudigde):


De E-fabriek zorgt voor een eenvoudige en compacte syntax voor het genereren 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: &lt;spam&amp;egg&gt;.</p>
  </body>
</html>

Ik waardeer over E-fabriek is volgende zaken

Code leest bijna als de resulterende XML-document

Leesbaarheid telt.

Hiermee oprichting van een XML-inhoud

Ondersteunt dingen zoals:

  • gebruik van namespaces
  • begint en eindigt tekstnodes binnen één element
  • functies formatteren attribuut inhoud (zie func KLASSE in volle lxml monster )

Hiermee kunnen zeer leesbaar constructies met lijsten

bijvoorbeeld:

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)

met als resultaat:

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

conclusies

Ik beveel het lezen lxml handleiding - het is zeer goed geschreven en zal u nog veel meer redenen om deze krachtige bibliotheek te gebruiken.

Het enige nadeel van lxml is, dat het moet worden gecompileerd. Zie SO verantwoorden voor meer tips hoe je lxml binnen fractie van een seconde te installeren vanaf wiel formaat pakket.

antwoordde op 17/04/2014 om 22:32
bron van user

stemmen
1

Ik denk dat je moet gebruiken lxml voor deze functionallity

antwoordde op 08/10/2014 om 06:58
bron van user

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more