xml.etree.ElementTree — XML API för ElementTree

Källkod: Lib/xml/etree/ElementTree.py


Modulen xml.etree.ElementTree implementerar ett enkelt och effektivt API för att analysera och skapa XML-data.

Ändrad i version 3.3: Denna modul kommer att använda en snabb implementering när så är möjligt.

Föråldrad sedan version 3.3: Modulen xml.etree.cElementTree är föråldrad.

Anteckning

Om du behöver analysera otillförlitliga eller oautentiserade data, se XML-säkerhet.

Handledning

Detta är en kort handledning för användning av xml.etree.ElementTree (förkortat ET). Målet är att demonstrera några av modulens byggstenar och grundläggande begrepp.

XML-träd och element

XML är till sin natur ett hierarkiskt dataformat och det mest naturliga sättet att representera det är med ett träd. ET har två klasser för detta ändamål - ElementTree representerar hela XML-dokumentet som ett träd, och Element representerar en enskild nod i detta träd. Interaktioner med hela dokumentet (läsa och skriva till/från filer) görs vanligtvis på ElementTree-nivå. Interaktioner med ett enskilt XML-element och dess underelement görs på nivån Element.

Parsning av XML

Vi kommer att använda det fiktiva XML-dokumentet country_data.xml som exempeldata för detta avsnitt:

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank>1</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank>4</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank>68</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

Vi kan importera dessa data genom att läsa från en fil:

import xml.etree.ElementTree as ET
träd = ET.parse('land_data.xml')
root = träd.getroot()

Eller direkt från en sträng:

root = ET.fromstring(land_data_som_sträng)

fromstring() parsar XML från en sträng direkt till ett Element, som är rotelementet i det parsade trädet. Andra parsingfunktioner kan skapa ett ElementTree. Kontrollera dokumentationen för att vara säker.

Som ett Element har root en tagg och en ordlista med attribut:

>>> root.tag
'data'
>>> root.attrib
{}

Den har också underordnade noder som vi kan iterera över:

>>> for child in root:
...     print(child.tag, child.attrib)
...
country {'name': 'Liechtenstein'}
country {'name': 'Singapore'}
country {'name': 'Panama'}

Barnen är nästlade och vi kan komma åt specifika barnnoder genom index:

>>> root[0][1].text
'2008'

Anteckning

Inte alla element i XML-data kommer att hamna som element i det analyserade trädet. För närvarande hoppar den här modulen över alla XML-kommentarer, bearbetningsinstruktioner och dokumenttypsdeklarationer i indata. Träd som byggs upp med hjälp av modulens API i stället för att parsa från XML-text kan dock innehålla kommentarer och bearbetningsinstruktioner; de kommer att inkluderas när XML-utdata genereras. En dokumenttypsdeklaration kan nås genom att skicka en anpassad TreeBuilder-instans till XMLParser-konstruktören.

Pull API för icke-blockerande parsing

De flesta parsingfunktioner som tillhandahålls av den här modulen kräver att hela dokumentet läses på en gång innan de returnerar något resultat. Det är möjligt att använda en XMLParser och mata in data i den stegvis, men det är ett push-API som anropar metoder på ett callback-mål, vilket är för låg nivå och obekvämt för de flesta behov. Ibland vill användaren verkligen kunna analysera XML stegvis, utan att blockera operationer, samtidigt som han eller hon kan njuta av bekvämligheten med helt konstruerade Element-objekt.

Det mest kraftfulla verktyget för att göra detta är XMLPullParser. Den kräver inte en blockerande läsning för att få XML-data, utan matas istället med data stegvis med XMLPullParser.feed()-anrop. För att hämta de analyserade XML-elementen anropas XMLPullParser.read_events(). Här är ett exempel:

>>> parser = ET.XMLPullParser(['start', 'end'])
>>> parser.feed('<mytag>sometext')
>>> list(parser.read_events())
[('start', <Element 'mytag' at 0x7fa66db2be58>)]
>>> parser.feed(' more text</mytag>')
>>> for event, elem in parser.read_events():
...     print(event)
...     print(elem.tag, 'text=', elem.text)
...
end
mytag text= sometext more text

Det uppenbara användningsfallet är applikationer som fungerar på ett icke-blockerande sätt där XML-data tas emot från ett uttag eller läses stegvis från någon lagringsenhet. I sådana fall är blockerande läsningar oacceptabla.

Eftersom den är så flexibel kan XMLPullParser vara obekväm att använda för enklare användningsfall. Om du inte har något emot att din applikation blockerar läsning av XML-data men ändå vill ha inkrementella parsingfunktioner kan du ta en titt på iterparse(). Det kan vara användbart när du läser ett stort XML-dokument och inte vill hålla det helt och hållet i minnet.

Om omedelbar återkoppling genom händelser önskas kan anrop av metoden XMLPullParser.flush() bidra till att minska fördröjningen; se till att studera de relaterade säkerhetsnoterna.

Hitta intressanta element

Element har några användbara metoder som hjälper till att iterera rekursivt över alla underträd under det (dess barn, deras barn, och så vidare). Till exempel Element.iter():

>>> for neighbor in root.iter('neighbor'):
...     print(neighbor.attrib)
...
{'name': 'Austria', 'direction': 'E'}
{'name': 'Switzerland', 'direction': 'W'}
{'name': 'Malaysia', 'direction': 'N'}
{'name': 'Costa Rica', 'direction': 'W'}
{'name': 'Colombia', 'direction': 'E'}

Element.findall() hittar bara element med en tagg som är direkta barn till det aktuella elementet. Element.find() hittar det första barnet med en viss tagg, och Element.text ger tillgång till elementets textinnehåll. Element.get() ger tillgång till elementets attribut:

>>> for country in root.findall('country'):
...     rank = country.find('rank').text
...     name = country.get('name')
...     print(name, rank)
...
Liechtenstein 1
Singapore 4
Panama 68

En mer sofistikerad specifikation av vilka element som ska sökas är möjlig genom att använda XPath.

Ändra en XML-fil

ElementTree ger ett enkelt sätt att bygga XML-dokument och skriva dem till filer. Metoden ElementTree.write() tjänar detta syfte.

