1.XML基本概念

XML指可扩展语言(eXtensible Markup Language)，用来传输和存储数据，一个XML文件分为如下几部分内容：

1）文档声明   2）元素   3）属性   4）注释    5）CDATA区   6）实体

1.1 文档声明

在编写XML文档时，需要先使用文档声明，声明XML文档的类型。最简单的声明语法：<?xml version="1.0" encoding="UTF-8"?>，其中version表示XML的版本，encoding表示文档的编码格式，默认为utf-8。当XML文件中有中文时，必须使用encoding属性指明文档的字符编码，例如：encoding="GB2312"或者encoding="utf-8"，并且在保存文件时，也要以相应的文件编码来保存，否则在使用浏览器解析XML文件时，就会出现解析错误的情况。

1.2 元素

XML元素指XML文件中出现的标签，一个标签分为开始标签和结束标签，一个标签有如下几种书写形式，例如：

  • 包含标签体：<a>www.cnblogs.com/</a>
  • 不含标签体的：<a></a>, 简写为：<a/>

一个标签中也可以嵌套若干子标签。但所有标签必须合理的嵌套，绝对不允许交叉嵌套 ，例如：错误的写法：<a>welcome to <b>www.cnblogs.com/</a></b>

格式良好的XML文档必须有且仅有一个根标签，其它标签都是这个根标签的子孙标签。此外对于XML标签中出现的所有空格和换行，XML解析程序都会当作标签内容进行处理，例如：下面两段内容的意义是不一样的。

第一段：<网址>http://www.cnblogs.com/</网址>

第二段：

<网址>http://www.cnblogs.com/
</网址>

由于在XML中，空格和换行都作为原始内容被处理，所以，在编写XML文件时，使用换行和缩进等方式来让原文件中的内容清晰可读的“良好”书写习惯可能要被迫改变。

XML元素名称命名规范：

  1. 区分大小写，例如，<P>和<p>是两个不同的标记。
  2. 不能以数字或"_" (下划线)开头。
  3. 不能以xml(或XML、或Xml 等)开头。
  4. 不能包含空格。
  5. 名称中间不能包含冒号（:）

1.3 属性

一个标签可以有多个属性，每个属性都有它自己的名称和取值，例如：<input name='text'>，属性值一定要用双引号（"）或单引号（'）引起来，定义属性必须遵循与标签相同的命名规范 。多学一招：在XML技术中，标签属性所代表的信息，也可以被改成用子元素的形式来描述，例如：

<input><name>text</name>
</input>

View Code

1.4 注释

Xml文件中的注释采用： <!--注释--> 格式。

　　注意：

  • XML声明之前不能有注释
  • 注释不能嵌套，例如：　

<!--大段注释……<!--局部注释-->……-->

View Code

1.5 CDATA区

在编写XML文件时，有些内容可能不想让解析引擎解析执行，而是当作原始内容处理，遇到此种情况，可以把这些内容放在CDATA区里，对于CDATA区域内的内容，XML解析程序不会处理，而是直接原封不动的输出。

语法：<![CDATA[ 内容 ]]>

示例:

<?xml version="1.0" encoding="UTF-8"?> <!--声明部分-->
<studentlist>  <!--根节点--><student id="10086">  <!--子节点,id节点属性--><name>张三</name><age>20</age><description><![CDATA[个人说明：<title></title>]]></description></student><student id="10087"><name>李四</name><age>22</age></student>
</studentlist>

View Code

1.6 实体

对于一些单个字符，若想显示其原始样式，也可以使用转义的形式予以处理。

1.7 格式良好的XML文档

　　1）必须有XML的声明语句     2）必须有且只有一个XML根元素       3）标签大小写敏感

　　4）属性使用双引号                5）标签必须成对出现                         6）空标签关闭

　　7）元素必须正确的嵌套         8）必须对特殊字符使用实体

2. xml的解析方法

常见的XML编程接口有DOM和SAX，这两种接口处理XML文件的方式不同，使用场合自然也就不同。Python有三种方法解析XML: SAX，DOM，以及ElementTree。

2.1 SAX (Simple API for XML )

Pyhton标准库包含SAX解析器，SAX用事件驱动模型，通过在解析XML的过程中触发一个个的事件并调用用户定义的回调函数来处理XML文件。SAX是一种基于事件驱动的API。利用SAX解析XML文档牵涉到两个部分:解析器和事件处理器。解析器负责读取XML文档,并向事件处理器发送事件,如元素开始及结束事件;而事件处理器则负责对事件作出处理。

