python修改xml中内容的简单介绍

发布时间：2022-11-16

本文目录一览：

  1. python 怎么修改xml文件内容
  2. 求大神指教：如何用python读取xml文件中指定标签的文档内容并将其修改？最好写下详细代码，非常感谢哈！
  3. 用python怎么操作xml文件内容
  4. python解析xml，包含中文，gb2312编码。修改xml后重新写入xml有些内容怎么变了？ 我的步骤如下：
  5. python 替换xml中的一行或者两行
  6. python操作xml文件问题

python 怎么修改xml文件内容

类似于：

#!/usr/bin/evn python 
#coding:utf-8  
try: 
    import xml.etree.cElementTree as ET 
except ImportError: 
    import xml.etree.ElementTree as ET 
import sys  
try: 
    tree = ET.parse("country.xml")     #打开xml文档  
    #root = ET.fromstring(country_string) #从字符串传递xml  
    root = tree.getroot()              #获得root节点  
except Exception, e: 
    print "Error:cannot parse file:country.xml." 
    sys.exit(1) 
print root.tag, "---", root.attrib  
for child in root: 
    print child.tag, "---", child.attrib  
print "*" * 10  
print root[0][1].text    #通过下标访问  
print root[0].tag, root[0].text  
print "*" * 10  
for country in root.findall('country'): #找到root节点下的所有country节点  
    rank = country.find('rank').text    #子节点下节点rank的值  
    name = country.get('name')          #子节点下属性name的值  
    print name, rank  
#修改xml文件  
for country in root.findall('country'): 
    rank = int(country.find('rank').text) 
    if rank  50: 
        root.remove(country)  
tree.write('output.xml')

给你推荐一篇文章看看吧：

求大神指教：如何用python读取xml文件中指定标签的文档内容并将其修改？最好写下详细代码，非常感谢哈！

使用python自带的ElementTree模块，给你个例子你就知道了 xml文档

<?xml version="1.0" encoding="utf-8"?>
<config>
<id>0</id>
<log_path>E:/Python/log_path</log_path>
</config>

Python 代码，修改id节的内容

from xml.etree import ElementTree
xml_file = 'config.xml'
xml = ElementTree.ElementTree(file=xml_file).getroot()
xml.find('id').text = '1'

用python怎么操作xml文件内容

一、什么是xml？

xml即可扩展标记语言，它可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。

abc.xml

<?xml version="1.0" encoding="utf-8"?>
<catalog>
<maxid>4</maxid>
<login username="pytest" passwd='123456'>
<caption>Python</caption>
<item id="4">
<caption>测试</caption>
</item>
</login>
<item id="2">
<caption>Zope</caption>
</item>
</catalog>

Ok ,从结构上，它很像我们常见的HTML超文本标记语言。但他们被设计的目的是不同的，超文本标记语言被设计用来显示数据，其焦点是数据的外观。它被设计用来传输和存储数据，其焦点是数据的内容。 那么它有如下特征：

  • 首先，它是有标签对组成，<aa>...</aa>
  • 标签可以有属性：<aa id='123'>...</aa>
  • 标签对可以嵌入数据：<aa>abc</aa>
  • 标签可以嵌入子标签（具有层级关系）：

二、获得标签属性

那么，下面来介绍如何用python来读取这种类型的文件。

#coding=utf-8
import xml.dom.minidom
#打开xml文档
dom = xml.dom.minidom.parse('abc.xml')
#得到文档元素对象
root = dom.documentElement
print root.nodeName
print root.nodeValue
print root.nodeType
print root.ELEMENT_NODE

xml.dom.minidom 模块被用来处理xml文件，所以要先引入。 xml.dom.minidom.parse() 用于打开一个xml文件，并将这个文件对象dom变量。 documentElement 用于得到dom对象的文档元素，并把获得的对象给root 每一个结点都有它的nodeName，nodeValue，nodeType属性。

  • nodeName为结点名字。
  • nodeValue是结点的值，只对文本结点有效。
  • nodeType是结点的类型。catalog是ELEMENT_NODE类型 现在有以下几种：
  • ATTRIBUTE_NODE
  • CDATA_SECTION_NODE
  • COMMENT_NODE
  • DOCUMENT_FRAGMENT_NODE
  • DOCUMENT_NODE
  • DOCUMENT_TYPE_NODE
  • ELEMENT_NODE
  • ENTITY_NODE
  • ENTITY_REFERENCE_NODE
  • NOTATION_NODE
  • PROCESSING_INSTRUCTION_NODE
  • TEXT_NODE

三、获得子标签

现在要获得catalog的子标签以的标签name

