Tengo muchas filas en una base de datos que contiene XML y estoy tratando de escribir un script de Python para contar instancias de un atributo de nodo particular.

Mi árbol se ve así:

<foo>
   <bar>
      <type foobar="1"/>
      <type foobar="2"/>
   </bar>
</foo>

¿Cómo puedo acceder a los atributos "1"y "2"en el XML usando Python?

Sugiero ElementTree. Hay otras implementaciones compatibles de la misma API, como lxml, y cElementTreeen la propia biblioteca estándar de Python; pero, en este contexto, lo que principalmente agregan es aún más velocidad: la facilidad de programación depende de la API, que ElementTreedefine.

Primero construya una instancia de Element a rootpartir del XML, por ejemplo, con la función XML , o analizando un archivo con algo como:

import xml.etree.ElementTree as ET
root = ET.parse('thefile.xml').getroot()

O cualquiera de las muchas otras formas que se muestran en ElementTree. Luego haz algo como:

for type_tag in root.findall('bar/type'):
    value = type_tag.get('foobar')
    print(value)

Y patrones de código similares, generalmente bastante simples.

minidom es el más rápido y bastante sencillo.

XML:

<data>
    <items>
        <item name="item1"></item>
        <item name="item2"></item>
        <item name="item3"></item>
        <item name="item4"></item>
    </items>
</data>

Pitón:

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)

Salida:

4
item1
item1
item2
item3
item4

Puedes usar BeautifulSoup :

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'

Hay muchas opciones alla afuera. cElementTree se ve excelente si la velocidad y el uso de memoria son un problema. Tiene muy poca sobrecarga en comparación con simplemente leer en el archivo usando readlines.

Las métricas relevantes se pueden encontrar en la tabla a continuación, copiadas de sitio 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 lo señaló @jfs , cElementTreeviene incluido con Python:

• Python 2: from xml.etree import cElementTree as ElementTree.
• Python 3: from xml.etree import ElementTree(la versión C acelerada se usa automáticamente).

Sugiero xmltodict por simplicidad.

Analiza tu XML a un 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')])])])

lxml.objectify es realmente simple.

Tomando su texto de muestra:

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)

Salida:

{'1': 1, '2': 1}

Python tiene una interfaz para el analizador XML de expatriados.

xml.parsers.expat

Es un analizador no validado, por lo que no se detectará un XML incorrecto. Pero si sabe que su archivo es correcto, entonces esto es bastante bueno, y probablemente obtendrá la información exacta que desea y puede descartar el resto sobre la marcha.

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

Podría sugerir declxml .

Divulgación completa: escribí esta biblioteca porque estaba buscando una forma de convertir entre estructuras de datos XML y Python sin necesidad de escribir docenas de líneas de código de análisis / serialización imperativo con ElementTree.

Con declxml, utiliza procesadores para definir declarativamente la estructura de su documento XML y cómo mapear entre las estructuras de datos XML y Python. Los procesadores se utilizan tanto para la serialización y el análisis como para un nivel básico de validación.

Analizar las estructuras de datos de Python es sencillo:

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 produce la salida:

{'bar': {'foobar': [1, 2]}}

También puede usar el mismo procesador para serializar datos a XML

data = {'bar': {
    'foobar': [7, 3, 21, 16, 11]
}}

xml.serialize_to_string(processor, data, indent='    ')

Que produce el siguiente resultado

<?xml version="1.0" ?>
<foo>
    <bar>
        <type foobar="7"/>
        <type foobar="3"/>
        <type foobar="21"/>
        <type foobar="16"/>
        <type foobar="11"/>
    </bar>
</foo>

Si desea trabajar con objetos en lugar de diccionarios, también puede definir procesadores para transformar datos hacia y desde objetos.

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 produce el siguiente resultado

{'bar': Bar(foobars=[1, 2])}

Solo para agregar otra posibilidad, puede usar desenredar , ya que es una biblioteca simple de xml a python-object. Aquí tienes un ejemplo:

Instalación:

pip install untangle

Uso:

Su archivo XML (un poco cambiado):

<foo>
   <bar name="bar_name">
      <type foobar="1"/>
   </bar>
</foo>

Accediendo a los atributos con untangle:

import untangle

obj = untangle.parse('/path_to_xml_file/file.xml')

print obj.foo.bar['name']
print obj.foo.bar.type['foobar']

El resultado será:

bar_name
1

Se puede encontrar más información sobre desenredar en " desenredar ".

Además, si tiene curiosidad, puede encontrar una lista de herramientas para trabajar con XML y Python en " Python y XML ". También verá que los más comunes fueron mencionados en respuestas anteriores.

Aquí un código muy simple pero efectivo 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")

Esto es de " python xml parse ".

XML:

<foo>
   <bar>
      <type foobar="1"/>
      <type foobar="2"/>
   </bar>
</foo>

Código de Python:

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])

Salida:

foo
1
2

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')

Esto imprimirá el valor del foobaratributo.

xml.etree.ElementTree vs. lxml

Estas son algunas de las ventajas de las dos bibliotecas más utilizadas que me beneficiaría saber antes de elegir entre ellas.

xml.etree.ElementTree:

1. Desde la biblioteca estándar : no es necesario instalar ningún módulo

lxml

1. Escriba fácilmente la declaración XML : por ejemplo, ¿necesita agregar standalone="no"?
2. Impresión bonita : puede tener un buen XML sangrado sin código adicional.
3. Funcionalidad Objectify : le permite usar XML como si estuviera tratando con una jerarquía de objetos Python normal .node.
4. sourceline permite obtener fácilmente la línea del elemento XML que está utilizando.
5. También puede utilizar un verificador de esquema XSD incorporado.

Encuentro Python xml.dom y xml.dom.minidom bastante fácil. Tenga en cuenta que DOM no es bueno para grandes cantidades de XML, pero si su entrada es bastante pequeña, entonces funcionará bien.

No es necesario usar una API específica de lib si la usa python-benedict. Simplemente inicialice una nueva instancia desde su XML y adminístrela fácilmente, ya que es una dictsubclase.

La instalación es fácil: pip install python-benedict

from benedict import benedict as bdict

# data-source can be an url, a filepath or data-string (as in this example)
data_source = """
<foo>
   <bar>
      <type foobar="1"/>
      <type foobar="2"/>
   </bar>
</foo>"""

data = bdict.from_xml(data_source)
t_list = data['foo.bar'] # yes, keypath supported
for t in t_list:
   print(t['@foobar'])

Apoya y normaliza operaciones de E / S con muchos formatos: Base64, CSV, JSON, TOML, XML, YAMLy query-string.

Está bien probado y de código abierto en GitHub .

#If the xml is in the form of a string as shown below then
from lxml  import etree, objectify
'''sample xml as a string with a name space {http://xmlns.abc.com}'''
message =b'<?xml version="1.0" encoding="UTF-8"?>\r\n<pa:Process xmlns:pa="http://xmlns.abc.com">\r\n\t<pa:firsttag>SAMPLE</pa:firsttag></pa:Process>\r\n'  # this is a sample xml which is a string


print('************message coversion and parsing starts*************')

message=message.decode('utf-8') 
message=message.replace('<?xml version="1.0" encoding="UTF-8"?>\r\n','') #replace is used to remove unwanted strings from the 'message'
message=message.replace('pa:Process>\r\n','pa:Process>')
print (message)

print ('******Parsing starts*************')
parser = etree.XMLParser(remove_blank_text=True) #the name space is removed here
root = etree.fromstring(message, parser) #parsing of xml happens here
print ('******Parsing completed************')


dict={}
for child in root: # parsed xml is iterated using a for loop and values are stored in a dictionary
    print(child.tag,child.text)
    print('****Derving from xml tree*****')
    if child.tag =="{http://xmlns.abc.com}firsttag":
        dict["FIRST_TAG"]=child.text
        print(dict)


### output
'''************message coversion and parsing starts*************
<pa:Process xmlns:pa="http://xmlns.abc.com">

    <pa:firsttag>SAMPLE</pa:firsttag></pa:Process>
******Parsing starts*************
******Parsing completed************
{http://xmlns.abc.com}firsttag SAMPLE
****Derving from xml tree*****
{'FIRST_TAG': 'SAMPLE'}'''

Si la fuente es un archivo xml, digamos como esta muestra

<pa:Process xmlns:pa="http://sssss">
        <pa:firsttag>SAMPLE</pa:firsttag>
    </pa:Process>

puedes probar el siguiente código

from lxml import etree, objectify
metadata = 'C:\\Users\\PROCS.xml' # this is sample xml file the contents are shown above
parser = etree.XMLParser(remove_blank_text=True) # this line removes the  name space from the xml in this sample the name space is --> http://sssss
tree = etree.parse(metadata, parser) # this line parses the xml file which is PROCS.xml
root = tree.getroot() # we get the root of xml which is process and iterate using a for loop
for elem in root.getiterator():
    if not hasattr(elem.tag, 'find'): continue  # (1)
    i = elem.tag.find('}')
    if i >= 0:
        elem.tag = elem.tag[i+1:]

dict={}  # a python dictionary is declared
for elem in tree.iter(): #iterating through the xml tree using a for loop
    if elem.tag =="firsttag": # if the tag name matches the name that is equated then the text in the tag is stored into the dictionary
        dict["FIRST_TAG"]=str(elem.text)
        print(dict)

La salida sería

{'FIRST_TAG': 'SAMPLE'}