优点:SAX流式读取XML文件，比较快，占用内存少。

缺点:需要用户实现回调函数（handler）。

2.2 DOM(Document Object Model)

将XML数据在内存中解析成一个树，通过对树的操作来操作XML。一个DOM的解析器在解析一个XML文档时，一次性读取整个文档，把文档中所有元素保存在内存中的一个树结构里，之后你可以利用DOM提供的不同的函数来读取或修改文档的内容和结构，也可以把修改过的内容写入xml文件。

优点:使用DOM的好处是你不需要对状态进行追踪，因为每一个节点都知道谁是它的父节点，谁是子节点.

缺点:DOM需要将XML数据映射到内存中的树，一是比较慢，二是比较耗内存，使用起来也比较麻烦！

2.3 ElementTree(元素树)

ElementTree就像一个轻量级的DOM，具有方便友好的API。代码可用性好，速度快，消耗内存少。相比而言，第三种方法，即方便，又快速，下面介绍用元素树如何解析XML。

3. ElementTree 详解

以Country.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"/><weather><Monday>rainy day</Monday><Tuesday>sunny day</Tuesday></weather></country>
</data>

View Code

我们把<country>xxx</contry>这种结构称为一个element，country称作element的tag，<></>之间的内容称作element的text或data，<>中的name称作element的attrib，而整个XML树被称作ElementTree。ElementTree生来就是为了处理 XML ，它在 Python 标准库中有两种实现。一种是纯 Python 实现例如xml.etree.ElementTree，另外一种是速度快一点的xml.etree.cElementTree。你要记住：尽量使用C语言实现的那种，因为它速度更快，而且消耗的内存更少。如果你的电脑上没有 _elementtree，那么你需要这样做：

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

这是一个让 Python 不同的库使用相同 API 的一个比较常用的办法。注意：从Python3.3开始，你没有必要这么做了，因为ElementTree模块会自动寻找可用的C库来加快速度。所以只需要 import xml.etree.ElementTree 就可以。

ElementTree模块拥有两个类

1）ElementTree: 代表整个XML文档，视作tree；用于对整个XML文档的操作；
2）Element： 代表XML文档(tree)上的单个节点；用于对XML节点及子节点的操作；

其官方中文版说明文档地址如下:

http://doc.codingdict.com/python_352/library/xml.etree.elementtree.html

3.1 模块方法

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

2) xml.etree.ElementTree.iselement(element)：检查element是否是有效的element对象，如果是element对象返回true，否则返回false.

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

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

5) xml.etree.ElementTree.tostring(element, encoding=”us-ascii”, method=”xml”, short_empty_elements=True):：将element及其所有的subelements转化成字符串。

其中element：表示一个element实例 ，encoding：默认编码是”us-ascii” ，method：默认是”xml”，可以选择“html”、“text”。

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

7) xml.etree.ElementTree.XML(text, parser=None)：用于从字符串常量中解析XML部分。其中text ：包含xml数据的字符串。 parser：解析器，默认是XMLParser ，结果返回的是一个Element实例

8）xml.etree.ElementTree.iterparse(source, events=None, parser=None)：在元素树中逐步解析XML,并且报告用户的情况。其中source是包含XML数据的文件名或文件对象。 events是要报告的事件列表，event有start，end，startns和endns四种选择 ，默认为end。 parser是一个可选的解析器实例，如果没有给出，则使用标准XMLParser解析器。 cElementTree不支持解析器。由iterparse创建的迭代器会产生形如(event,elem)的元组，其中event是事件列表中的某一个，而elem是相应的XML元素。

3.2 方法释义

3.2.1 使用模块方法读取XML数据

#_*_coding=utf-8
import xml.etree.ElementTree as ET
#1.ET对象具有多种方法从不同来源导入XML数据
#1)调用parse()方法，返回解析树
tree = ET.parse(r'E:\2018-12-19\country.xml')#载入数据<xml.etree.ElementTree.ElementTree object at 0x000001F36FFF8A20>
root =tree.getroot()#获取根节点，<Element 'data' at 0x0000018607C88638>
#2)调用fromstring()方法，从字符串常量中解析XML，返回解析树的根元素
data = open(r'E:\2018-12-19\country.xml').read()
root1= ET.fromstring(data)#<Element 'data' at 0x000001D99F539778>
#3)调用ElementTree类ElementTree(self, element=None, file=None)
tree1 = ET.ElementTree(r'E:\2018-12-19\country.xml')#<xml.etree.ElementTree.ElementTree object at 0x0000015EEBBB69B0>
root2 = tree.getroot()#<Element 'data' at 0x000001E74E558638>
#4)调用XML()方法，用于从字符串常量中解析XML部分。
root3 = ET.XML(data)#<Element 'data' at 0x0000027B351AAD68>