<?xml version="1.0" encoding="utf-8"?>
<catalog>
<maxid>4</maxid>
<login username="pytest" passwd='123456'>
<caption>Python</caption>
<item id="4">
<caption>测试</caption>
</item>
</login>
<item id="2">
<caption>Zope</caption>
</item>
</catalog>

对于知道元素名字的子元素，可以使用getElementsByTagName方法获取：

#coding=utf-8
import xml.dom.minidom
#打开xml文档
dom = xml.dom.minidom.parse('abc.xml')
#得到文档元素对象
root = dom.documentElement
bb = root.getElementsByTagName('maxid')
b = bb[0]
print b.nodeName
bb = root.getElementsByTagName('login')
b = bb[0]
print b.nodeName

如何区分相同标签名字的标签：

<?xml version="1.0" encoding="utf-8"?>
<catalog>
<maxid>4</maxid>
<login username="pytest" passwd='123456'>
<caption>Python</caption>
<item id="4">
<caption>测试</caption>
</item>
</login>
<item id="2">
<caption>Zope</caption>
</item>
</catalog>

caption和item标签不止一个如何区分？

#coding=utf-8
import xml.dom.minidom
#打开xml文档
dom = xml.dom.minidom.parse('abc.xml')
#得到文档元素对象
root = dom.documentElement
bb = root.getElementsByTagName('caption')
b = bb[2]
print b.nodeName
bb = root.getElementsByTagName('item')
b = bb[1]
print b.nodeName

root.getElementsByTagName('caption') 获得的是标签为caption 一组标签，b[0]表示一组标签中的第一个；b[2] ，表示这一组标签中的第三个。

四、获得标签属性值

<?xml version="1.0" encoding="utf-8"?>
<catalog>
<maxid>4</maxid>
<login username="pytest" passwd='123456'>
<caption>Python</caption>
<item id="4">
<caption>测试</caption>
</item>
</login>
<item id="2">
<caption>Zope</caption>
</item>
</catalog>

login和item标签是有属性的，如何获得他们的属性？

#coding=utf-8
import xml.dom.minidom
#打开xml文档
dom = xml.dom.minidom.parse('abc.xml')
#得到文档元素对象
root = dom.documentElement
itemlist = root.getElementsByTagName('login')
item = itemlist[0]
un = item.getAttribute("username")
print un
pd = item.getAttribute("passwd")
print pd
ii = root.getElementsByTagName('item')
i1 = ii[0]
i = i1.getAttribute("id")
print i
i2 = ii[1]
i = i2.getAttribute("id")
print i

getAttribute方法可以获得元素的属性所对应的值。

五、获得标签对之间的数据

<?xml version="1.0" encoding="utf-8"?>
<catalog>
<maxid>4</maxid>
<login username="pytest" passwd='123456'>
<caption>Python</caption>
<item id="4">
<caption>测试</caption>
</item>
</login>
<item id="2">
<caption>Zope</caption>
</item>
</catalog>

caption标签对之间是有数据的，如何获得这些数据？

获得标签对之间的数据有多种方法，

方法一：

#coding=utf-8
import xml.dom.minidom
#打开xml文档
dom = xml.dom.minidom.parse('abc.xml')
#得到文档元素对象
root = dom.documentElement
cc = dom.getElementsByTagName('caption')
c1 = cc[0]
print c1.firstChild.data
c2 = cc[1]
print c2.firstChild.data
c3 = cc[2]
print c3.firstChild.data

firstChild 属性返回被选节点的第一个子节点，.data表示获取该节点人数据。

方法二：

#coding=utf-8
from xml.etree import ElementTree as ET
per = ET.parse('abc.xml')
p = per.findall('./login/item')
for oneper in p:
    for child in oneper.getchildren():
        print child.tag, ':', child.text
p = per.findall('./item')
for oneper in p:
    for child in oneper.getchildren():
        print child.tag, ':', child.text

方法二有点复杂，所引用模块也与前面的不一样，findall用于指定在哪一级标签下开始遍历。 getchildren方法按照文档顺序返回所有子标签。并输出标签名（child.tag）和标签的数据（child.text） 其实，方法二的作用不在于此，它核心功能是可以遍历某一级标签下的所有子标签。

python解析xml，包含中文，gb2312编码。修改xml后重新写入xml有些内容怎么变了？ 我的步骤如下：

可能是python内置模块的输出是那样的，不需要用ue转，我觉得直接当文本读入内容MSG,然后解码再编码msg.decode("gb2312").encode("utf-8")，然后用正则表达式xx替换内容/xx来替换内容。。。个人觉得省事些，当然要看你具体情况

python 替换xml中的一行或者两行