När ett Element-objekt har skapats kan det manipuleras genom att direkt ändra dess fält (t.ex. Element.text), lägga till och ändra attribut (metoden Element.set()) samt lägga till nya barn (t.ex. med Element.append()).

Låt oss säga att vi vill lägga till en till varje lands rankning och lägga till ett uppdaterat attribut till rank-elementet:

>>> for rank in root.iter('rank'):
...     new_rank = int(rank.text) + 1
...     rank.text = str(new_rank)
...     rank.set('updated', 'yes')
...
>>> tree.write('output.xml')

Vår XML ser nu ut så här:

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

Vi kan ta bort element med hjälp av Element.remove(). Låt oss säga att vi vill ta bort alla länder med en rank högre än 50:

>>> for country in root.findall('country'):
...     # using root.findall() to avoid removal during traversal
...     rank = int(country.find('rank').text)
...     if rank > 50:
...         root.remove(country)
...
>>> tree.write('output.xml')

Observera att samtidig modifiering under iteration kan leda till problem, precis som när man itererar och modifierar Python-listor eller dicts. Därför samlar exemplet först in alla matchande element med root.findall() och itererar först därefter över listan med matchningar.

Vår XML ser nu ut så här:

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
</data>

Skapa XML-dokument

Funktionen SubElement() ger också ett bekvämt sätt att skapa nya underelement för ett givet element:

>>> a = ET.Element('a')
>>> b = ET.SubElement(a, 'b')
>>> c = ET.SubElement(a, 'c')
>>> d = ET.SubElement(c, 'd')
>>> ET.dump(a)
<a><b /><c><d /></c></a>

Parsning av XML med namnrymder

Om XML-inmatningen har namnrymder expanderas taggar och attribut med prefix i formen prefix:sometag till {uri}sometag där prefixet ersätts av hela URI. Om det finns ett default namespace blir dessutom den fullständiga URI:n prefixad till alla icke-prefixerade taggar.

Här är ett XML-exempel som innehåller två namnrymder, en med prefixet ”fictional” och en som fungerar som standardnamnrymd:

<?xml version="1.0"?>
<actors xmlns:fictional="http://characters.example.com"
        xmlns="http://people.example.com">
    <actor>
        <name>John Cleese</name>
        <fictional:character>Lancelot</fictional:character>
        <fictional:character>Archie Leach</fictional:character>
    </actor>
    <actor>
        <name>Eric Idle</name>
        <fictional:character>Sir Robin</fictional:character>
        <fictional:character>Gunther</fictional:character>
        <fictional:character>Kommendörkapten Clement</fictional:character>
    </actor>
</actors>

Ett sätt att söka och utforska detta XML-exempel är att manuellt lägga till URI:n till varje tagg eller attribut i xpath för en find() eller findall():

root = från sträng(xml_text)
för skådespelare i root.findall('{http://people.example.com}skådespelare'):
    namn = skådespelare.hitta('{http://people.example.com}namn')
    print(namn.text)
    for char in actor.findall('{http://characters.example.com}character'):
        print(' |-->', char.text)

Ett bättre sätt att söka i namespaced XML-exemplet är att skapa en ordbok med dina egna prefix och använda dem i sökfunktionerna:

ns = {'real_person': 'http://people.example.com',
      'roll': 'http://characters.example.com'}

for actor in root.findall('real_person:actor', ns):
    name = actor.find('verklig_person:namn', ns)
    print(namn.text)
    för char i actor.findall('roll:karaktär', ns):
        print(' |-->', char.text)

Dessa två metoder ger båda ut:

John Cleese
 |--> Lancelot
 |--> Archie Leach
Eric Idle
 |--> Sir Robin
 |--> Gunther
 |--> Commander Clement

Stöd för XPath

Den här modulen ger begränsat stöd för XPath-uttryck för att hitta element i ett träd. Målet är att stödja en liten delmängd av den förkortade syntaxen; en fullständig XPath-motor ligger utanför modulens omfattning.

Exempel

Här är ett exempel som demonstrerar några av XPath-funktionerna i modulen. Vi kommer att använda XML-dokumentet countrydata från Parsing XML avsnittet:

import xml.etree.ElementTree as ET

root = ET.fromstring(countrydata)

# Top-level elements
root.findall(".")

# All 'neighbor' grand-children of 'country' children of the top-level
# elements
root.findall("./country/neighbor")

# Nodes with name='Singapore' that have a 'year' child
root.findall(".//year/..[@name='Singapore']")

# 'year' nodes that are children of nodes with name='Singapore'
root.findall(".//*[@name='Singapore']/year")

# All 'neighbor' nodes that are the second child of their parent
root.findall(".//neighbor[2]")

För XML med namnrymder används den vanliga kvalificerade {namespace}tag-notationen:

# Alla dublin-core "title"-taggar i dokumentet
root.findall(".//{http://purl.org/dc/elements/1.1/}title")

XPath-syntax som stöds

Syntax

Betydelse

tag

Väljer alla underordnade element med den angivna taggen. Exempelvis väljer spam alla underordnade element med namnet spam, och spam/egg väljer alla barnbarn med namnet egg i alla underordnade element med namnet spam. {namespace}* väljer alla taggar i den angivna namnrymden, {*}spam väljer taggar med namnet spam i vilken (eller ingen) namnrymd som helst och {}* väljer bara taggar som inte finns i någon namnrymd.

Ändrad i version 3.8: Stöd för stjärn-wildcards har lagts till.

*

Väljer alla underordnade element, inklusive kommentarer och bearbetningsinstruktioner. Exempel: */egg väljer alla barnbarn med namnet egg.

.

Väljer den aktuella noden. Detta är mest användbart i början av sökvägen för att ange att det är en relativ sökväg.

//

Väljer alla underelement på alla nivåer under det aktuella elementet. Till exempel väljer .//egg alla egg-element i hela trädet.

..

Väljer det överordnade elementet. Returnerar None om sökvägen försöker nå förfäderna till startelementet (det element som find anropades på).

[@attrib]

Väljer alla element som har det angivna attributet.

[@attrib='värde']

Väljer alla element för vilka det angivna attributet har det angivna värdet. Värdet kan inte innehålla citattecken.

