我在包含XML的数据库中有很多行，并且我试图编写一个Python脚本来对特定节点属性的实例进行计数。

我的树看起来像：

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


如何使用Python访问XML中的"1"和"2"属性？

评论

相关：来自字符串源的Python xml ElementTree？

#1 楼

我建议ElementTree。相同API的其他兼容实现，例如Python标准库本身中的lxml和cElementTree；但是，在这种情况下，他们主要添加的是更高的速度-编程的难易程度取决于ElementTree定义的API。

首先从XML构建元素实例root，例如使用XML函数，或使用类似以下内容的文件进行解析：

然后执行以下操作：

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


以及类似的代码模式，通常非常简单。

评论

您似乎忽略了Python随附的xml.etree.cElementTree，并且在某些方面比lxml更快（“ lxml的iterparse（）稍慢于cET中的那个” –来自lxml作者的电子邮件）。

–约翰·马钦（John Machin）
09年12月16日在11:37
ElementTree可以使用，并且包含在Python中。但是，对XPath的支持有限，您无法遍历元素的父级，这会减慢开发速度（尤其是如果您不知道的话）。有关详细信息，请参见python xml查询获取父项。

–塞缪尔
2014年11月26日23:01
lxml不仅增加了速度。它提供了对诸如父节点，XML源中的行号之类的信息的轻松访问，这在某些情况下非常有用。

– Saheel Godhane
15年1月21日在22:23
似乎ElementTree存在一些漏洞问题，以下是引自docs的引文：警告xml.etree.ElementTree模块对于恶意构建的数据不安全。如果您需要解析不可信或未经身份验证的数据，请参阅XML漏洞。

– Cristik
2015年4月23日14:42


@Cristik大多数XML解析器似乎都是这种情况，请参见XML漏洞页面。

–gitaarik
2015年6月4日14:39

#2 楼

minidom是最快，最简单的方法。

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)


输出：

4
item1
item1
item2
item3
item4


评论

您如何获得“ item1”的值？例如：值1

–swmcdonnell
13年2月13日在14:03


极小的文档在哪里？我只发现了这一点，但没有做到：docs.python.org/2/library/xml.dom.minidom.html

–两栖动物
2014年1月14日20:43


我也感到困惑，为什么它直接从文档的顶层找到项目？如果您提供了路径（data-> items），它会更干净吗？因为，如果您还具有data-> secondSetOfItems并且也有名为item的节点，并且您只想列出两组项目之一，该怎么办？

–两栖动物
2014年1月14日20:49
请参阅stackoverflow.com/questions/21124018/…

–两栖动物
2014年1月14日21:05
该语法在这里不起作用，您需要在项目列表中删除s的括号：print（s.attributes ['name']。value）

– Alex Borsody
17年4月5日下午5:00


#3 楼

您可以使用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'


评论

三年后，使用bs4，这是一个很好的解决方案，非常灵活，尤其是在源格式不正确的情况下

–cedbeu
13年3月19日在9:40
@YOU BeautifulStoneSoup已弃用。只需使用BeautifulSoup（source_xml，features =“ xml”）

– andilabs
16年7月24日在11:21
再过了三年，我只是尝试使用ElementTree加载XML，不幸的是，除非我在适当的地方调整源，否则它无法解析，但是BeautifulSoup可以立即工作而没有任何更改！

– ViKiG
16年12月22日在7:16
@andi您的意思是“已弃用”。 “折旧”是指其价值下降，通常是由于使用年限或正常使用引起的磨损。

– jpmc26
17/09/28在19:17


ElementTree和minidom阻塞了有效XML数据，称存在无效XML数据，BeautifulSoup能够很好地对其进行处理。 +1

–leetNightshade
17年11月21日在0:42

#4 楼

有很多选择。如果速度和内存使用成为问题，则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版本自动使用）。


评论

使用cElementTree有不利之处吗？这似乎很容易。

–mayhewsw
2014年11月11日在21:08
显然，他们不想在OS X上使用该库，因为我花了15分钟以上的时间来弄清楚从何处下载该库，并且没有任何链接。缺少文档会阻止好的项目蓬勃发展，希望更多的人会意识到这一点。

