У мене багато рядків у базі даних, що містить XML, і я намагаюся написати сценарій Python для підрахунку екземплярів певного атрибута вузла.

Моє дерево виглядає так:

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

Як я можу отримати доступ до атрибутів "1"і "2"в XML за допомогою Python?

Я пропоную ElementTree. Є й інші сумісні реалізації того ж API, як lxml, наприклад , і cElementTreeв самій стандартній бібліотеці Python; але в цьому контексті те, що вони головним чином додають, - це ще більша швидкість - простота програмування залежить від API, який ElementTreeвизначає.

Спочатку побудуйте екземпляр Element rootз XML, наприклад, за допомогою функції XML або розібравши файл із чимось на зразок:

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

Або будь-який із багатьох інших способів, показаних на ElementTree. Тоді зробіть щось на кшталт:

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

І подібні, як правило, досить прості схеми коду.

minidom є найшвидшим і досить прямо вперед.

XML:

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

Пітон:

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)

Вихід:

4
item1
item1
item2
item3
item4

Ви можете використовувати 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'

Є багато варіантів там. cElementTree виглядає чудово, якщо проблема з швидкістю та використанням пам'яті. Він має дуже невеликі накладні витрати порівняно з простою читанням у файлі з використанням readlines.

Відповідні показники можна знайти в таблиці нижче, скопійованій з веб-сайту 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   

Як вказував @jfs , він cElementTreeпостачається в комплекті з Python:

• Python 2: from xml.etree import cElementTree as ElementTree.
• Python 3: from xml.etree import ElementTree(прискорена версія C використовується автоматично).

Я пропоную xmltodict для простоти.

Він аналізує ваш XML на OrdersDict;

>>> 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 - це дуже просто.

Беручи зразок тексту:

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)

Вихід:

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

У Python є інтерфейс до аналізатора експатів XML.

xml.parsers.expat

Це не валідизуючий аналізатор, тому поганий XML не буде спійманий. Але якщо ви знаєте, що ваш файл правильний, то це дуже добре, і ви, ймовірно, отримаєте точну інформацію, яку ви хочете, а решту ви зможете відкинути.

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

Я можу запропонувати declxml .

Повне розкриття: я написав цю бібліотеку, тому що шукав спосіб конвертувати між XML і Python структурами даних без необхідності запису десятків рядків обов'язкового розбору / коду серіалізації за допомогою ElementTree.

За допомогою declxml ви використовуєте процесори, щоб декларативно визначити структуру вашого XML-документа та спосіб відображення між структурами даних XML та Python. Процесори використовуються як для серіалізації та розбору, так і для базового рівня перевірки.

Розбір структур даних Python простий:

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)

Що дає результат:

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

Ви також можете використовувати той самий процесор для серіалізації даних у XML

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

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

Що дає наступний вихід

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

Якщо ви хочете працювати з об'єктами замість словників, ви можете визначити процесори для перетворення даних і в об'єкти.

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)

Що дає наступний вихід

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

Просто для додання іншої можливості ви можете використовувати untangle , оскільки це проста бібліотека xml-to-python-object. Ось у вас є приклад:

Установка:

pip install untangle

Використання:

Ваш XML-файл (трохи змінений):

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

Доступ до атрибутів за допомогою untangle:

import untangle

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

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

Вихід буде:

bar_name
1

Більш детальну інформацію про розкручування можна знайти в розділі " untangle ".

Також, якщо вам цікаво, ви можете знайти список інструментів для роботи з XML та Python у розділі " Python та XML ". Ви також побачите, що найпоширеніші з них були згадані попередніми відповідями.

Тут дуже простий, але ефективний код 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")

Це з " розбору python xml ".

XML:

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

Код 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])

Вихід:

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

Це надрукує значення foobarатрибута.

xml.etree.ElementTree vs. lxml

Ось деякі плюси двох найпоширеніших бібліотек, про які я хотів би знати, перш ніж обирати між ними.

xml.etree.ElementTree:

1. Зі стандартної бібліотеки : не потрібно встановлювати жоден модуль

lxml

1. Легко написати XML-декларацію : наприклад, вам потрібно додати standalone="no"?
2. Гарненьке друкування : ви можете мати приємний відступ XML без додаткового коду.
3. Об'єктивуйте функціональність: Це дозволяє використовувати XML так, як якщо б ви мали справу зі звичайною ієрархією об’єктів Python .node.
4. sourceline дозволяє легко отримати рядок використовуваного XML-елемента.
5. Ви також можете використовувати вбудовану перевірку схеми XSD.

Я вважаю Python xml.dom та xml.dom.minidom досить простим. Майте на увазі, що DOM не підходить для великої кількості XML, але якщо ваш вклад досить малий, то це буде добре.

Там немає ніякої необхідності використовувати Lib конкретного API , якщо ви використовуєте python-benedict. Просто ініціалізуйте новий екземпляр зі свого XML та керуйте ним легко, оскільки це dictпідклас.

Установка проста: 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'])

Він підтримує і нормалізує операції введення / виводу з багатьма форматами: Base64, CSV, JSON, TOML, XML, YAMLі query-string.

Він добре перевірений та відкритий на 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'}'''

Якщо джерелом є XML-файл, скажіть, як цей зразок

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

ви можете спробувати наступний код

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)

Вихід буде

{'FIRST_TAG': 'SAMPLE'}