读取XML数据

3.2.2 element对象的属性和方法

Element类
class xml.etree.ElementTree.Element(tag, attrib={}, **extra)#属性
　　tag：string，元素类型，element type。text：string，元素的内容,元素起始tag于结尾tag之间的文本。tail：string，元素的尾形。元素结尾tag与下一个起始tag之间的文本attrib：dictionary，元素的属性字典。＃针对属性的操作clear()：清空元素的后代、属性，并设置text和tail的属性为None。get(key, default=None)：获取key对应的属性值，如该属性不存在则返回default值。items()：根据属性字典返回一个列表，列表元素为(key, value）。keys()：返回包含所有元素属性键的列表。set(key, value)：设置新的属性键与值。＃针对后代的操作append(subelement)：添加一个直系子元素。extend(subelements)：通过列表对象追加0个或多个子元素。＃python2.7新特性find(match,namespaces=None)：寻找第一个匹配子元素，匹配对象可以为tag或path。findall(match,namespaces=None)：寻找所有匹配子元素，匹配对象可以为tag或path。findtext(match)：寻找第一个匹配子元素，返回其text值。匹配对象可以为tag或path。insert(index, element)：在指定位置插入子元素。iter(tag=None)：以当前element为root，创建一个tree iterator。＃python2.7新特性iterfind(match,namespaces=None)：根据tag或path查找所有的后代。itertext()：遍历所有后代并返回text值。remove(subelement)：删除子元素。

View Code

练习:

#_*_coding=utf-8
import xml.etree.ElementTree as ET
tree = ET.parse(r'E:\2018-12-19\country.xml')#载入数据<xml.etree.ElementTree.ElementTree object at 0x000001F36FFF8A20>
root =tree.getroot()#获取根节点，<Element 'data' at 0x0000018607C88638>
#1.获取element object 的四大属性tag、text、attrib以及tail
print(root.tag) #root element的tag
print(root.text) #root element的text
print(root.attrib) #root element本身的attrib,dict格式的
print(root.tail) #root element的tag结束到下一个tag之间的text
# #通过DICT逻辑获取树形结构的text，表示第一个child的第二个child element的text
print(root[0][1].text)#2008
#2. 针对属性的操作
#1)简单操作
print(root[0][3].keys())#['name', 'direction']
print(root[0][3].get('name'))#Austria
print(root[0][3].items())#[('name', 'Austria'), ('direction', 'E')]
root[0][3].set('name','aa')
#2）将所有的rank值加1,并添加属性updated为yes
for rank in root.iter("rank"):new_rank = int(rank.text) + 1rank.text = str(new_rank)  # 必须将int转为strrank.set("updated", "yes") # 添加属性
# 再终端显示整个xml
ET.dump(root)
# 注意 修改的内容存在内存中 尚未保存到文件中
# 保存修改后的内容
tree.write(r'E:\2018-12-19\country1.xml')
#3）删除添加的updated属性
for rank in root.iter("rank"):# attrib为属性字典# 删除对应的属性updateddel rank.attrib['updated']
ET.dump(root)
#3.遍历
#1)简单遍历
# 遍历xml文档的第二层
for child in root:# 第二层节点的标签名称和属性print(child.tag,":", child.attrib)# 遍历xml文档的第三层for children in child:# 第三层节点的标签名称和属性print(children.tag, ":", children.attrib)
#2）利用Element提供的方法遍历
#过滤出所有neighbor标签
for neighbor in root.iter('neighbor'):print(neighbor.tag,":",neighbor.attrib)
#遍历所有的country标签
for country in root.findall('country'):# 查找country标签下的第一个rank标签rank = country.find("rank").text# 获取country标签的name属性name = country.get("name")print(name, rank)

View Code

Xpath句法含义列表:

#_*_coding=utf-8
import xml.etree.ElementTree as ET
tree = ET.parse(r'E:\2018-12-19\country.xml')#载入数据<xml.etree.ElementTree.ElementTree object at 0x000001F36FFF8A20>
root =tree.getroot()#获取根节点，<Element 'data' at 0x0000018607C88638>
#4.查找感兴趣的标签
#1)使用element方法查找country名为"singapore"的国家的gdp值以及排名
#findall只能用来查找直接子元素，不能用来查找rank，neighbor等element
for country in root.findall('country'):name = country.get('name')if name == 'Singapore':rank = country.find('rank').textgdp = country.find('gdppc').textprint("{name}: rank={rank},gdp={gdp}".format(name=name,rank=rank,gdp=gdp))else:continue
#输出:Singapore: rank=5,gdp=59900
#2)使用Xpath寻找所有国家的name属性
countrylist=root.findall("./country")
for country in countrylist:print(country.get('name'))
#输出
# Liechtenstein
#Singapore
#Panama
#3)Xpath练习
#a)选取所有的country元素的rank子元素
print(root.findall('./country/rank'))#[<Element 'rank' at 0x0000029686D98228>, <Element 'rank' at 0x0000029686F79458>, <Element 'rank' at 0x0000029686F795E8>]
#b)以根节点为始祖，选取其后代中的rank元素
print(root.findall('.//rank'))#[<Element 'rank' at 0x0000023C970B71D8>, <Element 'rank' at 0x0000023C9729B408>, <Element 'rank' at 0x0000023C9729B598>]
#c)以country为始祖，选取后代中的year元素
print(root.findall('country//year'))#[<Element 'year' at 0x0000028F45BD1AE8>, <Element 'year' at 0x0000028F45BEC458>, <Element 'year' at 0x0000028F45BEC5E8>]
#d)以country为始祖，选取后代中的具有direction属性的元素
print(root.findall("country//*[@direction]"))#[<Element 'neighbor' at 0x000001E7E4A13228>, <Element 'neighbor' at 0x000001E7E4A1A368>, <Element 'neighbor' at 0x000001E7E4A1A4F8>, <Element 'neighbor' at 0x000001E7E4A1A688>, <Element 'neighbor' at 0x000001E7E4A1A6D8>]
#e)选取根元素的第一个country子元素
print(root.findall('./country[1]'))#[<Element 'country' at 0x0000024D411B4048>]
#f)选取根元素的最后一个country子元素
print(root.findall('./country[last()]'))#[<Element 'country' at 0x00000228D371A548>]
#g)选取根元素的倒数第二个country子元素
print(root.findall('./country[last()-1]'))#[<Element 'country' at 0x0000013D1C94A3B8>]
#h)以根节点为始祖，选取其后代含有name属性且值为Malaysia的元素
print(root.findall(".//*[@name='Malaysia']"))#[<Element 'neighbor' at 0x00000223B202A4F8>]
#i)以root为始祖，选取具有year子元素且其子元素text为2011的元素
print(root.findall(".//*[year='2011']"))#[<Element 'country' at 0x000002982D2D93B8>, <Element 'country' at 0x000002982D2D9548>]
#g)以country为始祖，选取具有名为Monday子元素的元素
print(root.findall("country//*[Monday]"))#[<Element 'weather' at 0x000001C447FBA728>]
#k)以root为始祖，选取name=panama的元素的后代Monday元素
print(root.findall(".//*[@name='Panama']/weather/Monday"))#[<Element 'Monday' at 0x0000017AA408A778>]
print(root.findall(".//*[@name='Panama']/*/Monday"))

获取感兴趣的元素

3.2.3 创建XML文档

1）创建XML

#_*_coding=utf-8
import xml.etree.ElementTree as ET
#使用indent函数，使element tree 输出带缩进格式的xml
def indent(elem, level=0):i = "\n" + level*"\t"if len(elem):if not elem.text or not elem.text.strip():elem.text = i + "\t"if not elem.tail or not elem.tail.strip():elem.tail = ifor elem in elem:indent(elem, level+1)if not elem.tail or not elem.tail.strip():elem.tail = ielse:if level and (not elem.tail or not elem.tail.strip()):elem.tail = i
#创建根节点
data = ET.Element('data')
#创建子节点并添加属性
sub1= ET.SubElement(data,'country',attrib={'name':'Liechtenstein','MothorTongue':'German'})
#sub1.attrib = {'MothorTongue':'German'}#此处再赋值，会覆盖之前设置的attrib值
country1_rank = ET.SubElement(sub1,'rank')
country1_rank.text = '2'
country1_year = ET.SubElement(sub1,'year')
country1_year.text = '2008'
country1_gdp = ET.SubElement(sub1,'gdppc')
country1_gdp.text = '141100'
country1_neighbor = ET.SubElement(sub1,'neighbor',attrib={'name':'Austria','direction':'w'})
indent(data)
ET.dump(data)
#创建element tree对象，写文件
tree = ET.ElementTree(data)
tree.write(r'E:\2018-12-19\text.xml')

View Code

2)将字典转换为XML文档

