XML이 포함 된 데이터베이스에 많은 행이 있으며 특정 노드 속성의 인스턴스를 계산하기 위해 Python 스크립트를 작성하려고합니다.

내 나무는 다음과 같습니다

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

Python을 사용하여 속성 "1"및 "2"XML에 액세스하려면 어떻게 해야합니까?

나는 제안한다 ElementTree. 같은 API의 다른 호환 가능한 구현 (예 : lxml, 및 cElementTreePython 표준 라이브러리 자체)이 있습니다. 그러나 이러한 맥락에서 그들이 주로 추가하는 것은 훨씬 더 빠릅니다. 프로그래밍의 용이성은 ElementTree정의 하는 API에 달려 있습니다.

먼저 rootXML에서, 예를 들어 XML 함수를 사용하거나 다음과 같은 파일을 구문 분석 하여 Element 인스턴스 를 빌드 하십시오.

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 에서 지적했듯이 cElementTreePython과 함께 번들로 제공됩니다.

• 파이썬 2 : from xml.etree import cElementTree as ElementTree.
• Python 3 : from xml.etree import ElementTree(가속 C 버전이 자동으로 사용됨)

단순화를 위해 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')])])])

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}

파이썬에는 국외 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을 제안 할 수 있습니다 .

전체 공개 : ElementTree로 수십 줄의 명령 구문 분석 / 직렬화 코드를 작성할 필요없이 XML과 Python 데이터 구조간에 변환하는 방법을 찾고 있었기 때문에이 라이브러리를 작성했습니다.

declxml을 사용하면 프로세서 를 사용 하여 XML 문서의 구조와 XML과 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])}

다른 가능성을 추가하기 위해 간단한 xml-to-python-object 라이브러리이므로 untangle 을 사용할 수 있습니다 . 여기 예가 있습니다 :

설치:

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 and XML " 에서 XML 및 Python 작업을위한 도구 목록을 찾을 수 있습니다 . 또한 가장 일반적인 답변이 이전 답변에서 언급되었음을 알 수 있습니다.

를 사용하는 매우 간단하지만 효과적인 코드 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 " 에서 가져온 것 입니다.

XML :

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

파이썬 코드 :

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 대 lxml

이들은 내가 선택하기 전에 알아야 할 가장 많이 사용되는 두 라이브러리의 장점입니다.

xml.etree.ElementTree :

1. 로부터 표준 라이브러리 : 더는 모듈을 설치하는 필요가 없다

lxml

1. XML 선언을 쉽게 작성할 수 있습니다 . 예를 들어 추가해야 standalone="no"합니까?
2. 예쁜 인쇄 : 추가 코드없이 멋진 들여 쓰기 XML을 가질 수 있습니다 .
3. Objectify 기능 : 마치 일반 Python 객체 계층을 다루는 것처럼 XML을 사용할 수 있습니다 .node.
4. sourceline 사용중인 XML 요소를 쉽게 얻을 수 있습니다.
5. 내장 XSD 스키마 검사기를 사용할 수도 있습니다.

파이썬 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'])

그것은 지원하고 정상화 I / O 작업이 많은 포맷 : 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'}