[@attrib!='värde']

Markerar alla element för vilka det angivna attributet inte har det angivna värdet. Värdet får inte innehålla citattecken.

Tillagd i version 3.10.

[tag]

Väljer alla element som har ett barn med namnet tag. Endast omedelbara barn stöds.

[.='text']

Väljer alla element vars fullständiga textinnehåll, inklusive ättlingar, är lika med den angivna texten.

Tillagd i version 3.7.

[.!='text']

Väljer alla element vars fullständiga textinnehåll, inklusive ättlingar, inte är lika med den angivna texten.

Tillagd i version 3.10.

[tag='text']

Väljer alla element som har ett barn med namnet tag vars fullständiga textinnehåll, inklusive ättlingar, är lika med den angivna texten.

[tag!='text']

Väljer alla element som har ett barn med namnet tag vars fullständiga textinnehåll, inklusive ättlingar, inte motsvarar den angivna texten.

Tillagd i version 3.10.

[position]

Väljer alla element som befinner sig på den angivna positionen. Positionen kan vara antingen ett heltal (1 är den första positionen), uttrycket last() (för den sista positionen) eller en position relativt den sista positionen (t.ex. last()-1).

Predikat (uttryck inom hakparentes) måste föregås av ett taggnamn, en asterisk eller ett annat predikat. position-predikaten måste föregås av ett taggnamn.

Referens

Funktioner

xml.etree.ElementTree.canonicalize(xml_data=None, *, out=None, from_file=None, **options)

C14N 2.0 transformationsfunktion.

Kanonisering är ett sätt att normalisera XML-utdata på ett sätt som möjliggör byte-för-byte-jämförelser och digitala signaturer. Det minskar den frihet som XML-serialisatorer har och genererar i stället en mer begränsad XML-representation. De viktigaste begränsningarna gäller placeringen av namnrymdsdeklarationer, ordningsföljden för attribut och obetydliga blanksteg.

Denna funktion tar en XML-datasträng (xml_data) eller en filsökväg eller ett filliknande objekt (from_file) som indata, konverterar den till den kanoniska formen och skriver ut den med hjälp av out fil(-liknande) objekt, om det tillhandahålls, eller returnerar den som en textsträng om så inte är fallet. Utdatafilen tar emot text, inte bytes. Den bör därför öppnas i textläge med kodningen utf-8.

Typiska användningsområden:

xml_data = ".<root>.</root>."
print(canonicalize(xml_data))

med open("c14n_output.xml", mode='w', encoding='utf-8') som out_file:
    canonicalize(xml_data, out=out_file)

med open("c14n_output.xml", mode='w', encoding='utf-8') som out_file:
    canonicalize(from_file="inputfile.xml", out=out_file)

Konfigurationsalternativen* är följande:

  • with_comments: inställd på true för att inkludera kommentarer (standard: false)

  • strip_text: satt till true för att ta bort blanksteg före och efter textinnehåll

    (standard: false)

  • rewrite_prefixes: satt till true för att ersätta namnrymdsprefix med ”n{number}”

    (standard: false)

  • qname_aware_tags: en uppsättning taggnamn som är medvetna om qname och där prefix

    ska ersättas i textinnehåll (standard: tom)

  • qname_aware_attrs: en uppsättning qname aware-attributnamn där prefix

    ska ersättas i textinnehåll (standard: tom)

  • exclude_attrs: en uppsättning attributnamn som inte ska serialiseras

  • exclude_tags: en uppsättning taggnamn som inte ska serialiseras

I alternativlistan ovan hänvisar ”en uppsättning” till en samling eller iterabel av strängar, ingen ordning förväntas.

Tillagd i version 3.8.

xml.etree.ElementTree.Comment(text=None)

Fabrik för kommentarselement. Denna fabriksfunktion skapar ett speciellt element som kommer att serialiseras som en XML-kommentar av standardserialisatorn. Kommentarssträngen kan vara antingen en bytestring eller en Unicode-sträng. text är en sträng som innehåller kommentarssträngen. Returnerar en elementinstans som representerar en kommentar.

Observera att XMLParser hoppar över kommentarer i indata istället för att skapa kommentarsobjekt för dem. Ett ElementTree kommer endast att innehålla kommentarsnoder om de har infogats i trädet med hjälp av någon av Element metoderna.

xml.etree.ElementTree.dump(elem)

Skriver ett elementträd eller en elementstruktur till sys.stdout. Denna funktion bör endast användas för felsökning.

Det exakta utdataformatet är beroende av implementeringen. I den här versionen skrivs den som en vanlig XML-fil.

elem är ett elementträd eller ett enskilt element.

Ändrad i version 3.8: Funktionen dump() bevarar nu den attributordning som anges av användaren.

xml.etree.ElementTree.fromstring(text, parser=None)

Parsar ett XML-avsnitt från en strängkonstant. Samma som XML(). text är en sträng som innehåller XML-data. parser är en valfri parser-instans. Om den inte anges används standardparsern XMLParser. Returnerar en Element-instans.

xml.etree.ElementTree.fromstringlist(sequence, parser=None)

Parsar ett XML-dokument från en sekvens av strängfragment. sequence är en lista eller annan sekvens som innehåller XML-datafragment. parser är en valfri parser-instans. Om den inte anges används standardparsern XMLParser. Returnerar en Element-instans.

Tillagd i version 3.2.

xml.etree.ElementTree.indent(tree, space='  ', level=0)

Lägger till blanksteg i underträdet för att trädet ska bli visuellt indraget. Detta kan användas för att generera vackert tryckt XML-utdata. tree kan vara ett Element eller ElementTree. space är den blankstegsträng som ska infogas för varje indragningsnivå, två blankstegstecken som standard. För indragning av partiella subträd inuti ett redan indraget träd, skicka den initiala indragningsnivån som level.

Tillagd i version 3.9.

xml.etree.ElementTree.iselement(element)

Kontrollera om ett objekt ser ut att vara ett giltigt elementobjekt. element är en elementinstans. Returnerar True om detta är ett element-objekt.

xml.etree.ElementTree.iterparse(source, events=None, parser=None)