#_*_coding=utf-8
import xml.etree.ElementTree as ET#使用indent函数，使element tree 输出带缩进格式的xml
def indent(elem, level=0):i = "\n" + level*"\t"if len(elem):if not elem.text or not elem.text.strip():elem.text = i + "\t"if not elem.tail or not elem.tail.strip():elem.tail = ifor elem in elem:indent(elem, level+1)if not elem.tail or not elem.tail.strip():elem.tail = ielse:if level and (not elem.tail or not elem.tail.strip()):elem.tail = i
def dict_to_xml(tag, d):'''Turn a simple dict of key/value pairs into XML'''elem = ET.Element(tag)for key, val in d.items():child = ET.Element(key)child.text = str(val)elem.append(child)return elemdict1 = {'rank':'2','year':'2008','gdppc':'141100','neighbor':''}
data = dict_to_xml('country',dict1)
indent(data)
ET.dump(data)#输出
# <country>
#     <rank>2</rank>
#     <year>2008</year>
#     <gdppc>141100</gdppc>
#     <neighbor />
# </country>

View Code

3.2.4 解析大型XML文档

使用xml.etree.ElementTree.iterparse(source, events=None, parser=None)方法你将用尽可能少的内存从一个超大的XML文档中提取数据。

示例1：iterparse的简单使用

