精华内容
下载资源
问答
  • xml.etree.ElementTree

    2019-09-27 09:22:01
    Python 标准库之 xml.etree.ElementTree 简介 Element类型是一种灵活的容器对象,用于在内存中存储结构化数据。 [注意]xml.etree.ElementTree模块在应对恶意结构数据时显得并不安全。 每个element对象都具有...

     

    Python 标准库之 xml.etree.ElementTree

    简介

     

    Element类型是一种灵活的容器对象,用于在内存中存储结构化数据。

    [注意]xml.etree.ElementTree模块在应对恶意结构数据时显得并不安全。

    每个element对象都具有以下属性:

      1. tag:string对象,表示数据代表的种类。

      2. attrib:dictionary对象,表示附有的属性。

      3. text:string对象,表示element的内容。

      4. tail:string对象,表示element闭合之后的尾迹。

      5. 若干子元素(child elements)。

    <tag attrib1=1>text</tag>tail
      1     2        3         4

    创建元素的方法有Element或者SubElement(),前者称作元素的构建函数(constructor),用以构建任一独存的元素;后者称作元素的制造函数(factory function),用以制造某一元素的子元素。

    有了一串元素之后,使用ElementTree类来将其打包,把一串元素转换为xml文件或者从xml文件中解析出来。

    若想加快速度,可以使用C语言编译的API xml.etree.cElementTree。

     

     导入ElementTree

     

    在使用xml.etree.ElementTree时,一般都按如下导入:

    try:
        import xml.etree.cElementTree as ET
    except ImportError:
        import xml.etree.ElementTree as ET

    XML是中结构化数据形式,在ET中使用ElementTree代表整个XML文档,并视其为一棵树,Element代表这个文档树中的单个节点。

    ET对象具有多种方法从不同来源导入数据,如下:

    复制代码

    #从硬盘的xml文件读取数据
    
    import xml.etree.ElementTree as ET
    tree = ET.parse('country_data.xml')    #载入数据
    root = tree.getroot()    #获取根节点
    
    #从字符串读取数据
    root = ET.fromstring(country_data_as_string)

    复制代码

    [注意]fromstring()是直接获取string对象中的根节点,因此以上root其实是一个Element。

    作为一个Element对象,本身是具有子元素,因此可以直接对Element进行迭代取值:

    复制代码

    >>> for child in root:
    ...   print child.tag, child.attrib
    ...
    country {'name': 'Liechtenstein'}
    country {'name': 'Singapore'}
    country {'name': 'Panama'}
    
    或者直接使用索引寻找子节点:
    >>> root[0][1].text
    '2008'

    复制代码

     

     Element中的遍历与查询

     

    Element.iter(tag=None):遍历该Element所有后代,也可以指定tag进行遍历寻找。

    Element.findall(path):查找当前元素下tag或path能够匹配的直系节点。

    Element.find(path):查找当前元素下tag或path能够匹配的首个直系节点。

    Element.text: 获取当前元素的text值。

    Element.get(key, default=None):获取元素指定key对应的属性值,如果没有该属性,则返回default值。

     

     Element对象 

     

    复制代码

    class xml.etree.ElementTree.Element(tag, attrib={}, **extra)
    
      tag:string,元素代表的数据种类。
      text:string,元素的内容。
      tail:string,元素的尾形。
      attrib:dictionary,元素的属性字典。
      
      #针对属性的操作
      clear():清空元素的后代、属性、text和tail也设置为None。
      get(key, default=None):获取key对应的属性值,如该属性不存在则返回default值。
      items():根据属性字典返回一个列表,列表元素为(key, value)。
      keys():返回包含所有元素属性键的列表。
      set(key, value):设置新的属性键与值。
    
      #针对后代的操作
      append(subelement):添加直系子元素。
      extend(subelements):增加一串元素对象作为子元素。#python2.7新特性
      find(match):寻找第一个匹配子元素,匹配对象可以为tag或path。
      findall(match):寻找所有匹配子元素,匹配对象可以为tag或path。
      findtext(match):寻找第一个匹配子元素,返回其text值。匹配对象可以为tag或path。
      insert(index, element):在指定位置插入子元素。
      iter(tag=None):生成遍历当前元素所有后代或者给定tag的后代的迭代器。#python2.7新特性
      iterfind(match):根据tag或path查找所有的后代。
      itertext():遍历所有后代并返回text值。
      remove(subelement):删除子元素。

    复制代码

      

     ElementTree对象

     

    复制代码

    class xml.etree.ElementTree.ElementTree(element=None, file=None)
      element如果给定,则为新的ElementTree的根节点。
    
      _setroot(element):用给定的element替换当前的根节点。慎用。
      
      # 以下方法与Element类中同名方法近似,区别在于它们指定以根节点作为操作对象。
      find(match)
      findall(match)
      findtext(match, default=None)
      getroot():获取根节点.
      iter(tag=None)
      iterfind(match)
      parse(source, parser=None):装载xml对象,source可以为文件名或文件类型对象.
      write(fileencoding="us-ascii"xml_declaration=Nonedefault_namespace=None,method="xml") 

    复制代码

     

     模块方法

     

    复制代码

    xml.etree.ElementTree.Comment(text=None)

    创建一个特别的element,通过标准序列化使其代表了一个comment。comment可以为bytestring或unicode。

     

    xml.etree.ElementTree.dump(elem)

    生成一个element tree,通过sys.stdout输出,elem可以是元素树或单个元素。这个方法最好只用于debug。

     

    xml.etree.ElementTree.fromstring(text)

    text是一个包含XML数据的字符串,与XML()方法类似,返回一个Element实例。

     

    xml.etree.ElementTree.fromstringlist(sequenceparser=None)

    从字符串的序列对象中解析xml文档。缺省parser为XMLParser,返回Element实例。

    New in version 2.7.

     

    xml.etree.ElementTree.iselement(element)

    检查是否是一个element对象。

     

    xml.etree.ElementTree.iterparse(sourceevents=Noneparser=None)

    将文件或包含xml数据的文件对象递增解析为element tree,并且报告进度。events是一个汇报列表,如果忽略,将只有end事件会汇报出来。

    注意,iterparse()只会在看见开始标签的">"符号时才会抛出start事件,因此届时属性是已经定义了,但是text和tail属性在那时还没有定义,同样子元素也没有定义,因此他们可能不能被显示出来。如果你想要完整的元素,请查找end事件。

     

    xml.etree.ElementTree.parse(sourceparser=None)

    将一个文件或者字符串解析为element tree。

     

    xml.etree.ElementTree.ProcessingInstruction(targettext=None)

    这个方法会创建一个特别的element,该element被序列化为一个xml处理命令。

     

    xml.etree.ElementTree.register_namespace(prefixuri)

    注册命名空间前缀。这个注册是全局有效,任何已经给出的前缀或者命名空间uri的映射关系会被删除。

    New in version 2.7.

     

    xml.etree.ElementTree.SubElement(parenttagattrib={}**extra)

    子元素工厂,创建一个Element实例并追加到已知的节点。

     

    xml.etree.ElementTree.tostring(elementencoding="us-ascii"method="xml")

    生成一个字符串来表示表示xml的element,包括所有子元素。element是Element实例,method为"xml","html","text"。返回包含了xml数据的字符串。

     

    xml.etree.ElementTree.tostringlist(elementencoding="us-ascii"method="xml")

    生成一个字符串来表示表示xml的element,包括所有子元素。element是Element实例,method为"xml","html","text"。返回包含了xml数据的字符串列表。

    New in version 2.7.

     

    xml.etree.ElementTree.XML(textparser=None)

    从一个字符串常量中解析出xml片段。返回Element实例。

     

    xml.etree.ElementTree.XMLID(textparser=None)

    从字符串常量解析出xml片段,同时返回一个字典,用以映射element的id到其自身。

    展开全文
  • Python 标准库之 xml.etree.ElementTree

    万次阅读 2020-04-13 13:57:19
    Python中有多种xml处理API,常用的有xml.dom.*模块、xml.sax.*模块、xml.parser.expat模块和xml.etree.ElementTree模块(以下简称ET)。本文将主要介绍ET的使用,以及它的常用函数。其它模块的简介,请参照文献[1]。...

     

    Python中有多种xml处理API,常用的有xml.dom.*模块、xml.sax.*模块、xml.parser.expat模块和xml.etree.ElementTree模块(以下简称ET)。本文将主要介绍ET的使用,以及它的常用函数。其它模块的简介,请参照文献[1]。

    ET使用Element表示xml中的节点、文本、注释等。其主要属性如下:

    tag:string对象,表示数据代表的种类,当为节点时为节点名称。
    
    text:string对象,表示element的内容。
    
    attrib:dictionary对象,表示附有的属性。
    
    tail:string对象,表示element闭合之后的尾迹。
    
    若干子元素(child elements)。

    <tag attrib1=1>text</tag>tail
        1     3            2             4

    PS: ET模块对于那些恶意构造的数据并不是安全的,如果需要解析数据最好了一下xml的弱点[2]

     

    一、导入ET

    在Python标准库中,ElementTree有两种实现方式:一种是纯Python的实现xml.etree.ElementTree,另一种是速度更快一点的xml.etree.cElementTree。如果不确定环境中是否有cElementTree,可以使用如下的方式导入:

    try:
        import xml.etree.cElementTree as ET
    except ImportError:
        import xml.etree.ElementTree as ET

    但从Python 3.3开始,会默认使用cElementTree来加快速度,但是之前的版本最好使用如上的代码,以提高代码的兼容性。

     

    二、解析xml

    假设我们现在有如下的xml

    <?xml version="1.0"?>
    <data>
        <country name="Liechtenstein">
            <rank>1</rank>
            <year>2008</year>
            <gdppc>141100</gdppc>
            <neighbor name="Austria" direction="E"/>
            <neighbor name="Switzerland" direction="W"/>
        </country>
        <country name="Singapore">
            <rank>4</rank>
            <year>2011</year>
            <gdppc>59900</gdppc>
            <neighbor name="Malaysia" direction="N"/>
        </country>
        <country name="Panama">
            <rank>68</rank>
            <year>2011</year>
            <gdppc>13600</gdppc>
            <neighbor name="Costa Rica" direction="W"/>
            <neighbor name="Colombia" direction="E"/>
        </country>
    </data>

    有两种方式可以解析xml

    1. 从文件中解析xml文件

    >>> import xml.etree.cElementTree as ET
    >>> tree = ET.ElementTree(file='doc1.xml')     #载入数据
    >>> root = tree.getroot()     #获取根节点
    <Element 'doc' at 0x11eb780>

     

    2. 从内存字符串中解析xml

    root = ET.fromstring(country_data_as_string)

     

    其中第二种方式可以直接过去根节点。

     

    三、数据的访问

    >>> for child in root:
    ...   print child.tag, child.attrib
    ...
    country {'name': 'Liechtenstein'}
    country {'name': 'Singapore'}
    country {'name': 'Panama'}


    或者直接使用索引寻找子节点:

    >>> root[0][1].text
    '2008'
     

    或者使用xpath方式进行遍历,但其支持部分xpath方法,其支持的xpath请参照[4]

    >>> root.findall("./country/neighbor")
    [<Element 'neighbor' at 0x14fa0f0>, <Element 'neighbor' at 0x14fa150>, <Element 'neighbor' at 0x14fa3f0>, <Element 'neighbor' at 0x14fa6c0>, <Element 'neighbor' at 0x14fa750>]

     

     

    四、 处理xml流

    如下的程序将从xml文件中一边读入xml一边解析,并将在遇到标签开始或标签结束的时候返回相应的事件。

    for event, elem in ET.iterparse(sys.argv[2]):
        if event == 'end':
            if elem.tag == 'location' and elem.text == 'Zimbabwe':
                count += 1
        elem.clear() # discard the element

    这个程序将在检查到标签结束的时候,对指定的标签进行计数。最后的elem.clear()保证了,在解析的之后尽快的释放内存。

     

    五、Element对象

    class xml.etree.ElementTree.Element(tag, attrib={}, **extra)
    
      tag:string      元素代表的数据种类。
      text:string     元素的内容。
      tail:string      元素的尾形。
      attrib:dictionary     元素的属性字典。
     
      #针对属性的操作
      clear()          清空元素的后代、属性、text和tail也设置为None。
      get(key, default=None)     获取key对应的属性值,如该属性不存在则返回default值。
      items()         根据属性字典返回一个列表,列表元素为(key, value)。
      keys()           返回包含所有元素属性键的列表。
      set(key, value)     设置新的属性键与值。
    
      #针对后代的操作
      append(subelement)     添加直系子元素。
      extend(subelements)    增加一串元素对象作为子元素。#python2.7新特性
      find(match)                  寻找第一个匹配子元素,匹配对象可以为tag或path。
      findall(match)               寻找所有匹配子元素,匹配对象可以为tag或path。
      findtext(match)             寻找第一个匹配子元素,返回其text值。匹配对象可以为tag或path。
      insert(index, element)   在指定位置插入子元素。
      iter(tag=None)              生成遍历当前元素所有后代或者给定tag的后代的迭代器。#python2.7新特性
      iterfind(match)              根据tag或path查找所有的后代。
      itertext()                       遍历所有后代并返回text值。
      remove(subelement)      删除子元素。
    

    六、ElementTree对象

    class xml.etree.ElementTree.ElementTree(element=None, file=None)
      element如果给定,则为新的ElementTree的根节点。
    
      _setroot(element):用给定的element替换当前的根节点。慎用。
     
      # 以下方法与Element类中同名方法近似,区别在于它们指定以根节点作为操作对象。
      find(match)
      findall(match)
      findtext(match, default=None)
      iter(tag=None)
      iterfind(match)
      parse(source, parser=None)     装载xml对象,source可以为文件名或文件类型对象
      getroot()     获取根节点
      write(file, encoding="us-ascii", xml_declaration=None, default_namespace=None,method="xml") 

     

    七、模块方法-->用于生成xml文件

    1. 创建一个特别的element,通过标准序列化使其代表了一个comment。comment可以为bytestring或unicode。

         ET.Comment(text=None)

    2. 生成一个element tree,通过sys.stdout输出,elem可以是元素树或单个元素。这个方法最好只用于debug。 

         ET.dump(elem)

    3. text是一个包含XML数据的字符串,与XML()方法类似,返回一个Element实例。 

         ET.fromstring(text)

    4. 从字符串的序列对象中解析xml文档。缺省parser为XMLParser,返回Element实例。V2.7中新加属性 

         ET.fromstringlist(sequence, parser=None)

    5. 检查是否是一个element对象。 

         ET.iselement(element)

    6. 将文件或包含xml数据的文件对象递增解析为element tree,并且报告进度。events是一个汇报列表,如果忽略,将只有end事件会汇报出来。
         注意,iterparse()只会在看见开始标签的">"符号时才会抛出start事件,因此届时属性是已经定义了,但是text和tail属性在那时还没有定义,同样子元素也没有定义,因此他们可能不能被显示出来。如果你想要完整的元素,请查找end事件。

         ET.iterparse(source, events=None, parser=None)

    7. 将一个文件或者字符串解析为element tree。 

         ET.parse(source, parser=None)

    8. 这个方法会创建一个特别的element,该element被序列化为一个xml处理命令。 

         ET.ProcessingInstruction(target, text=None)

    9. 注册命名空间前缀。这个注册是全局有效,任何已经给出的前缀或者命名空间uri的映射关系会被删除。 V2.7新加属性

         ET.register_namespace(prefix, uri)

    10. 子元素工厂,创建一个Element实例并追加到已知的节点。 

         ET.SubElement(parent, tag, attrib={}, **extra)

    11. 生成一个字符串来表示表示xml的element,包括所有子元素。element是Element实例,method为"xml", "html", "text"。 返回包含了xml数据的字符串。 

         ET.tostring(element, encoding="us-ascii", method="xml")

    12. 生成一个字符串来表示表示xml的element,包括所有子元素。element是Element实例,method为"xml","html","text"。返回包含了xml数据的字符串列表。V2.7新添加属性

         ET.tostringlist(element, encoding="us-ascii", method="xml")

    13. 从一个字符串常量中解析出xml片段。返回Element实例。 

         ET.XML(text, parser=None)

     

    14. 从字符串常量解析出xml片段,同时返回一个字典,用以映射element的id到其自身。 

         ET.XMLID(text, parser=None)

    每天一点点,感受自己存在的意义。

    展开全文
  • Python xml.etree.ElementTree解析XML文件

    万次阅读 多人点赞 2018-01-26 21:26:52
    (一)简介 xml.etree.ElementTree模块实现了一个简单而高效的API用于解析和创建XML数据。xml.etree.ElementTree模块对于恶意构造...参考文献:https://docs.python.org/3.6/library/xml.etree.elementtree.html 1.
    (一)简介
    1. xml.etree.ElementTree模块实现了一个简单而高效的API用于解析和创建XML数据。xml.etree.ElementTree模块对于恶意构造的数据是不安全的。如果您需要解析不受信任或未经验证的数据,请参阅XML漏洞。
    2. 参考文献:https://docs.python.org/3.6/library/xml.etree.elementtree.html
    1.XML tree and elements

    XML是一种固有的分层数据格式,最自然的表示方法是使用树。ET有两个类为此目的—ElementTree表示整个XML文档为树,元素表示此树中的单个节点。与整个文档的交互(读取和写入文件)通常是在ElementTree级别上完成的。与单个XML元素及其子元素的交互是在元素级别上完成的。

    2.解析XML文件

    我们将使用以下XML文档作为本节的示例数据。

    <?xml version="1.0"?>
    <data>
        <country name="Liechtenstein">
            <rank>1</rank>
            <year>2008</year>
            <gdppc>141100</gdppc>
            <neighbor name="Austria" direction="E"/>
            <neighbor name="Switzerland" direction="W"/>
        </country>
        <country name="Singapore">
            <rank>4</rank>
            <year>2011</year>
            <gdppc>59900</gdppc>
            <neighbor name="Malaysia" direction="N"/>
        </country>
        <country name="Panama">
            <rank>68</rank>
            <year>2011</year>
            <gdppc>13600</gdppc>
            <neighbor name="Costa Rica" direction="W"/>
            <neighbor name="Colombia" direction="E"/>
        </country>
    </data>
    

    我们可以通过读取文件来导入这些数据:

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

    作为一个元素,root有一个标签和一个属性字典:

    >>> root.tag
    'data'
    >>> root.attrib
    {}
    

    它也有子节点,我们可以迭代:

    >>> for child in root:
    ...     print(child.tag, child.attrib)
    ...
    country {'name': 'Liechtenstein'}
    country {'name': 'Singapore'}
    country {'name': 'Panama'}
    

    孩子节点是嵌套的,我们可以通过索引访问特定的子节点:

    
    >>> root[0][1].text
    '2008'
    

    注:并不是所有的XML元素输入将作为解析数元素的结尾,目前这个模块跳过了所有XML注解、处理指令和文档类型声明。然而创建tree使用的是该模块的API,而不是解析XML文本。通过将自定义TreeBuilder实例传递给XMLParser构造函数,可以访问文档类型声明。

    3.获取XML中的元素

    Element有一些有用的方法,可以帮助递归地遍历它下面的所有子树(它的子树,它们的子树,等等)比如:Element.iter():

    >>> for neighbor in root.iter('neighbor'):
    ...     print(neighbor.attrib)
    ...
    {'name': 'Austria', 'direction': 'E'}
    {'name': 'Switzerland', 'direction': 'W'}
    {'name': 'Malaysia', 'direction': 'N'}
    {'name': 'Costa Rica', 'direction': 'W'}
    {'name': 'Colombia', 'direction': 'E'}
    

    1.Element.findall(): 只找到带有标签的元素,该标签是当前元素的直接子元素。 2.Element.find() :找到第一个带有特定标签的子元素。
    3. Element.text:访问标签的内容
    4. Element.get():访问标签的属性值

    >>> for country in root.findall('country'):
    ...     rank = country.find('rank').text
    ...     name = country.get('name')
    ...     print(name, rank)
    ...
    Liechtenstein 1
    Singapore 4
    Panama 68
    
    4.修改XML文件

    ElementTree提供了一种构建XML文档并将xml写入文件的简单方法。
    1.ElementTree.write() :创建xml文件或向xml中写入数据。
    2.Element.set():添加和修改标签的属性和属性值。
    3.Element.append():添加孩子节点

    假设我们想在每个国家的排名中添加一个,并将更新后的属性添加到rank元素:

    >>> for rank in root.iter('rank'):
    ...     new_rank = int(rank.text) + 1
    ...     rank.text = str(new_rank)
    ...     rank.set('updated', 'yes')
    ...
    >>> tree.write('output.xml')
    

    修改后XML是这样的:

    <?xml version="1.0"?>
    <data>
        <country name="Liechtenstein">
            <rank updated="yes">2</rank>
            <year>2008</year>
            <gdppc>141100</gdppc>
            <neighbor name="Austria" direction="E"/>
            <neighbor name="Switzerland" direction="W"/>
        </country>
        <country name="Singapore">
            <rank updated="yes">5</rank>
            <year>2011</year>
            <gdppc>59900</gdppc>
            <neighbor name="Malaysia" direction="N"/>
        </country>
        <country name="Panama">
            <rank updated="yes">69</rank>
            <year>2011</year>
            <gdppc>13600</gdppc>
            <neighbor name="Costa Rica" direction="W"/>
            <neighbor name="Colombia" direction="E"/>
        </country>
    </data>
    

    我们使用Element.remove()删除标签,假设我们想要移除所有排名高于50的国家:

    >>> for country in root.findall('country'):
    ...     rank = int(country.find('rank').text)
    ...     if rank > 50:
    ...         root.remove(country)
    ...
    >>> tree.write('output.xml')
    

    删除满足条件标签后XML是这样的:

    <?xml version="1.0"?>
    <data>
        <country name="Liechtenstein">
            <rank updated="yes">2</rank>
            <year>2008</year>
            <gdppc>141100</gdppc>
            <neighbor name="Austria" direction="E"/>
            <neighbor name="Switzerland" direction="W"/>
        </country>
        <country name="Singapore">
            <rank updated="yes">5</rank>
            <year>2011</year>
            <gdppc>59900</gdppc>
            <neighbor name="Malaysia" direction="N"/>
        </country>
    </data>
    
    5.创建XML文档

    1.SubElement():用于创建新的子元素。

    >>> a = ET.Element('a')
    >>> b = ET.SubElement(a, 'b')
    >>> c = ET.SubElement(a, 'c')
    >>> d = ET.SubElement(c, 'd')
    >>> ET.dump(a)
    <a><b /><c><d /></c></a>
    
    6.解析XML名称空间

    If the XML input has namespaces, tags and attributes with prefixes in the form prefix:sometag get expanded to {uri}sometag where the prefix is replaced by the full URI. Also, if there is a default namespace, that full URI gets prepended to all of the non-prefixed tags.

    这里有一个XML示例它包含两个名称空间,一个是前缀“ fictional”另一个是默认的名称空间:

    <?xml version="1.0"?>
    <actors xmlns:fictional="http://characters.example.com"
            xmlns="http://people.example.com">
        <actor>
            <name>John Cleese</name>
            <fictional:character>Lancelot</fictional:character>
            <fictional:character>Archie Leach</fictional:character>
        </actor>
        <actor>
            <name>Eric Idle</name>
            <fictional:character>Sir Robin</fictional:character>
            <fictional:character>Gunther</fictional:character>
            <fictional:character>Commander Clement</fictional:character>
        </actor>
    </actors>
    

    搜索名称空间XML示例的更好方法是使用自己的前缀创建字典,并在搜索函数中使用这些前缀:

    ns = {'real_person': 'http://people.example.com',
          'role': 'http://characters.example.com'}
    
    for actor in root.findall('real_person:actor', ns):
        name = actor.find('real_person:name', ns)
        print(name.text)
        for char in actor.findall('role:character', ns):
            print(' |-->', char.text)
    

    输出结果:

    John Cleese
     |--> Lancelot
     |--> Archie Leach
    Eric Idle
     |--> Sir Robin
     |--> Gunther
     |--> Commander Clement
    
    7.对XPath的支持

    xml.etree.ElementTree 模块对XPath表达式在树中定位元素提供了有限的支持。它支持一小部分缩写语法,完整的XPath引擎不在模块的范围内。

    下面的示例演示了模块的一些XPath功能。我们将使用解析XML部分中的countrydata XML文档:

    import xml.etree.ElementTree as ET
    
    root = ET.fromstring(countrydata)
    
    # Top-level elements
    root.findall(".")
    
    # All 'neighbor' grand-children of 'country' children of the top-level
    # elements
    root.findall("./country/neighbor")
    
    # Nodes with name='Singapore' that have a 'year' child
    root.findall(".//year/..[@name='Singapore']")
    
    # 'year' nodes that are children of nodes with name='Singapore'
    root.findall(".//*[@name='Singapore']/year")
    
    # All 'neighbor' nodes that are the second child of their parent
    root.findall(".//neighbor[2]")
    
    01.支持XPath语法

    如图所示:
    这里写图片描述


    (二)参考API
    1.函数

    1.xml.etree.ElementTree.Comment(text=None):注释元素工厂,这个工厂函数创建一个特殊的元素,将被序列化为XML注释标准的序列化器。注释字符串可以是bytestring或Unicode字符串,文本是包含注释字符串的字符串,返回表示注释的元素实例。

    注意:XMLParser忽略了输入中的注释,而不是为它们创建注释对象。如果ElementTree使用其中一个元素方法插入到树中,它只会包含注释节点。

    2.xml.etree.ElementTree.dump(elem):把元素树或元素结构写入sys.stdout。这个函数只用于调试。

    3.xml.etree.ElementTree.fromstring(text):从字符串常量解析XML,XML()方法解析的方式也一样,它们返回的都是一个Element实例。

    4.xml.etree.ElementTree.iselement(element):检查对手是否是有效的element对象,如果是element对象返回true,否则返回false.

    5.xml.etree.ElementTree.iterparse(source, events=None, parser=None):在元素树中逐步解析XML,并且报告用户的情况。资源是文件名或包含xml数据的文件对象。一系列的事件需要被报告,支持事件的字符串有 “start”, “end”, “start-ns” and “end-ns”,如果忽略事件,则只报告“end”事件。解析器是一个可选的解析器实例。如果没有给出,则使用标准的XMLParser解析器。解析器必须是XMLParser的子类,并且只能使用默认的TreeBuilder作为目标。使用iterparse()函数返回一个迭代器对象。

    6.xml.etree.ElementTree.parse(source, parser=None):把XML文件解析成 element tree,资源是一个文件名或包含XML数据的文件对象,解析器是一个可选的解析器实例。如果没有指定parser的参数值,默认使用的是XMLParser解析器。调用此函数返回ElementTree实例对象。

    7.xml.etree.ElementTree.ProcessingInstruction(target, text=None):返回一个元素实例,表示一个处理指令。

    8.xml.etree.ElementTree.register_namespace(prefix, uri):注册命名空间前缀, registry是全局的,任何现有的前缀或名称空间URI的映射都将被删除。这个命名空间中的标签和属性将被给定的前缀给序列化。

    9.xml.etree.ElementTree.SubElement(parent, tag, attrib={}, **extra):此函数是一个Subelement工厂,这个函数用于创建 element 实例,并将其添加到现有的 element 中。

    10.xml.etree.ElementTree.tostring(element, encoding=“us-ascii”, method=“xml”, *, short_empty_elements=True): 转化为字符串。
    01.element:表示一个element实例
    02. encoding:默认编码是"us-ascii"
    03.method:默认是"xml",可以选择“html”、“text”

    11.xml.etree.ElementTree.tostringlist(element, encoding=“us-ascii”, method=“xml”, *, short_empty_elements=True):转化成字符串列表。

    12.xml.etree.ElementTree.XML(text, parser=None):
    01.text :包含xml数据的字符串。
    02.parser:解析器默认是XMLParser
    03.返回的是一个Element实例

    13.xml.etree.ElementTree.XMLID(text, parser=None):返回一个包含Element实例和字典的元组。

    2.Element 对象
    class xml.etree.ElementTree.Element(tag, attrib={}, **extra)

    1.tag: 标签
    2.text: 去除标签,获得标签中的内容。
    3.attrib: 获取标签中的属性和属性值。
    4.tail: 这个属性可以用来保存与元素相关联的附加数据。它的值通常是字符串,但可能是特定于应用程序的对象。

    Element 对象的方法

    1.clear():清除所有子元素和所有属性,并将文本和尾部属性设置为None。

    2.get(attribute_name, default=None):通过指定属性名获取属性值。

    3.items():以键值对的形式返回元素属性。

    4.keys():以列表的方式返回元素名。

    5.set(attribute_name,attribute_value):在某标签中设置属性和属性值。

    6.append(subelement):将元素子元素添加到元素的子元素内部列表的末尾。

    7.extend(subelements):追加子元素。

    8.find(match, namespaces=None):找到第一个匹配的子元素,match可以是标签名或者path。返回Elememt实例或None。

    9.findall(match, namespaces=None):找到所有匹配的子元素,返回的是一个元素列表。

    10.findtext(match, default=None, namespaces=None):找到匹配第一个子元素的文本。返回的是匹配元素中的文本内容。

    11.getchildren():Python3.2后使用 list(elem) 或 iteration.

    12.getiterator(tag=None):Python3.2后使用 Element.iter()

    13.iter(tag=None):以当前元素为根创建树迭代器。迭代器遍历这个元素和它下面的所有元素(深度优先级)。如果标签不是None或’*’,那么只有标签等于标签的元素才会从迭代器返回。如果在迭代过程中修改树结构,则结果是未定义的。

    14.iterfind(match, namespaces=None):匹配满足条件的子元素,返回元素。

    15.itertext():创建一个文本迭代器。迭代器循环遍历此元素和所有子元素,以文档顺序,并返回所有内部文本。

    16.makeelement(tag, attrib):此方法使用SubElement()函数代替。

    17.remove(subelement):删除子元素。

    3.ElementTree 对象

    class xml.etree.ElementTree.ElementTree(element=None, file=None):

    ElementTree是一个包装器类,这个类表示一个完整的元素层次结构,并为标准XML的序列化添加了一些额外的支持。

    1._setroot(element):替换根元素,原来的根元素中的内容会消失。

    2.find(match, namespaces=None):从根元素开始匹配和 Element.find()作用一样。

    3.findall(match, namespaces=None):从根元素开始匹配和 Element.findall()作用一样。

    4.findtext(match, default=None, namespaces=None):从根元素开始匹配和 Element.findtext()作用一样。

    5.getiterator(tag=None):Python3.2后使用 ElementTree.iter() 代替。

    6.iter(tag=None):迭代所有元素

    7.iterfind(match, namespaces=None):从根元素开始匹配和 Element.iterfind()作用一样。

    8.parse(source, parser=None):解析xml文本,返回根元素。

    9.write(file, encoding=“us-ascii”, xml_declaration=None, default_namespace=None, method=“xml”, *, short_empty_elements=True):写出XML文本。

    展开全文
  • 主要介绍了python xml.etree.ElementTree遍历xml所有节点实例详解的相关资料,这里附有实例代码,需要的朋友可以参考下
  • 主要介绍了Python3 xml.etree.ElementTree支持的XPath语法详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 2017/3/12 20.5 xml.etree.ElementTree ElementTree XML API Python 3.6.1rc1文档 20.5xml.etree.ElementTree在ElementTree 的XML API 源代码 Lib / xml / etree / ElementTree.py 该xml.etree.ElementTree模块实现...
  • xml.etree.ElementTree.ParseError: not well-formed (invalid token) 1. XML 解析报错 … tree = ET.parse(xml_file) File “/usr/lib/python3.5/xml/etree/ElementTree.py”, line 1184, in parse tree.parse...

    xml.etree.ElementTree.ParseError: not well-formed (invalid token)

    1. XML 解析报错

    ......
        tree = ET.parse(xml_file)
      File "/usr/lib/python3.5/xml/etree/ElementTree.py", line 1184, in parse
        tree.parse(source, parser)
      File "/usr/lib/python3.5/xml/etree/ElementTree.py", line 596, in parse
        self._root = parser._parse_whole(source)
    xml.etree.ElementTree.ParseError: not well-formed (invalid token): line 868, column 13
    

    2. XML 中存在非法字符

    在这里插入图片描述

    在这里插入图片描述

    编码或者全角/半角输入引起的问题。

    展开全文
  • Python3 xml解析模块xml.etree.ElementTree简介
  • python xml.etree.ElementTree遍历xml所有节点XML文件内容:代码:#-*- coding: UTF-8 -*-# 从文件中读取数据import xml.etree.ElementTree as ET#全局唯一标识unique_id = 1#遍历所有的节点def walkData(root_node,...
  • python2.7.15 xml参考文档 简易化使用: 一、打开xml文件 import xml.etree.ElementTree as ET tree = ET.parse(‘country_data.xml’...tree = xml.etree.ElementTree.parse(f) 二、查找节点/元素 node = tree.find(".
  • '''在Python标准库中,ElementTree有两种实现方式:一种是纯Python的实现xml.etree.ElementTree,另一种是速度更快一点的xml.etree.cElementTree。如果不确定环境中是否有cElementTree,可以使用如下的方式导入但从...
  • 本文快速帮你建立xml.etree.ElementTree的基本概念,并介绍几种简单用法。看完这篇博文,再去学习xml.etree.ElementTree的其它方法就很容易了。
  • xml.etree.ElementTree支持的XPath语法
  • xml.etree.ElementTree模块

    2019-03-13 20:14:00
    xml.etree.ElementTree模块 Element类型是一种灵活的容器对象,用于在内存中存储结构化数据。  xml.etree.ElementTree模块在应对恶意结构数据时显得并不安全。 每个element对象都具有以下属性:  1. tag:...
  • # -*- coding:UTF-8 -*-import xml.etree.ElementTree as ETimport xml.dom.minidom as minidom#获取根节点def getRoot(xmlpath):'''xmlpath:xml文件的路径'''root = ET.parse(xmlpath).getroot()return root#格式化...
  • 自己翻译的python的 xml.etree.ElementTree模块。这个模块向我们展示了python和XML交互的一个方法。
  • xml.etree.ElementTree模块实现了一个简单而高效的API用于解析和创建XML数据。
  • Python 标准库之 xml.etree.ElementTree Python中有多种xml处理API,常用的有xml.dom.*模块、xml.sax.*模块、xml.parser.expat模块和xml.etree.ElementTree模块(以下简称ET)。本文将主要介绍ET的使用,以及它的...
  • import xml.etree.ElementTree as ET tree = ET.parse('C:\test.xml') root = tree.getroot() 改成: import xml.etree.ElementTree as ET f = open('C:\test.xml') xml_text = f.read() root = ET.fromstring(xml_...
  • I am trying to use xml.etree.ElementTree to parse a xml file, find a specific tag, append a child to that tag, append another child to the newly created tag and add text to the latter child.My XML:tex...
  • 68.[Python]使用xml.etree.ElementTree操作XML

    千次阅读 2017-02-07 20:08:47
    详细介绍Python中使用xml.etree.ElementTree操作XML的各种方法。
  • xml.etree.ElementTree xml.dom xml.dom.minidom xml.dom.pulldom xml.sax xml.parsers.expat 本文主要介绍xml.etree.ElementTree(简称ET)模块,它是一个一个简单而轻量级的XML处理器。 关于XML文件的相关知识: ...
  • xml.etree.ElementTree模块 Element类型是一种灵活的容器对象,用于在内存中存储结构化数据。  xml.etree.ElementTree模块在应对恶意结构数据时显得并不安全。 每个element对象都具有以下属性:  1. tag:...
  • python -- xml.etree.ElementTree

    千次阅读 2018-05-09 16:49:19
    简介XML是被设计用来传输和存储数据的可扩展标记语言,Python中可以使用xml.etree.ElementTree操作XML文件。 Python 2.7采用ElementTree 1.3版本。xml.etree.ElementTree的更高效、占用内存更少的C语言版本的实现是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,909
精华内容 3,563
关键字:

xml.etree.elementtree