–震惊
2014年12月23日下午6:55
@Stunner：它在stdlib中，即您不需要下载任何内容。在Python 2上：从xml.etree导入cElementTree作为ElementTree。在Python 3上：从xml.etree导入ElementTree（自动使用加速的C版本）

– jfs
15-10-26在14:16


@mayhewsw要弄清楚如何为特定任务有效使用ElementTree，需要付出更多的努力。对于适合内存的文档，使用minidom要容易得多，它对于较小的XML文档也很好用。

–触角
16-10-8在8:51

#5 楼

我建议使用xmltodict来简化操作。

它将XML解析为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')])])])


评论

同意如果不需要XPath或任何复杂的东西，则使用起来会容易得多（尤其是在解释器中）；对于发布XML而不是JSON的REST API十分方便

–丹·帕萨罗（Dan Passaro）
2014年7月25日在18:25


请记住，OrderedDict不支持重复键。大多数XML充满了相同类型的多个同级兄弟（例如，节中的所有段落，或栏中的所有类型）。因此，这仅适用于非常有限的特殊情况。

– TextGeek
18年7月17日在15:47
@TextGeek在这种情况下，result [“ foo”] [“ bar”] [“ type”]是所有元素的列表，因此它仍然有效（即使结构可能有点意外）。

– luator
18年8月30日在8:16

#6 楼

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}


评论

count使用默认键将每个项目的计数存储在字典中，因此您不必检查成员资格。您也可以尝试查看collections.Counter。

–瑞安·金斯特伦（Ryan Ginstrom）
14年7月20日在21:22

#7 楼

Python具有与expat 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


#8 楼

为了增加另一种可能性，您可以使用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


有关“不缠结”的更多信息，请参见“不缠结”。

此外，如果您好奇，还可以找到用于在“ Python和XML”中使用XML和Python。您还将看到以前的答案提到了最常见的答案。

评论

是什么使纠缠与琐事不同？

–亚伦·曼（Aaron Mann）
1月30日0:11
我无法告诉您这两者之间的区别，因为我没有从事过琐事工作。

– jchanger
1月31日8:02

#9 楼

我可能会建议使用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])}


#10 楼

这是使用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 parse”。

#11 楼

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


#12 楼

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属性的值。

#13 楼

xml.etree.ElementTree与lxml

这些是我最先了解的两个最常用的库的一些优点。在它们之间进行选择。

xml.etree.ElementTree ：


从标准库中：无需安装任何模块

lxml



轻松编写XML声明：例如，您需要添加standalone="no"吗？

漂亮的印刷：无需额外的代码，您就可以拥有漂亮的缩进XML。

对象化功能：它使您可以像处理普通的Python对象层次结构.node一样使用XML。

sourceline可以轻松获取您所需要的XML元素行正在使用。
还可以使用内置的XSD模式检查器。


#14 楼

如果使用python-benedict，则无需使用特定于lib的API。只需从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'])

它支持并规范多种格式的I / O操作：Base64，CSV，JSON，TOML，XML，YAML和query-string。
它在GitHub上经过了良好的测试和开源。披露：我是作者。

#15 楼

一个新的库，用完后我就爱上了它。我向您推荐。
from simplified_scrapy import SimplifiedDoc
xml = '''
<foo>
   <bar>
      <type foobar="1"/>
      <type foobar="2"/>
   </bar>
</foo>
'''

doc = SimplifiedDoc(xml)
types = doc.selects('bar>type')
print (len(types)) # 2
print (types.foobar) # ['1', '2']
print (doc.selects('bar>type>foobar()')) # ['1', '2']

这里有更多示例。该库易于使用。

#16 楼

#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'}'''


评论

还请提供一些上下文，解释您的答案如何解决问题。不鼓励仅使用代码的答案。

– Pedram Parsian
2月20日下午3:57

#17 楼

如果您不想使用任何外部库或第三方工具，请尝试以下代码。

这会将xml解析为python dictionary

这会将xml属性解析为好
这还将解析<tag/>之类的空标签和仅具有<tag var=val/>之类的属性的标签


代码
 import re