#_*_coding=utf-8
import xml.etree.ElementTree as ET
data = ET.iterparse(r'E:\2018-12-19\country.xml',('start','end'))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
#输出
# ('start', <Element 'data' at 0x000001A2AFA23228>)
# ('start', <Element 'country' at 0x000001A2AFA2B368>)
# ('start', <Element 'rank' at 0x000001A2AFA2B3B8>)
# ('end', <Element 'rank' at 0x000001A2AFA2B3B8>)
# ('start', <Element 'year' at 0x000001A2AFA2B408>)
# ('end', <Element 'year' at 0x000001A2AFA2B408>)
# ('start', <Element 'gdppc' at 0x000001A2AFA2B458>)
# ('end', <Element 'gdppc' at 0x000001A2AFA2B458>)
# ('start', <Element 'neighbor' at 0x000001A2AFA2B4A8>)
# ('end', <Element 'neighbor' at 0x000001A2AFA2B4A8>)
# ('start', <Element 'neighbor' at 0x000001A2AFA2B4F8>)
# ('end', <Element 'neighbor' at 0x000001A2AFA2B4F8>)
# ('end', <Element 'country' at 0x000001A2AFA2B368>)
# ('start', <Element 'country' at 0x000001A2AFA2B548>)
# ('start', <Element 'rank' at 0x000001A2AFA2B598>)

View Code

由上例可以看出，start 事件在某个元素第一次被创建并且还没有被插入其他数据 (如子元素) 时被创建，即是当遇到标签的“>”符号时触发start，而 end 事件在某个元素已经完成时被创建，即是遇到标签的结束标志时会触发end。

下面是一个包含iterparse()方法的很简单的函数，该函数只使用很少的内存就能增量式的处理一个大型 XML 文件，实现对节点的迭代式解析和删除，返回指定路径的最后一层元素。

#_*_coding=utf-8
from xml.etree.ElementTree import iterparsedef parse_and_remove(filename,path):path_parts = path.split('/')doc = iterparse(filename, ('start', 'end'))# Skip the root element
    next(doc)tag_stack = []elem_stack = []for event, elem in doc:if event == 'start':tag_stack.append(elem.tag)elem_stack.append(elem)elif event == 'end':if tag_stack == path_parts:yield elemelem_stack[-2].remove(elem)try:tag_stack.pop()elem_stack.pop()except IndexError:passdata = parse_and_remove(r'E:\2018-12-19\country.xml',('country/weather/Monday'))
print(next(data))
#输出
#<Element 'Monday' at 0x00000283BCD89958>

View Code

>>>>待续

转载于:https://www.cnblogs.com/wuxunyan/p/10444964.html

