Python - XML

The Extensible Markup Language (XML) is a markup language much like HTML. It is a portable and. It is useful for handling small to medium amounts of data without using any SQL database.

Python's standard library contains xml package. This package has following modules that define XML processing APIs.

1. xml.etree.ElementTree: a simple and lightweight XML processor API
2. xml.dom: the DOM API definition
3. xml.sax: SAX2 base classes and convenience functions
   

ElementTree module

XML is a tree like hierarchical data format. This module has two classes for this purpose - 'ElementTree' treats the whole XML document as a tree, and 'Element' represents a single node in this tree. Reading and writing operations on XML files are done on the ElementTree level. Interactions with a single XML element and its sub-elements are done on the Element level.

To create XML file using ElementTree:

The tree is a hierarchical structure of elements starting with root followed by other elements. Each element is created by using Element() function of this module.

import xml.etree.ElementTree as xml
e=xml.Element('name')

Each element is characterized by a tag and attrib attribute which is a dict object. For tree's starting element, attrib is an empty dictionary

>>> root=xml.Element('students')
>>> root.tag
'students'
>>> root.attrib
{}

You may now set up one or more child elements to be added under root element. Each child may have one or more subelements. Add them using Subelement() function and define it's text attribute.

child=xml.Element("student")
nm = xml.SubElement(child, "name")
nm.text = student.get('name')
age = xml.SubElement(child, "age")
age.text = str(student.get('age'))

Each child is added to root by append() function as:

root.append(child)

After adding required number of child elements, construct a tree object by elementTree() function:

tree = xml.ElementTree(root)

The entire tree structure is written to a binary file by tree object's write() function:

f=open('mytest.xml', "wb")
tree.write(f)

In following example tree is constructed out of list of dictionary items. Each dictionary item holds key-value pairs describing a student data structure. The tree so constructed is written to 'myfile.xml'

import xml.etree.ElementTree as xml
students=[{'name':'aaa','age':21,'marks':50},{'name':'bbb','age':22,'marks':60}]
root = xml.Element("students")
for student in students:
       child=xml.Element("student")
       root.append(child)
       nm = xml.SubElement(child, "name")
       nm.text = student.get('name')
       age = xml.SubElement(child, "age")
       age.text = str(student.get('age'))
       mark=xml.SubElement(child, "marks")
       mark.text=str(student.get('marks'))
tree = xml.ElementTree(root)
with open('myfile.xml', "wb") as fh:
       tree.write(fh)

The 'myfile.xml' is stored in current working directory.

<students><student><name>aaa</name><age>21</age><marks>50</marks></student><student><name>bbb</name><age>22</age><marks>60</marks></student></students>

To parse XML file:

Let us now read back the 'myfile.xml' created in above example. For this purpose following functions in ElementTree module will be used:

• ElementTree(): This function is overloaded to read the hierarchical structure of elements to a tree objects.

tree = xml.ElementTree(file='myfile.xml')

• getroot(): This function returns root element of the tree

root = tree.getroot()

• getchildren(): This function returns the list of sub-elements one level below of an element.

children = root.getchildren()

In following example, elements and sub-elements of the 'myfile.xml' are parsed into a list of dictionary items.

import xml.etree.ElementTree as xml
tree = xml.ElementTree(file='myfile.xml')
root = tree.getroot()
students=[]
children = root.getchildren()
for child in children:
       student={}
       pairs = child.getchildren()
       for pair in pairs:
           student[pair.tag]=pair.text
       students.append(student)
print (students)

Output:

[{'name': 'aaa', 'age': '21', 'marks': '50'}, {'name': 'bbb', 'age': '22', 'marks': '60'}]

To modify XML file

We shall use iter() function of Element. It creates a tree iterator for given tag with the current element as the root. The iterator iterates over this element and all elements below it, in document (depth first) order.

Let us build iterator for all 'marks' subelements and increment text of each marks tag by 10.

import xml.etree.ElementTree as xml
tree = xml.ElementTree(file='myfile.xml')
root = tree.getroot()
for x in root.iter('marks'):
       mark=int (x.text)
       mark=mark+10
       x.text=str(mark)
with open("myfile.xml", "wb") as fh:
       tree.write(fh)

Our 'myfile.xml' will now be modified accordingly.

We can also use set() to update value of a certain key.

x.set(marks, str(mark))

The DOM API

The Document Object Model is a cross-language API recommended by World Wide Web Consortium (W3C) for accessing and modifying the XML documents. It is extremely useful for random-access applications. The easiest way to load an XML document xml.dom module.

Minimal implementation of the Document Object Model interface is done by xml.dom.minidom with an API that is available in other languages. It is simpler than the full DOM and also significantly smaller.

The xml.dom.pulldom module provides a “pull parser” that generates DOM-accessible fragments of the document.

The Document Object Model is a cross-language API recommended by World Wide Web Consortium (W3C) for accessing and modifying the XML documents. It is extremely useful for random-access applications. The easiest way to load an XML document is to use xml.dom module.

Minimal implementation of the Document Object Model interface is done by xml.dom.minidom with an API that is available in other languages. It is simpler than the full DOM and also significantly smaller.

The xml.dom.pulldom module provides a “pull parser” that generates DOM-accessible fragments of the document.

The minidom object provides a parser method that creates a DOM tree from the XML file.

xml.dom.minidom.parse(filename)

The getElementsByTagName() function lets access to individual elements in the DOM tree.

SAX API

SAX is a standard interface for event-driven XML parsing. You need to subclass xml.sax.ContentHandler and obtain ContentHandler. The ContentHandler handles tags and attributes of XML.Methods for handling parsing events are defined in ContentHandler class.

The ContentHandler class provides startElement() and endElement() methods which get called when an element starts and ends respectively.

make_parser() function creates a a SAX XMLReader object.

parser = xml.sax.make_parser()

Then set the contenthandler to user-defined class subclassed from SAX.ContentHandler.

Handler = MovieHandler()
parser.setContentHandler( Handler )

Now you can use above parser object to parse an XML file.

parser.parse('myfile.xml')

Following method creates a SAX parser and uses it to parse a document.

xml.sax.parse( xmlfile, contenthandler[, errorhandler])

The parseString() method to create a SAX parser and to parse the specified XML string.

xml.sax.parseString(xmlstring,contenthandler[,errorhandler])

Comparison of DOM vs SAX

SAX

1. you register callbacks for events and let the parser proceed through the document
2. useful for large documents or of there are have memory limitations
3. parses the file as it reads it from disk
4. entire file is never stored in the memory

DOM

1. entire file is read into the memory and stored in a hierarchical (tree-based) form to represent all the features of an XML document
2. SAX not as fast as DOM, with large files
3. DOM can kill resources if used on many small files

SAX is read-only, while DOM allows changes to the XML file.