Parse XML file into Python object
This code is from my teacher's Github. It converts XML string to Python object. The advantage of this approach is that it works on any XML.
Implement logic:
def xml2py(node):
"""
convert xml to python object
node: xml.etree.ElementTree object
"""
name = node.tag
pytype = type(name, (object, ), {})
pyobj = pytype()
for attr in node.attrib.keys():
setattr(pyobj, attr, node.get(attr))
if node.text and node.text != '' and node.text != ' ' and node.text != '\n':
setattr(pyobj, 'text', node.text)
for cn in node:
if not hasattr(pyobj, cn.tag):
setattr(pyobj, cn.tag, [])
getattr(pyobj, cn.tag).append(xml2py(cn))
return pyobj
Define data:
xml_str = '''<?xml version="1.0" encoding="UTF-8"?>
<menza>
<date day="Monday">
<meal name="Potato flat cakes">
<ingredient name="potatoes"/>
<ingredient name="flour"/>
<ingredient name="eggs"/>
</meal>
<meal name="Pancakes">
<ingredient name="milk"/>
<ingredient name="flour"/>
<ingredient name="eggs"/>
</meal>
</date>
</menza>'''
Load object from XML:
import xml.etree.ElementTree as ET
menza_xml_tree = ET.fromstring(xml_str)
obj = xml2py(menza_xml_tree)
Test:
for date in obj.date:
print(date.day)
for meal in date.meal:
print('\t', meal.name)
for ingredient in meal.ingredient:
print('\t\t', ingredient.name)
I have also been looking for a simple way to transform data between XML documents and Python data structures, something similar to Golang's XML library which allows you to declaratively specify how to map from data structures to XML.
I was unable to find such a library for Python, so I wrote one to meet my need called declxml for declarative XML processing.
With declxml, you create processors which declaratively define the structure of your XML document. Processors are used to perform both parsing and serialization as well as a basic level of validation.
Parsing this XML data into a list of dictionaries with declxml is straightforward
import declxml as xml
xml_string = """
<encspot>
<file>
<Name>some filename.mp3</Name>
<Encoder>Gogo (after 3.0)</Encoder>
<Bitrate>131</Bitrate>
</file>
<file>
<Name>another filename.mp3</Name>
<Encoder>iTunes</Encoder>
<Bitrate>128</Bitrate>
</file>
</encspot>
"""
processor = xml.dictionary('encspot', [
xml.array(xml.dictionary('file', [
xml.string('Name'),
xml.string('Encoder'),
xml.integer('Bitrate')
]), alias='files')
])
xml.parse_from_string(processor, xml_string)
Which produces the following result
{'files': [
{'Bitrate': 131, 'Encoder': 'Gogo (after 3.0)', 'Name': 'some filename.mp3'},
{'Bitrate': 128, 'Encoder': 'iTunes', 'Name': 'another filename.mp3'}
]}
Want to parse the data into objects instead of dictionaries? You can do that as well
import declxml as xml
class AudioFile:
def __init__(self):
self.name = None
self.encoder = None
self.bit_rate = None
def __repr__(self):
return 'AudioFile(name={}, encoder={}, bit_rate={})'.format(
self.name, self.encoder, self.bit_rate)
processor = xml.array(xml.user_object('file', AudioFile, [
xml.string('Name', alias='name'),
xml.string('Encoder', alias='encoder'),
xml.integer('Bitrate', alias='bit_rate')
]), nested='encspot')
xml.parse_from_string(processor, xml_string)
Which produces the output
[AudioFile(name=some filename.mp3, encoder=Gogo (after 3.0), bit_rate=131),
AudioFile(name=another filename.mp3, encoder=iTunes, bit_rate=128)]
Use ElementTree. You don't need/want to muck about with a parse-only gadget like pyexpat ... you'd only end up re-inventing ElementTree partially and poorly.
Another possibility is lxml which is a third-party package which implements the ElementTree interface plus more.
Update Someone started playing code-golf; here's my entry, which actually creates the data structure you asked for:
# xs = """<encspot> etc etc </encspot"""
>>> import xml.etree.cElementTree as et
>>> from pprint import pprint as pp
>>> pp([dict((attr.tag, attr.text) for attr in el) for el in et.fromstring(xs)])
[{'Bitrate': '131',
'Encoder': 'Gogo (after 3.0)',
'Frame': 'no',
'Frames': '6255',
'Freq.': '44100',
'Length': '00:02:43',
'Mode': 'joint stereo',
'Name': 'some filename.mp3',
'Quality': 'good',
'Size': '5,236,644'},
{'Bitrate': '0', 'Name': 'foo.mp3'}]
>>>
You'd probably want to have a dict mapping "attribute" names to conversion functions:
converters = {
'Frames': int,
'Size': lambda x: int(x.replace(',', '')),
# etc
}
My beloved SD Chargers hat is off to you if you think a regex is easier than this:
#!/usr/bin/env python
import xml.etree.cElementTree as et
sxml="""
<encspot>
<file>
<Name>some filename.mp3</Name>
<Encoder>Gogo (after 3.0)</Encoder>
<Bitrate>131</Bitrate>
</file>
<file>
<Name>another filename.mp3</Name>
<Encoder>iTunes</Encoder>
<Bitrate>128</Bitrate>
</file>
</encspot>
"""
tree=et.fromstring(sxml)
for el in tree.findall('file'):
print '-------------------'
for ch in el.getchildren():
print '{:>15}: {:<30}'.format(ch.tag, ch.text)
print "\nan alternate way:"
el=tree.find('file[2]/Name') # xpath
print '{:>15}: {:<30}'.format(el.tag, el.text)
Output:
-------------------
Name: some filename.mp3
Encoder: Gogo (after 3.0)
Bitrate: 131
-------------------
Name: another filename.mp3
Encoder: iTunes
Bitrate: 128
an alternate way:
Name: another filename.mp3
If your attraction to a regex is being terse, here is an equally incomprehensible bit of list comprehension to create a data structure:
[(ch.tag,ch.text) for e in tree.findall('file') for ch in e.getchildren()]
Which creates a list of tuples of the XML children of <file> in document order:
[('Name', 'some filename.mp3'),
('Encoder', 'Gogo (after 3.0)'),
('Bitrate', '131'),
('Name', 'another filename.mp3'),
('Encoder', 'iTunes'),
('Bitrate', '128')]
With a few more lines and a little more thought, obviously, you can create any data structure that you want from XML with ElementTree. It is part of the Python distribution.
Edit
Code golf is on!
[{item.tag: item.text for item in ch} for ch in tree.findall('file')]
[ {'Bitrate': '131',
'Name': 'some filename.mp3',
'Encoder': 'Gogo (after 3.0)'},
{'Bitrate': '128',
'Name': 'another filename.mp3',
'Encoder': 'iTunes'}]
If your XML only has the file section, you can choose your golf. If your XML has other tags, other sections, you need to account for the section the children are in and you will need to use findall
There is a tutorial on ElementTree at Effbot.org