Python之XML模块相关推荐

  1. python中xml模块_python常用模块之xml模块

    使用xml模块需先引入模块名: #! /usr/bin/env python # -*- coding:utf-8 -*- import xml.etree.ElementTree as ET #ET ...

  2. Python基础-XML模块

    xml是实现不同语言或程序之间进行数据交换的协议,跟json差不多,但json使用起来更简单,不过,古时候,在json还没诞生的黑暗年代,大家只能选择用xml呀,至今很多传统公司如金融行业的很多系统的 ...

  3. python中xml模块_python学习第十五天-2（XML模块）

    也是一种文本转换形式. import xxxxxxxxxxxxxxxxxxx  as xx,可以用xx代替xxxxxxxxxxxxxxxxxxx模块 xml文件的新增,修改,删除,查询. 新增:​ i ...

  4. python解析xml生成代码_python解析xml模块封装代码

    有如下的xml文件: 复制代码 代码如下: 1 2 下面介绍python解析xml文件的几种方法,使用python模块实现. 方式1,python模块实现自动遍历所有节点: 复制代码 代码如下: #! ...

  5. python解析xml文件最好选用的模块_用Python解析XML文件

    本文翻译自:https://developer.yahoo.com/python/python-xml.html 使用Python解析XML文件 许多YDN APIs提供了JSON格式的数据输出,JS ...

  6. python常用内置模块-Python常用内置模块之xml模块

    xml即可扩展标记语言,它可以用来标记数据.定义数据类型,是一种允许用户对自己的标记语言进行定义的源语言.从结构上,很像HTML超文本标记语言.但他们被设计的目的是不同的,超文本标记语言被设计用来显示 ...

  7. python常用内置模块-Python常用内置模块之xml模块(详解)

    xml即可扩展标记语言,它可以用来标记数据.定义数据类型,是一种允许用户对自己的标记语言进行定义的源语言.从结构上,很像HTML超文本标记语言.但他们被设计的目的是不同的,超文本标记语言被设计用来显示 ...

  8. python模块--json \ pickle \ shelve \ XML模块

    一.json模块 之前学习过的eval内置方法可以将一个字符串转成一个python对象,不过eval方法时有局限性的,对于普通的数据类型,json.loads和eval都能用,但遇到特殊类型的时候,e ...

  9. 初学者python笔记（json模块、pickle模块、xml模块、shelve模块）

    文章目录 json模块 正常数据转化(复杂) json模块的相关操作 pickle模块 shelve模块 xml模块 在Python中,json模块.pickle模块.xml模块.shelve模块这四 ...

  10. Python之路(第十六篇)xml模块、datetime模块

    一.xml模块 xml是实现不同语言或程序之间进行数据交换的协议,跟json差不多,但json使用起来更简单, xml比较早,早期许多软件都是用xml,至今很多传统公司如金融行业的很多系统的接口还主要 ...

最新文章

  1. 线程Queue，进程Queue和RabbitMQ区别
  2. java棋盘问题_0x03大数问题（JAVA解决棋盘覆盖，A+B Problem II）
  3. matlab 连通分支,(完整版)图的连通性判断matlab实验报告
  4. python ipaddress_Python3标准库：ipaddress Internet地址
  5. python基础-C扩展
  6. C++(STL):20---deque容器访问元素
  7. SpringBoot中如何优雅的使用拦截器
  8. spring + mybatis + 多数据源整合事务
  9. TI CCS下载地址
  10. arduino：废旧光驱DIY激光雕刻机（完善中……）
  11. 如何在word中批量编辑所有图片的大小？
  12. 悉尼大学计算机专业新生,悉尼大学计算机专业详解
  13. 来自一个曾经200斤现在140斤程序员的减肥成功经验（包含个人认为相对安全的饮食法推荐）
  14. 使用markdownpad生成目录
  15. 使用苹果的地图与定位
  16. PDF Search for Mac(PDF文件搜索工具)
  17. 函数最值题目及答案_关于函数的习题及答案
  18. greedy策略求解活动选择问题 ActivitySelectProblem
  19. 【Java面试】什么是字节码？采用字节码的好处是什么？
  20. EasyX学习笔记（二、黑客帝国数据流）

热门文章

  1. Perl语言入门，第17章自写习题答案。
  2. Python--繁体中文与简体中文相互转换
  3. Read_books_水煮三国
  4. 选频滤波器 matlab,MATLAB低通滤波器选频实现
  5. java下载 文件_Java下载文件的几种方式
  6. Windows环境下hadoop安装和配置详细步骤
  7. JavaScript函数及其作用
  8. 武汉市15区科技企业孵化器及众创空间补贴附武汉市科技企业孵化器和众创空间管理办法
  9. 佳易王收银管理软件和扫码通M800大部分扫码支付平台对接步骤：
  10. mybatis中mysql递归查询多级_mybatis+mysql递归查询