Parsar ett XML-avsnitt till ett elementträd stegvis och rapporterar vad som händer till användaren. source är ett filnamn eller filobjekt som innehåller XML-data. events är en sekvens av händelser som ska rapporteras tillbaka. De händelser som stöds är strängarna "start", "end", "comment", "pi", "start-ns" och "end-ns" (händelserna ”ns” används för att få detaljerad information om namnrymden). Om events utelämnas rapporteras endast "end"-händelser. parser är en valfri parser-instans. Om den inte anges används standardparsern XMLParser. parser måste vara en subklass av XMLParser och kan bara använda standard TreeBuilder som mål. Returnerar en iterator som tillhandahåller (event, elem)-par; den har ett root-attribut som refererar till rotelementet i det resulterande XML-trädet när källan är helt läst. Iteratorn har metoden close() som stänger det interna filobjektet om källan är ett filnamn.

Observera att medan iterparse() bygger trädet stegvis, gör den blockerande läsningar på källan (eller filen som den namnger). Därför är den olämplig för applikationer där blockerande läsningar inte kan göras. För helt icke-blockerande parsing, se XMLPullParser.

Anteckning

iterparse() garanterar bara att den har sett tecknet ”>” i en starttagg när den avger en ”start”-händelse, så attributen är definierade, men innehållet i text- och tail-attributen är odefinierat vid den tidpunkten. Detsamma gäller för elementets barn; de kan vara närvarande eller inte.

Om du behöver ett helt fyllt element ska du leta efter ”end”-händelser i stället.

Föråldrad sedan version 3.4: Argumentet parser.

Ändrad i version 3.8: Händelserna comment och pi har lagts till.

Ändrad i version 3.13: Lagt till metoden close().

xml.etree.ElementTree.parse(source, parser=None)

Parsar ett XML-avsnitt till ett elementträd. source är ett filnamn eller ett filobjekt som innehåller XML-data. parser är en valfri parser-instans. Om den inte anges används standardparsern XMLParser. Returnerar en ElementTree-instans.

xml.etree.ElementTree.ProcessingInstruction(target, text=None)

Fabrik för PI-element. Denna fabriksfunktion skapar ett speciellt element som kommer att serialiseras som en XML-bearbetningsinstruktion. target är en sträng som innehåller PI-målet. text är en sträng som innehåller PI-innehållet, om det anges. Returnerar en elementinstans som representerar en bearbetningsinstruktion.

Observera att XMLParser hoppar över bearbetningsinstruktioner i indata istället för att skapa PI-objekt för dem. Ett ElementTree kommer endast att innehålla noder med bearbetningsinstruktioner om de har infogats i trädet med hjälp av en av Element metoderna.

xml.etree.ElementTree.register_namespace(prefix, uri)

Registrerar ett namnrymdsprefix. Registret är globalt och alla befintliga mappningar för antingen det angivna prefixet eller namnrymds-URI:n kommer att tas bort. prefix är ett namnrymdsprefix. uri är en namnrymds-uri. Taggar och attribut i denna namnrymd kommer att serialiseras med det angivna prefixet, om det är möjligt.

Tillagd i version 3.2.

xml.etree.ElementTree.SubElement(parent, tag, attrib={}, **extra)

Fabrik för underelement. Denna funktion skapar en elementinstans och lägger till den till ett befintligt element.

Elementnamn, attributnamn och attributvärden kan vara antingen bytesträngar eller Unicode-strängar. parent är det överordnade elementet. tag är namnet på underelementet. attrib är en valfri ordbok som innehåller elementattribut. extra innehåller ytterligare attribut, som anges som nyckelordsargument. Returnerar en elementinstans.

xml.etree.ElementTree.tostring(element, encoding='us-ascii', method='xml', *, xml_declaration=None, default_namespace=None, short_empty_elements=True)

Skapar en strängrepresentation av ett XML-element, inklusive alla underelement. element är en instans av Element. encoding [1] är kodningen för utdata (standard är US-ASCII). Använd encoding="unicode" för att generera en Unicode-sträng (annars genereras en bytestring). method är antingen "xml", "html" eller "text" (standard är "xml"). xml_declaration, default_namespace och short_empty_elements har samma betydelse som i ElementTree.write(). Returnerar en (valfritt) kodad sträng som innehåller XML-data.

Ändrad i version 3.4: Parametern short_empty_elements har lagts till.

Ändrad i version 3.8: Parametrarna xml_declaration och default_namespace har lagts till.

Ändrad i version 3.8: Funktionen tostring() bevarar nu den attributordning som anges av användaren.

xml.etree.ElementTree.tostringlist(element, encoding='us-ascii', method='xml', *, xml_declaration=None, default_namespace=None, short_empty_elements=True)

Skapar en strängrepresentation av ett XML-element, inklusive alla underelement. element är en instans av Element. encoding [1] är kodningen för utdata (standard är US-ASCII). Använd encoding="unicode" för att generera en Unicode-sträng (annars genereras en bytestring). method är antingen "xml", "html" eller "text" (standard är "xml"). xml_declaration, default_namespace och short_empty_elements har samma betydelse som i ElementTree.write(). Returnerar en lista med (valfritt) kodade strängar som innehåller XML-data. Den garanterar inte någon specifik sekvens, förutom att b"".join(tostringlist(element)) == tostring(element).

Tillagd i version 3.2.

Ändrad i version 3.4: Parametern short_empty_elements har lagts till.

Ändrad i version 3.8: Parametrarna xml_declaration och default_namespace har lagts till.

Ändrad i version 3.8: Funktionen tostringlist() bevarar nu den attributordning som anges av användaren.

xml.etree.ElementTree.XML(text, parser=None)

Parsar ett XML-avsnitt från en strängkonstant. Denna funktion kan användas för att bädda in ”XML-literaler” i Python-kod. text är en sträng som innehåller XML-data. parser är en valfri parser-instans. Om den inte anges används standardparsern XMLParser. Returnerar en Element-instans.

xml.etree.ElementTree.XMLID(text, parser=None)

Parsar ett XML-avsnitt från en strängkonstant och returnerar också en ordbok som mappar från element-id:n till element. text är en sträng som innehåller XML-data. parser är en valfri parser-instans. Om den inte anges används standardparsern XMLParser. Returnerar en tupel som innehåller en Element-instans och en ordbok.

