Como analiso o XML em Python?
Tenho muitas linhas numa base de dados que contém xml e estou a tentar escrever um programa em Python que irá passar por essas linhas e conta quantas instâncias de um atributo de nó em particular aparecem. Por exemplo, a minha árvore parece:
<foo>
<bar>
<type foobar="1"/>
<type foobar="2"/>
</bar>
</foo>
Como posso aceder aos atributos 1 e 2 no XML usando Python?
13 answers
ElementTree
. Há outras compatível implementações da mesma API, tais como lxml
, e cElementTree
na biblioteca Python padrão em si; mas, neste contexto, o que principalmente adicionar é ainda mais velocidade-a facilidade de programação parte depende da API, que ElementTree
define.
Depois de construir uma instância de elementos e
a partir do XML, por exemplo, com a função XML, ou processando um ficheiro com algo como
import xml.etree.ElementTree
e = xml.etree.ElementTree.parse('thefile.xml').getroot()
Ou qualquer um dos muitas outras formas mostradas em ElementTree
, faz-se algo do género:
for atype in e.findall('type'):
print(atype.get('foobar'))
E semelhantes, geralmente muito simples, padrões de código.
minidom
é o mais rápido e bem em frente:
XML:
<data>
<items>
<item name="item1"></item>
<item name="item2"></item>
<item name="item3"></item>
<item name="item4"></item>
</items>
</data>
PYTHON:
from xml.dom import minidom
xmldoc = minidom.parse('items.xml')
itemlist = xmldoc.getElementsByTagName('item')
print(len(itemlist))
print(itemlist[0].attributes['name'].value)
for s in itemlist:
print(s.attributes['name'].value)
Saída
4
item1
item1
item2
item3
item4
Podes usar Uma bela caneta
from bs4 import BeautifulSoup
x="""<foo>
<bar>
<type foobar="1"/>
<type foobar="2"/>
</bar>
</foo>"""
y=BeautifulSoup(x)
>>> y.foo.bar.type["foobar"]
u'1'
>>> y.foo.bar.findAll("type")
[<type foobar="1"></type>, <type foobar="2"></type>]
>>> y.foo.bar.findAll("type")[0]["foobar"]
u'1'
>>> y.foo.bar.findAll("type")[1]["foobar"]
u'2'
readlines
.
As métricas relevantes podem ser encontradas na tabela abaixo, copiadas do sítio web cElementTree :
library time space
xml.dom.minidom (Python 2.1) 6.3 s 80000K
gnosis.objectify 2.0 s 22000k
xml.dom.minidom (Python 2.4) 1.4 s 53000k
ElementTree 1.2 1.6 s 14500k
ElementTree 1.2.4/1.3 1.1 s 14500k
cDomlette (C extension) 0.540 s 20500k
PyRXPU (C extension) 0.175 s 10850k
libxml2 (C extension) 0.098 s 16000k
readlines (read as utf-8) 0.093 s 8850k
cElementTree (C extension) --> 0.047 s 4900K <--
readlines (read as ascii) 0.032 s 5050k
Como indicado por @jfs, cElementTree
vem junto com Python:
- Python 2:
from xml.etree import cElementTree as ElementTree
. - Python 3:
from xml.etree import ElementTree
(a versão C acelerada é usado automaticamente).
Lxml.objectify é muito simples.
A retirar o texto da amostra:
from lxml import objectify
from collections import defaultdict
count = defaultdict(int)
root = objectify.fromstring(text)
for item in root.bar.type:
count[item.attrib.get("foobar")] += 1
print dict(count)
Resultado:
{'1': 1, '2': 1}
Ele analisa o seu xml para um OrderedDict;
>>> e = '<foo>
<bar>
<type foobar="1"/>
<type foobar="2"/>
</bar>
</foo> '
>>> import xmltodict
>>> result = xmltodict.parse(e)
>>> result
OrderedDict([(u'foo', OrderedDict([(u'bar', OrderedDict([(u'type', [OrderedDict([(u'@foobar', u'1')]), OrderedDict([(u'@foobar', u'2')])])]))]))])
>>> result['foo']
OrderedDict([(u'bar', OrderedDict([(u'type', [OrderedDict([(u'@foobar', u'1')]), OrderedDict([(u'@foobar', u'2')])])]))])
>>> result['foo']['bar']
OrderedDict([(u'type', [OrderedDict([(u'@foobar', u'1')]), OrderedDict([(u'@foobar', u'2')])])])
O Python tem uma interface para o analisador xml expat.
xml.parsers.expat
É um analisador não validante, por isso o mau xml não será apanhado. Mas se você sabe que seu arquivo está correto, então isso é muito bom, e você provavelmente vai obter a informação exata que você quer e você pode descartar o resto no momento.
stringofxml = """<foo>
<bar>
<type arg="value" />
<type arg="value" />
<type arg="value" />
</bar>
<bar>
<type arg="value" />
</bar>
</foo>"""
count = 0
def start(name, attr):
global count
if name == 'type':
count += 1
p = expat.ParserCreate()
p.StartElementHandler = start
p.Parse(stringofxml)
print count # prints 4
Aqui um código muito simples, mas eficaz, usando cElementTree
.
try:
import cElementTree as ET
except ImportError:
try:
# Python 2.5 need to import a different module
import xml.etree.cElementTree as ET
except ImportError:
exit_err("Failed to import cElementTree from any known place")
def find_in_tree(tree, node):
found = tree.find(node)
if found == None:
print "No %s in file" % node
found = []
return found
# Parse a xml file (specify the path)
def_file = "xml_file_name.xml"
try:
dom = ET.parse(open(def_file, "r"))
root = dom.getroot()
except:
exit_err("Unable to open and parse input definition file: " + def_file)
# Parse to find the child nodes list of node 'myNode'
fwdefs = find_in_tree(root,"myNode")
Fonte:
http://www.snip2code.com/Snippet/991/python-xml-parse?fromPage=1
Só para adicionar outra possibilidade, você pode usar untangle , uma vez que é uma biblioteca simples de xml-para-python-object. Aqui você tem um exemplo:
Instalação
pip install untangle
Utilização
O seu ficheiro xml (um pouco alterado):
<foo>
<bar name="bar_name">
<type foobar="1"/>
</bar>
</foo>
Aceder aos atributos com desembaraço:
import untangle
obj = untangle.parse('/path_to_xml_file/file.xml')
print obj.foo.bar['name']
print obj.foo.bar.type['foobar']
A saída será:
bar_name
1
Mais informações sobre o untangle podem ser encontradas aqui.
Também (se estiver curioso), pode encontre uma lista de ferramentas para trabalhar com XML e Python aqui (Você também verá que as mais comuns foram mencionadas pelas respostas anteriores).
Posso sugerirdeclxml .
Divulgação completa: eu escrevi esta biblioteca porque eu estava procurando uma maneira de converter entre estruturas de dados XML e Python sem precisar escrever dezenas de linhas de código de análise/serialização imperativo com ElementTree.
Com o declxml, você usa processadores para definir declarativamente a estrutura do seu documento XML e como mapear entre estruturas de dados XML e Python. Processadores são usados para ambos serialização e análise, bem como para um nível básico de validação.
Processar as estruturas de dados em Python é simples:
import declxml as xml
xml_string = """
<foo>
<bar>
<type foobar="1"/>
<type foobar="2"/>
</bar>
</foo>
"""
processor = xml.dictionary('foo', [
xml.dictionary('bar', [
xml.array(xml.integer('type', attribute='foobar'))
])
])
xml.parse_from_string(processor, xml_string)
Que produz a produção:
{'bar': {'foobar': [1, 2]}}
Você também pode usar o mesmo processador para serializar dados em XML
data = {'bar': {
'foobar': [7, 3, 21, 16, 11]
}}
xml.serialize_to_string(processor, data, indent=' ')
Que produz a seguinte Produção
<?xml version="1.0" ?>
<foo>
<bar>
<type foobar="7"/>
<type foobar="3"/>
<type foobar="21"/>
<type foobar="16"/>
<type foobar="11"/>
</bar>
</foo>
Se você quiser trabalhar com objetos em vez de dicionários, você pode definir processadores para transformar dados de e para objetos também.
import declxml as xml
class Bar:
def __init__(self):
self.foobars = []
def __repr__(self):
return 'Bar(foobars={})'.format(self.foobars)
xml_string = """
<foo>
<bar>
<type foobar="1"/>
<type foobar="2"/>
</bar>
</foo>
"""
processor = xml.dictionary('foo', [
xml.user_object('bar', Bar, [
xml.array(xml.integer('type', attribute='foobar'), alias='foobars')
])
])
xml.parse_from_string(processor, xml_string)
Que produz o após a saída
{'bar': Bar(foobars=[1, 2])}
Encontro o xml Python .dom e xml.dom.minidom muito fácil. Tenha em mente que DOM não é bom para grandes quantidades de XML, mas se sua entrada é bastante pequena, então isso vai funcionar bem.
import xml.etree.ElementTree as ET
data = '''<foo>
<bar>
<type foobar="1"/>
<type foobar="2"/>
</bar>
</foo>'''
tree = ET.fromstring(data)
lst = tree.findall('bar/type')
for item in lst:
print item.get('foobar')
Isto irá imprimir o valor do atributo foobar.
XML
<foo>
<bar>
<type foobar="1"/>
<type foobar="2"/>
</bar>
</foo>
PYTHON_CODE
import xml.etree.cElementTree as ET
tree = ET.parse("foo.xml")
root = tree.getroot()
root_tag = root.tag
print(root_tag)
for form in root.findall("./bar/type"):
x=(form.attrib)
z=list(x)
for i in z:
print(x[i])
Resultado:
foo
1
2