a = 'Range 0-229956 /Range'
b = "'Range 0-(A-1) /Range'\n'Range B-229956 /Range'"
d = open("a.xml", "w")
while 1:
    line = d.readline()
    if line == a:
        replace(a, b)
    if not line:
        break

如果你的A,B两个值是从终端读取的话在开始read一下就行：

read A
read B

python操作xml文件问题

我给你个示例代码，你自己改改增加子节点那一段就好了。

#!/usr/bin/python
# -*- coding=utf-8 -*-
# author : wklken@yeah.net
# date: 2012-05-25
# version: 0.1
from xml.etree.ElementTree import ElementTree, Element
def read_xml(in_path):
    '''读取并解析xml文件
       in_path: xml路径
       return: ElementTree'''
    tree = ElementTree()
    tree.parse(in_path)
    return tree
def write_xml(tree, out_path):
    '''将xml文件写出
       tree: xml树
       out_path: 写出路径'''
    tree.write(out_path, encoding="utf-8", xml_declaration=True)
def if_match(node, kv_map):
    '''判断某个节点是否包含所有传入参数属性
       node: 节点
       kv_map: 属性及属性值组成的map'''
    for key in kv_map:
        if node.get(key) != kv_map.get(key):
            return False
    return True
#---------------search -----
def find_nodes(tree, path):
    '''查找某个路径匹配的所有节点
       tree: xml树
       path: 节点路径'''
    return tree.findall(path)
def get_node_by_keyvalue(nodelist, kv_map):
    '''根据属性及属性值定位符合的节点，返回节点
       nodelist: 节点列表
       kv_map: 匹配属性及属性值map'''
    result_nodes = []
    for node in nodelist:
        if if_match(node, kv_map):
            result_nodes.append(node)
    return result_nodes
#---------------change -----
def change_node_properties(nodelist, kv_map, is_delete=False):
    '''修改/增加 /删除 节点的属性及属性值
       nodelist: 节点列表
       kv_map:属性及属性值map'''
    for node in nodelist:
        for key in kv_map:
            if is_delete:
                if key in node.attrib:
                    del node.attrib[key]
            else:
                node.set(key, kv_map.get(key))
def change_node_text(nodelist, text, is_add=False, is_delete=False):
    '''改变/增加/删除一个节点的文本
       nodelist:节点列表
       text : 更新后的文本'''
    for node in nodelist:
        if is_add:
            node.text += text
        elif is_delete:
            node.text = ""
        else:
            node.text = text
def create_node(tag, property_map, content):
    '''新造一个节点
       tag:节点标签
       property_map:属性及属性值map
       content: 节点闭合标签里的文本内容
       return 新节点'''
    element = Element(tag, property_map)
    element.text = content
    return element
def add_child_node(nodelist, element):
    '''给一个节点添加子节点
       nodelist: 节点列表
       element: 子节点'''
    for node in nodelist:
        node.append(element)
def del_node_by_tagkeyvalue(nodelist, tag, kv_map):
    '''同过属性及属性值定位一个节点，并删除之
       nodelist: 父节点列表
       tag:子节点标签
       kv_map: 属性及属性值列表'''
    for parent_node in nodelist:
        children = parent_node.getchildren()
        for child in children:
            if child.tag == tag and if_match(child, kv_map):
                parent_node.remove(child)
if __name__ == "__main__":
    #1. 读取xml文件
    tree = read_xml("./test.xml")
    #2. 属性修改
    #A. 找到父节点
    nodes = find_nodes(tree, "processers/processer")
    #B. 通过属性准确定位子节点
    result_nodes = get_node_by_keyvalue(nodes, {"name":"BProcesser"})
    #C. 修改节点属性
    change_node_properties(result_nodes, {"age": "1"})
    #D. 删除节点属性
    change_node_properties(result_nodes, {"value":""}, True)
    #3. 节点修改
    #A.新建节点
    a = create_node("person", {"age":"15","money":"200000"}, "this is the firest content")
    #B.插入到父节点之下
    add_child_node(result_nodes, a)
    #4. 删除节点
    #定位父节点
    del_parent_nodes = find_nodes(tree, "processers/services/service")
    #准确定位子节点并删除之
    target_del_node = del_node_by_tagkeyvalue(del_parent_nodes, "chain", {"sequency" : "chain1"})
    #5. 修改节点文本
    #定位节点
    text_nodes = get_node_by_keyvalue(find_nodes(tree, "processers/services/service/chain"), {"sequency":"chain3"})
    change_node_text(text_nodes, "new text")
    #6. 输出到结果文件
    write_xml(tree, "./out.xml")
推荐文章