XInkludera stöd

Den här modulen ger begränsat stöd för XInclude-direktiv, via hjälpmodulen xml.etree.ElementInclude. Den här modulen kan användas för att infoga delträd och textsträngar i elementträd, baserat på information i trädet.

Exempel

Här följer ett exempel som visar hur modulen XInclude används. För att inkludera ett XML-dokument i det aktuella dokumentet, använd elementet {http://www.w3.org/2001/XInclude}include och sätt attributet parse till "xml", och använd attributet href för att ange dokumentet som ska inkluderas.

<?xml version="1.0"?>
<document xmlns:xi="http://www.w3.org/2001/XInclude">
  <xi:include href="source.xml" parse="xml" />
</document>

Som standard behandlas attributet href som ett filnamn. Du kan använda anpassade laddare för att åsidosätta detta beteende. Observera också att standardhjälpen inte stöder XPointer-syntax.

För att bearbeta den här filen laddar du den som vanligt och skickar rotelementet till modulen xml.etree.ElementTree:

from xml.etree import ElementTree, ElementInclude

tree = ElementTree.parse("document.xml")
root = tree.getroot()

ElementInclude.include(root)

ElementInclude-modulen ersätter elementet {http://www.w3.org/2001/XInclude}include med rotelementet från dokumentet source.xml. Resultatet kan se ut ungefär så här:

<document xmlns:xi="http://www.w3.org/2001/XInclude">
  <para>Detta är ett stycke.</para>
</document>

Om attributet parse utelämnas är standardvärdet ”xml”. Attributet href är obligatoriskt.

Om du vill inkludera ett textdokument använder du elementet {http://www.w3.org/2001/XInclude}include och sätter attributet parse till ”text”:

<?xml version="1.0"?>
<document xmlns:xi="http://www.w3.org/2001/XInclude">
  Copyright (c) <xi:include href="year.txt" parse="text" />.
</document>

Resultatet kan se ut ungefär så här:

<document xmlns:xi="http://www.w3.org/2001/XInclude">
  Upphovsrätt (c) 2003.
</document>

Referens

Funktioner

xml.etree.ElementInclude.default_loader(href, parse, encoding=None)

Standardladdare. Denna standardladdare läser en inkluderad resurs från disken. href är en URL. parse är för parse-läge antingen ”xml” eller ”text”. encoding är en valfri textkodning. Om den inte anges är kodningen utf-8. Returnerar den expanderade resursen. Om analysläget är "xml", är detta en Element-instans. Om tolkningsläget är "text" är detta en sträng. Om laddaren misslyckas kan den returnera None eller skapa ett undantag.

xml.etree.ElementInclude.include(elem, loader=None, base_url=None, max_depth=6)

Denna funktion expanderar XInclude-direktiv på plats i trädet som pekas ut av elem. elem är antingen roten Element eller en ElementTree-instans för att hitta ett sådant element. loader är en valfri resursladdare. Om den utelämnas är standardvärdet default_loader(). Om den anges bör den vara en anropsbar som implementerar samma gränssnitt som default_loader(). base_url är originalfilens bas-URL för att lösa relativa referenser till include-filer. max_depth är det maximala antalet rekursiva inkluderingar. Begränsat för att minska risken för explosion av skadligt innehåll. Ange None för att inaktivera begränsningen.

Ändrad i version 3.9: Parametrarna base_url och max_depth har lagts till.

Element Objects

class xml.etree.ElementTree.Element(tag, attrib={}, **extra)

Klassen Element. Denna klass definierar Element-gränssnittet och tillhandahåller en referensimplementering av detta gränssnitt.

Elementnamn, attributnamn och attributvärden kan vara antingen bytesträngar eller Unicode-strängar. tag är elementets namn. attrib är en valfri ordbok som innehåller elementattribut. extra innehåller ytterligare attribut, som anges som nyckelordsargument.

tag

En sträng som identifierar vilken typ av data som elementet representerar (elementtypen, med andra ord).

text
tail

Dessa attribut kan användas för att hålla ytterligare data associerade med elementet. Deras värden är vanligtvis strängar men kan vara vilket applikationsspecifikt objekt som helst. Om elementet skapas från en XML-fil innehåller attributet text antingen texten mellan elementets starttagg och dess första barn- eller sluttagg, eller None, och attributet tail innehåller antingen texten mellan elementets sluttagg och nästa tagg, eller None. För XML-data

<a><b><c>12<d/></c></b>34</a>

elementet a har None för både attributen text och tail, elementet b har text "1" och tail "4", elementet c har text "2" och tail None, och elementet d har text None och tail "3".

För att samla in den inre texten i ett element, se itertext(), till exempel "".join(element.itertext()).

Applikationer kan lagra godtyckliga objekt i dessa attribut.

attrib

En ordbok som innehåller elementets attribut. Observera att även om attrib-värdet alltid är en verklig föränderlig Python-ordbok, kan en ElementTree-implementering välja att använda en annan intern representation och skapa ordboken endast om någon ber om det. För att dra nytta av sådana implementationer, använd dictionary-metoderna nedan när det är möjligt.

Följande ordboksliknande metoder fungerar på elementattributen.

clear()

Återställer ett element. Denna funktion tar bort alla underelement, rensar alla attribut och sätter text- och tail-attributen till None.

get(key, default=None)

Hämtar elementattributet med namnet key.

Returnerar attributvärdet, eller default om attributet inte hittades.

items()

Returnerar elementattributen som en sekvens av (namn, värde)-par. Attributen returneras i godtycklig ordning.

keys()

Returnerar elementens attributnamn som en lista. Namnen returneras i godtycklig ordning.

set(key, value)

Ställ in attributet key på elementet till value.

Följande metoder fungerar på elementets barn (underelement).

append(subelement)

Lägger till elementet subelement i slutet av detta elements interna lista över subelement. Utlöser TypeError om subelement inte är ett Element.

extend(subelements)

Lägger till subelement från en iterabel av element. Utlöser TypeError om ett subelement inte är ett Element.

Tillagd i version 3.2.

find(match, namespaces=None)

Hittar det första underelementet som matchar match. match kan vara ett taggnamn eller en sökväg. Returnerar en elementinstans eller None. namespaces är en valfri mappning från namnrymds prefix till fullständigt namn. Passera '' som prefix för att flytta alla taggnamn utan prefix i uttrycket till det angivna namnrymden.

findall(match, namespaces=None)

Hittar alla matchande underelement, genom taggnamn eller path. Returnerar en lista som innehåller alla matchande element i dokumentordning. namespaces är en valfri mappning från namnrymdsprefix till fullständigt namn. Passera '' som prefix för att flytta alla taggnamn utan prefix i uttrycket till det angivna namnrymden.

findtext(match, default=None, namespaces=None)

Hittar text för det första underelementet som matchar match. match kan vara ett taggnamn eller en sökväg. Returnerar textinnehållet i det första matchande elementet, eller default om inget element hittades. Observera att om det matchande elementet inte har något textinnehåll returneras en tom sträng. namespaces är en valfri mappning från namnrymdsprefix till fullständigt namn. Ange '' som prefix för att flytta alla taggnamn utan prefix i uttrycket till den angivna namnrymden.

insert(index, subelement)

Infogar subelement på den angivna positionen i detta element. Ger TypeError om subelement inte är ett Element.

iter(tag=None)

Skapar ett träd iterator med det aktuella elementet som rot. Iteratorn itererar över detta element och alla element under det, i dokumentordning (djupet först). Om tag inte är None eller '*' returneras endast element vars tagg är lika med tag från iteratorn. Om trädstrukturen ändras under iterationen blir resultatet odefinierat.

Tillagd i version 3.2.

iterfind(match, namespaces=None)

Hittar alla matchande underelement, med taggnamn eller path. Returnerar en iterabel som ger alla matchande element i dokumentordning. namespaces är en valfri mappning från namnrymdsprefix till fullständigt namn.

Tillagd i version 3.2.

itertext()

Skapar en text-iterator. Iteratorn loopar över detta element och alla underelement, i dokumentordning, och returnerar all inre text.

Tillagd i version 3.2.

makeelement(tag, attrib)

Skapar ett nytt elementobjekt av samma typ som detta element. Anropa inte denna metod, använd istället fabriksfunktionen SubElement().

remove(subelement)

Tar bort subelement från elementet. Till skillnad från find*-metoderna jämför den här metoden element baserat på instansidentiteten, inte på taggens värde eller innehåll.

Element-objekt stöder också följande sekvensmetoder för att arbeta med underelement: __delitem__(), __getitem__(), __setitem__(), __len__().

Varning för detta: Element utan underelement kommer att testas som False. I en framtida version av Python kommer alla element att testas som True oavsett om underelement existerar. Föredra istället explicita len(elem) eller elem is not None tester.:

element = root.find('foo')

om inte element:  # var försiktig!
    print("elementet hittades inte, eller elementet har inga underelement")

om elementet är None:
    print("elementet hittades inte")

Ändrad i version 3.12: Test av sanningsvärdet för ett element ger upphov till DeprecationWarning.

Före Python 3.8 gjordes serialiseringsordningen för XML-attributen för element artificiellt förutsägbar genom att sortera attributen efter deras namn. Baserat på den nu garanterade ordningsföljden för dicts togs denna godtyckliga omordning bort i Python 3.8 för att bevara den ordning i vilken attributen ursprungligen analyserades eller skapades av användarkoden.

I allmänhet bör användarkod försöka att inte vara beroende av en specifik ordning av attribut, med tanke på att XML Information Set uttryckligen utesluter attributordningen från att förmedla information. Koden bör vara förberedd på att hantera vilken ordning som helst i indata. I fall där deterministisk XML-utdata krävs, t.ex. för kryptografisk signering eller testdatauppsättningar, finns kanonisk serialisering tillgänglig med funktionen canonicalize().

I fall där kanonisk utdata inte är tillämplig men en specifik attributordning fortfarande är önskvärd vid utdata, bör koden sträva efter att skapa attributen direkt i önskad ordning för att undvika perceptuella missanpassningar för läsare av koden. I fall där detta är svårt att uppnå kan ett recept som följande tillämpas före serialisering för att genomdriva en ordning oberoende av elementskapandet:

def reorder_attributes(rot):
    för el i rot.iter():
        attrib = el.attrib
        if len(attrib) > 1:
            # justera attributordningen, t.ex. genom sortering
            attribs = sorterad(attrib.items())
            attrib.clear()
            attrib.update(attribs)

ElementTree-objekt

class xml.etree.ElementTree.ElementTree(element=None, file=None)

Omslagsklassen ElementTree. Den här klassen representerar en hel elementhierarki och ger lite extra stöd för serialisering till och från standard-XML.

element är rotelementet. Trädet initialiseras med innehållet i XML filen om den anges.

_setroot(element)

Ersätter rotelementet för det här trädet. Detta kastar bort det aktuella innehållet i trädet och ersätter det med det angivna elementet. Använd med försiktighet. element är en elementinstans.

find(match, namespaces=None)

Samma som Element.find(), med start vid trädets rot.

findall(match, namespaces=None)

Samma som Element.findall(), med början vid trädets rot.

findtext(match, default=None, namespaces=None)

Samma som Element.findtext(), med början vid trädets rot.

getroot()

Returnerar rotelementet för detta träd.

iter(tag=None)

Skapar och returnerar en träditerator för rotelementet. Iteratorn loopar över alla element i detta träd, i sektionsordning. tag är den tagg som ska sökas (standard är att returnera alla element).

iterfind(match, namespaces=None)

Samma som Element.iterfind(), med start vid trädets rot.

Tillagd i version 3.2.

parse(source, parser=None)

Läser in ett externt XML-avsnitt i detta elementträd. source är ett filnamn eller filobjekt. parser är en valfri parser-instans. Om den inte anges används standardparsern XMLParser. Returnerar sektionens rotelement.

write(file, encoding='us-ascii', xml_declaration=None, default_namespace=None, method='xml', *, short_empty_elements=True)

Skriver elementträdet till en fil, som XML. file är ett filnamn eller ett filobjekt som öppnats för skrivning. encoding [1] är kodningen för utdata (standard är US-ASCII). xml_declaration kontrollerar om en XML-deklaration ska läggas till i filen. Använd False för aldrig, True för alltid, None för endast om inte US-ASCII eller UTF-8 eller Unicode (standard är None). default_namespace anger standard XML-namnrymd (för ”xmlns”). method är antingen "xml", "html" eller "text" (standard är "xml"). Parametern short_empty_elements, som endast innehåller nyckelord, styr formateringen av element som inte innehåller något innehåll. Om True (standard), skickas de ut som en enda självstängande tagg, annars skickas de ut som ett par start/slut-taggar.

Utdata är antingen en sträng (str) eller binär (bytes). Detta styrs av argumentet encoding. Om encoding är "unicode" är utdata en sträng, annars är den binär. Observera att detta kan stå i konflikt med typen av fil om det är ett öppet filobjekt; se till att du inte försöker skriva en sträng till en binär ström och vice versa.

Ändrad i version 3.4: Parametern short_empty_elements har lagts till.

Ändrad i version 3.8: Metoden write() bevarar nu den attributordning som anges av användaren.

Detta är den XML-fil som ska manipuleras:

<html>
    <head>
        <title>Exempel-sida</title>
    </head>
    <body>
        <p>Flyttad till <a href="http://example.org/">example.org</a>
        eller <a href="http://example.com/">exempel.com.</a></p>
    </body>
</html>

Exempel på ändring av attributet ”target” för varje länk i första stycket:

>>> from xml.etree.ElementTree import ElementTree
>>> tree = ElementTree()
>>> tree.parse("index.xhtml")
<Element 'html' at 0xb77e6fac>
>>> p = tree.find("body/p")     # Finds first occurrence of tag p in body
>>> p
<Element 'p' at 0xb77ec26c>
>>> links = list(p.iter("a"))   # Returns list of all links
>>> links
[<Element 'a' at 0xb77ec2ac>, <Element 'a' at 0xb77ec1cc>]
>>> for i in links:             # Iterates through all found links
...     i.attrib["target"] = "blank"
...
>>> tree.write("output.xhtml")

QName-objekt

class xml.etree.ElementTree.QName(text_or_uri, tag=None)

QName-omslag. Detta kan användas för att omsluta ett QName-attributvärde för att få korrekt namnrymdshantering vid utdata. text_or_uri är en sträng som innehåller QName-värdet i formen {uri}local, eller, om argumentet tag anges, URI-delen av ett QName. Om tag anges tolkas det första argumentet som en URI, och detta argument tolkas som ett lokalt namn. QName-instanser är opaka.

TreeBuilder-objekt

class xml.etree.ElementTree.TreeBuilder(element_factory=None, *, comment_factory=None, pi_factory=None, insert_comments=False, insert_pis=False)

Generisk byggare av elementstruktur. Denna byggare konverterar en sekvens av start-, data-, slut-, kommentar- och pi-metodanrop till en välformad elementstruktur. Du kan använda den här klassen för att bygga en elementstruktur med hjälp av en anpassad XML-parser eller en parser för något annat XML-liknande format.

element_factory, när den ges, måste vara en anropsbar som accepterar två positionella argument: en tagg och ett dict av attribut. Den förväntas returnera en ny elementinstans.

Funktionerna comment_factory och pi_factory, när de anges, bör bete sig som funktionerna Comment() och ProcessingInstruction() för att skapa kommentarer och bearbetningsinstruktioner. Om den inte anges kommer standardfabrikerna att användas. När insert_comments och/eller insert_pis är true kommer kommentarer/pis att infogas i trädet om de förekommer i rotelementet (men inte utanför det).

close()

Tömmer byggarens buffertar och returnerar dokumentelementet på högsta nivån. Returnerar en instans av Element.

data(data)

Lägger till text i det aktuella elementet. data är en sträng. Detta bör vara antingen en bytestring eller en Unicode-sträng.

end(tag)

Stänger det aktuella elementet. tag är elementets namn. Returnerar det stängda elementet.

start(tag, attrs)

Öppnar ett nytt element. tag är elementets namn. attrs är en ordbok som innehåller elementattribut. Returnerar det öppnade elementet.

comment(text)

Skapar en kommentar med den angivna texten. Om insert_comments är true, kommer den också att läggas till i trädet.

Tillagd i version 3.8.

pi(target, text)

Skapar en processinstruktion med det angivna målnamnet och texten. Om insert_pis är true, kommer detta också att lägga till den i trädet.

Tillagd i version 3.8.

Dessutom kan ett anpassat TreeBuilder-objekt tillhandahålla följande metoder:

doctype(name, pubid, system)

Hanterar en doctype-deklaration. name är doctypens namn. pubid är den offentliga identifieraren. system är systemidentifieraren. Den här metoden finns inte i standardklassen TreeBuilder.

Tillagd i version 3.2.

start_ns(prefix, uri)

Anropas när parsern stöter på en ny namnrymdsdeklaration, före start() callback för det inledande element som definierar den. prefix är '' för standardnamnrymden och det deklarerade namnrymdens prefixnamn i annat fall. uri är namnrymdens URI.

Tillagd i version 3.8.

end_ns(prefix)

Anropas efter end() callback för ett element som deklarerade en mappning av namnrymdsprefix, med namnet på det prefix som gick utanför räckvidden.

Tillagd i version 3.8.

class xml.etree.ElementTree.C14NWriterTarget(write, *, with_comments=False, strip_text=False, rewrite_prefixes=False, qname_aware_tags=None, qname_aware_attrs=None, exclude_attrs=None, exclude_tags=None)

En C14N 2.0 skribent. Argumenten är desamma som för funktionen canonicalize(). Den här klassen bygger inte ett träd utan översätter återuppringningshändelserna direkt till en serialiserad form med hjälp av funktionen write.

Tillagd i version 3.8.

XMLParser-objekt

class xml.etree.ElementTree.XMLParser(*, target=None, encoding=None)

Den här klassen är modulens byggsten på låg nivå. Den använder xml.parsers.expat för effektiv, händelsebaserad parsning av XML. Den kan matas med XML-data stegvis med metoden feed(), och parsinghändelser översätts till ett push-API - genom att anropa callbacks på objektet target. Om target utelämnas används standardklassen TreeBuilder. Om encoding [1] anges, åsidosätter värdet den kodning som anges i XML-filen.

Ändrad i version 3.8: Parametrar är nu keyword-only. Argumentet html stöds inte längre.

close()

Avslutar matningen av data till parsern. Returnerar resultatet av anropet av close()-metoden för det mål som skickades under konstruktionen; som standard är detta dokumentelementet på toppnivå.

feed(data)

Matar in data till parsern. data är kodade data.

flush()

Utlöser parsning av tidigare matade oanalyserade data, vilket kan användas för att säkerställa mer omedelbar återkoppling, i synnerhet med Expat >=2.6.0. Implementeringen av flush() inaktiverar tillfälligt reparse deferral med Expat (om det för närvarande är aktiverat) och utlöser en reparse. Att inaktivera reparse deferral har säkerhetsmässiga konsekvenser; se xml.parsers.expat.xmlparser.SetReparseDeferralEnabled() för detaljer.

Observera att flush() har backporterats till vissa tidigare utgåvor av CPython som en säkerhetsfix. Kontrollera tillgängligheten av flush() med hasattr() om den används i kod som körs i flera olika Python-versioner.

Tillagd i version 3.13.

XMLParser.feed() anropar target:s metod start(tag, attrs_dict) för varje inledande tagg, dess metod end(tag) för varje avslutande tagg, och data bearbetas med metoden data(data). För fler callback-metoder som stöds, se TreeBuilder-klassen. XMLParser.close() anropar target:s metod close(). XMLParser kan inte bara användas för att bygga en trädstruktur. Detta är ett exempel på hur man räknar det maximala djupet på en XML-fil:

>>> from xml.etree.ElementTree import XMLParser
>>> class MaxDepth:                     # The target object of the parser
...     maxDepth = 0
...     depth = 0
...     def start(self, tag, attrib):   # Called for each opening tag.
...         self.depth += 1
...         if self.depth > self.maxDepth:
...             self.maxDepth = self.depth
...     def end(self, tag):             # Called for each closing tag.
...         self.depth -= 1
...     def data(self, data):
...         pass            # We do not need to do anything with data.
...     def close(self):    # Called when all data has been parsed.
...         return self.maxDepth
...
>>> target = MaxDepth()
>>> parser = XMLParser(target=target)
>>> exampleXml = """
... <a>
...   <b>
...   </b>
...   <b>
...     <c>
...       <d>
...       </d>
...     </c>
...   </b>
... </a>"""
>>> parser.feed(exampleXml)
>>> parser.close()
4

XMLPullParser-objekt

class xml.etree.ElementTree.XMLPullParser(events=None)

En pull-parser som lämpar sig för icke-blockerande applikationer. Dess API på inmatningssidan liknar det för XMLParser, men istället för att skicka anrop till ett återuppringningsmål samlar XMLPullParser in en intern lista över parsinghändelser och låter användaren läsa från den. events är en sekvens av händelser som ska rapporteras tillbaka. De händelser som stöds är strängarna "start", "end", "comment", "pi", "start-ns" och "end-ns" (händelserna ”ns” används för att få detaljerad information om namnrymden). Om events utelämnas, rapporteras endast "end"-händelser.

feed(data)

Mata in de givna bytesdata till parsern.

flush()

Utlöser parsning av tidigare matade oanalyserade data, vilket kan användas för att säkerställa mer omedelbar återkoppling, i synnerhet med Expat >=2.6.0. Implementeringen av flush() inaktiverar tillfälligt reparse deferral med Expat (om det för närvarande är aktiverat) och utlöser en reparse. Att inaktivera reparse deferral har säkerhetsmässiga konsekvenser; se xml.parsers.expat.xmlparser.SetReparseDeferralEnabled() för detaljer.

Observera att flush() har backporterats till vissa tidigare utgåvor av CPython som en säkerhetsfix. Kontrollera tillgängligheten av flush() med hasattr() om den används i kod som körs i flera olika Python-versioner.

Tillagd i version 3.13.

close()

Signalerar till parsern att dataflödet är avslutat. Till skillnad från XMLParser.close() returnerar denna metod alltid None. Eventuella händelser som ännu inte hämtats när parsern stängs kan fortfarande läsas med read_events().

read_events()

Returnerar en iterator över de händelser som har påträffats i de data som matats in i parsern. Iteratorn ger paren (event, elem), där event är en sträng som representerar händelsens typ (t.ex. "end") och elem är det påträffade Element-objektet, eller annat kontextvärde enligt följande.

  • start, end: det aktuella elementet.

  • comment, pi: den aktuella kommentaren / bearbetningsinstruktionen

  • start-ns: en tupel (prefix, uri) som namnger den deklarerade namnrymdsmappningen.

  • end-ns: None (detta kan ändras i en framtida version)

Händelser som tillhandahållits i ett tidigare anrop till read_events() kommer inte att återskapas. Händelser konsumeras från den interna kön endast när de hämtas från iteratorn, så flera läsare som parallellt itererar över iteratorer som erhållits från read_events() kommer att få oförutsägbara resultat.

Anteckning

XMLPullParser garanterar bara att den har sett tecknet ”>” i en starttagg när den sänder ut en ”start”-händelse, så attributen är definierade, men innehållet i text- och tail-attributen är odefinierat vid den tidpunkten. Detsamma gäller för elementets barn; de kan vara närvarande eller inte.

Om du behöver ett helt fyllt element ska du leta efter ”end”-händelser i stället.

Tillagd i version 3.4.

Ändrad i version 3.8: Händelserna comment och pi har lagts till.

Undantag

class xml.etree.ElementTree.ParseError

XML-parsefel, som uppstår när de olika parsningsmetoderna i denna modul misslyckas med parsningen. Strängrepresentationen av en instans av detta undantag kommer att innehålla ett användarvänligt felmeddelande. Dessutom kommer den att ha följande attribut tillgängliga:

code

En numerisk felkod från expat-parsern. Se dokumentationen för xml.parsers.expat för en lista över felkoder och deras innebörd.

position

En tupel av rad, kolumn-nummer, som anger var felet inträffade.

Fotnoter