def getdict(content):
    res=re.findall("<(?P<var>\S*)(?P<attr>[^/>]*)(?:(?:>(?P<val>.*?)</(?P=var)>)|(?:/>))",content)
    if len(res)>=1:
        attreg="(?P<avr>\S+?)(?:(?:=(?P<quote>['\"])(?P<avl>.*?)(?P=quote))|(?:=(?P<avl1>.*?)(?:\s|$))|(?P<avl2>[\s]+)|$)"
        if len(res)>1:
            return [{i[0]:[{"@attributes":[{j[0]:(j[2] or j[3] or j[4])} for j in re.findall(attreg,i[1].strip())]},{"$values":getdict(i[2])}]} for i in res]
        else:
            return {res[0]:[{"@attributes":[{j[0]:(j[2] or j[3] or j[4])} for j in re.findall(attreg,res[1].strip())]},{"$values":getdict(res[2])}]}
    else:
        return content

with open("test.xml","r") as f:
    print(getdict(f.read().replace('\n','')))

样本输入
 <details class="4b" count=1 boy>
    <name type="firstname">John</name>
    <age>13</age>
    <hobby>Coin collection</hobby>
    <hobby>Stamp collection</hobby>
    <address>
        <country>USA</country>
        <state>CA</state>
    </address>
</details>
<details empty="True"/>
<details/>
<details class="4a" count=2 girl>
    <name type="firstname">Samantha</name>
    <age>13</age>
    <hobby>Fishing</hobby>
    <hobby>Chess</hobby>
    <address current="no">
        <country>Australia</country>
        <state>NSW</state>
    </address>
</details>

输出（已美化）
[
  {
    "details": [
      {
        "@attributes": [
          {
            "class": "4b"
          },
          {
            "count": "1"
          },
          {
            "boy": ""
          }
        ]
      },
      {
        "$values": [
          {
            "name": [
              {
                "@attributes": [
                  {
                    "type": "firstname"
                  }
                ]
              },
              {
                "$values": "John"
              }
            ]
          },
          {
            "age": [
              {
                "@attributes": []
              },
              {
                "$values": "13"
              }
            ]
          },
          {
            "hobby": [
              {
                "@attributes": []
              },
              {
                "$values": "Coin collection"
              }
            ]
          },
          {
            "hobby": [
              {
                "@attributes": []
              },
              {
                "$values": "Stamp collection"
              }
            ]
          },
          {
            "address": [
              {
                "@attributes": []
              },
              {
                "$values": [
                  {
                    "country": [
                      {
                        "@attributes": []
                      },
                      {
                        "$values": "USA"
                      }
                    ]
                  },
                  {
                    "state": [
                      {
                        "@attributes": []
                      },
                      {
                        "$values": "CA"
                      }
                    ]
                  }
                ]
              }
            ]
          }
        ]
      }
    ]
  },
  {
    "details": [
      {
        "@attributes": [
          {
            "empty": "True"
          }
        ]
      },
      {
        "$values": ""
      }
    ]
  },
  {
    "details": [
      {
        "@attributes": []
      },
      {
        "$values": ""
      }
    ]
  },
  {
    "details": [
      {
        "@attributes": [
          {
            "class": "4a"
          },
          {
            "count": "2"
          },
          {
            "girl": ""
          }
        ]
      },
      {
        "$values": [
          {
            "name": [
              {
                "@attributes": [
                  {
                    "type": "firstname"
                  }
                ]
              },
              {
                "$values": "Samantha"
              }
            ]
          },
          {
            "age": [
              {
                "@attributes": []
              },
              {
                "$values": "13"
              }
            ]
          },
          {
            "hobby": [
              {
                "@attributes": []
              },
              {
                "$values": "Fishing"
              }
            ]
          },
          {
            "hobby": [
              {
                "@attributes": []
              },
              {
                "$values": "Chess"
              }
            ]
          },
          {
            "address": [
              {
                "@attributes": [
                  {
                    "current": "no"
                  }
                ]
              },
              {
                "$values": [
                  {
                    "country": [
                      {
                        "@attributes": []
                      },
                      {
                        "$values": "Australia"
                      }
                    ]
                  },
                  {
                    "state": [
                      {
                        "@attributes": []
                      },
                      {
                        "$values": "NSW"
                      }
                    ]
                  }
                ]
              }
            ]
          }
        ]
      }
    ]
  }
]


评论

这是一个好方法，但是返回的结果不方便使用。

–爵士乐
10月23日9:34

#18 楼

如果源是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'}