结构化文件存储

• xml, json
• 为了解决不同设备之间信息交换
• xml
• json

XML文件

• 参考资料

  • https://docs.python.org/3/library/xml.etree.elementtree.html
  • http://www.runoob.com/python/python-xml.html
  • https://blog.csdn.net/seetheworld518/article/details/49535285

• XML(eXtensibleMarkupLanguage), 可扩展标记语言

  • 标记语言：语言中使用尖括号括起来的文本字符串标记

  • 可扩展：用户可以定义自己需要的标记

  • 例如：

      <Teacher>
          自定义标记Teacher
          在两个标记之间任何内容都应该跟Teacher相关
      </Teacher>
    

  • exam.xml

    <?xml version="1.0" encoding="utf-8" ?>
    
    
    <School type="online" loc="beijing">
       <Student type="Web" gender="male">
           <score> math>80 </score>
           <name>
               ruo
           </name>
           <age>18</age>
       </Student>
    
       <Student>
           <name>ruo</name>
           <age>18</age>
       </Student>
    
       <Student>
           <name>ruo</name>
           <age>18</age>
       </Student>
    </School>
    

  • 是w3c组织制定的一个标准

  • XML描述的数据本身，即数据的结构和定义

  • HTML侧重于如何显示web页面中的数据

• XML文档的构成

  • 处理命令（可以认为一个文件内只有一个处理命令）
    • 最多只有一行
    • 且必须在第一行
    • 内容是与xml本身处理起相关的一些声明或者指令
    • 以xml关键字开头
    • 一般用于声明XML的版本和采用的编码
      • version属性是必须的
      • encoding属性用来支出xml解释器使用的编码
  • 根元素（一个文件内只有一个根元素）
    • 在整个xml文件中，可以把他看做一个树形结构
    • 根元素有且只能有一个
  • 子元素
  • 属性
  • 内容
    • 表明标签所存储的信息
  • 注释

    • 起说明作用的信息

    • 注释不能嵌套在标签里

    • 只有在注释的开始和结尾使用双短横线

    • 三短横线只能出现在注释的开头而不能用在结尾

        <name> <!-- wangdapeng -->  </name> #可以
        <name <!-- wangdapeng -->>  </name> #不可以，注释在标签内
       
        <!--my-name-by-wang--> #可以，注释内容可以有一个短横线
        <!--my--name--by--wang--> #不可以，双短横线只能出现在开头或结尾
        
        <!---my-name--> #可以，三短横线只能出现在开头
        <!---my-name---> #不可以，三短横线只能出现在开头
      

• 保留字符的处理

  • XML中使用的符号可能跟实际符号相冲突，典型的就是左右尖括号

  • 使用实体引用(EntityReference)来表示保留字符

      <score> score>80 </score> #有错误，xml中不能出现>
      <score> score&gt;80</score> #使用实体引用
    

  • 把含有保留字符的部分放在CDATA块内部，CDATA块把内部信息视为不需要转义

      <![CDATA[
          select name,age
          from Student
          where score>80
          ]]>
    

  • 常用的需要转义的保留字符和对应的实体引用

      - &:&
      - <:&lt;
      - >:&gt;
      - ':&apos;
      - ":&quot;
      - 一共五个，每个实体引用都以&开头并且以分号结尾
    

• XML标签的签名规则

  • Pascal命名法
  • 用单词表示，第一个字母大写
  • 大小写严格区分
  • 配对的标签必须一致

• 命名空间

  • 为了防止命名冲突

      <Student>
          <Name>ruo</Name>
          <Age>18</Age>
      </Student>
      
      <Room>
          <Nmae>2014</Name>
          <Location>1-23-1</Location>
      </Room>
    

  • 如果归并上述两个内容信息，会产生冲突

      <Schooler>
          <Name>ruo</Name>
          <Age>18</Age>
          <Nmae>2014</Name>
          <Location>1-23-1</Location>
      </Schooler>
    

  • 为了避免冲突，需要给可能冲突元素添加命名空间

  • xmlns: xml name space 的缩写

      <Schooler xmlns:student="http://my_student" xmlns:room="http://my_room">
          <student:Name>ruo</student:Name>
          <Age>18</Age>
          <room:Nmae>2014<room:/Name>
          <Location>1-23-1</Location>
      </Schooler>
    

XML访问

读取

• XML读取分为两个主要技术，SAX，DOM

• SAX(Simple API for XML):

  • 基于事件驱动的API
  • 利用SAX解析文档涉及到解析器和事件处理两部分
  • 特点：
    • 快
    • 流式读取

• DOM

  • 是W3C规定的XML编程接口
  • 一个XML文件在缓冲中以树形结构保存，读取
  • 用途
    • 定位浏览XML任何一个节点信息
    • 添加删除相应内容
  • minidom
    • minidom.parse(filename):加载读取的xml文件, filename也可以是xml代码
    • doc.documentElement:获取xml文档对象，一个xml文件只有一个对于的文档对象
    • node.getAttribute(attr_name):获取xml节点的属性值
    • node.getElementByTagName(tage_name)：得到一个节点对象集合
    • node.childNodes:得到所有孩子节点
    • node.childNodes[index].nodeValue:获取单个节点值
    • node.firstNode:得到第一个节点，等价于node.childNodes[0]
    • node.attributes[tage_name]
    • 案例v01

      import xml.dom.minidom
      # 负责解析xml文件
      from xml.dom.minidom import parse
      
      # 使用minidom打开xml文件
      DOMTree = xml.dom.minidom.parse("student.xml")
      # 得到文档对象
      doc = DOMTree.documentElement
      
      # 显示子元素
      for ele in doc.childNodes:
          if ele.nodeName == "Teacher":
              print("-------Node:{0}------".format(ele.nodeName))
              childs = ele.childNodes
              for child in childs:
                  if child.nodeName == "Name":
                      # data是文本节点的一个属性，表示他的值
                      print("Name:{0}".format(child.childNodes[0].data))
                  if child.nodeName == "Mobile":
                      # data是文本节点的一个属性，表示他的值
                     print("Mobile:{0}".format(child.childNodes[0].data))
                  if child.nodeName == "Age":
                      # data是文本节点的一个属性，表示他的值
                      print("Age:{0}".format(child.childNodes[0].data))
                      if child.hasAttribute("detail"):
                          print("Age-detail:{0}".format(child.getAttribute("detail")))
      

  • etree
    • 以树形结构来表示xml
    • root.getiterator:得到相应的可迭代的node集合
    • root.iter
    • find(node_name):查找指定node_name的节点,返回一个node
    • root.findall(node_name):返回多个node_name的节点
    • node.tag: node对应的tagename
    • node.text:node的文本值
    • node.attrib： 是node的属性的字典类型的内容
    • 案例v02

      import xml.etree.ElementTree
      
      root = xml.etree.ElementTree.parse("student.xml")
      print("利用getiterator访问： ")
      nodes = root.getiterator()
      for node in nodes:
          print("{0}--{1}".format(node.tag, node.text))
      
      
      print("利用find和findall方法： ")
      ele_teacher = root.find("Teacher")
      print(type(ele_teacher))
      print("{0}--{1}".format(ele_teacher.tag, ele_teacher.text))
      
      
      ele_stus = root.findall("Student")
      print(type(ele_stus))
      for ele in ele_stus:
          print("{0}--{1}".format(ele.tag, ele.text))
          for sub in ele.getiterator():
              if sub.tag == "Name":
                  if "Other" in sub.attrib.keys():
              print(sub.attrib['Other'])
      

    • student.xml

      <?xml version="1.0" encoding="UTF-8" ?>
      <School>
          <Teacher desc="PythonTeacher" score="good">
              <Name>ruo</Name>
              <Age detail="Age for year 2010">18</Age>
              <Mobile>18888888888</Mobile>
          </Teacher>
          <Student>
              <Name Other="他是班长">chen</Name>
              <Age Detail="The yongest boy in class">14</Age>
          </Student>
          <Student>
              <Name>LiSi</Name>
              <Age>19</Age>
              <Mobile>16666666666</Mobile>
              <!-- 案例 -->
          </Student>
      </School>
      

• xml文件写入

  • 更改

    • ele.set: 属性
    • ele.append: 添加子元素
    • ele.remove: 删除元素
    • 案例v03

      import xml.etree.ElementTree as et
      
      
      tree = et.parse(r'to_edit.xml')
      
      root = tree.getroot()
      
      for e in root.iter('Name'):
          print(e.text)
      
      for stu in root.iter('Student'):
          name = stu.find('Name')
      
          if name != None:
              name.set('test', name.text * 2)
      
      stu = root.find('Student')
      
      # 生成一个新的元素
      e = et.Element('ADDer')
      e.attrib = {'a':'b'}
      e.text = "我加的"
      
      stu.append(e)
      
      # 一定要把修改后的内容写回文件，否则修改无效
      tree.write('to_edit.xml')
      

    • to_edit.xml

      <School>
      <Teacher>
          <Name>ruochen</Name>
          <Age detail="Age for year 2010">18</Age>
          <Mobile>18888888888</Mobile>
      </Teacher>
      <Student>
          <Name Other="&#20182;&#26159;&#29677;&#38271;" test="ZhangSanZhangSan">ZhangSan</Name>
          <Age Detail="The yongest boy in class">14</Age>
      </Student>
      <Student>
          <Name test="luodayouluodayou">luodayou</Name>
          <Age>59</Age>
          <Mobile>16666666666</Mobile>
      </Student>
      <Student>
          <Name test="LiSiLiSiLiSi">LiSi</Name>
          <Age>19</Age>
          <Mobile>19999999999</Mobile>
      </Student>
      

    </School>

  • 生成创建

    • SubElement, 案例v04

      import xml.etree.ElementTree as et
      
      stu = et.Element("Student1")
      
      name = et.SubElement(stu, 'Name')
      name.attrib = {'lang', 'en'}
      name.text = 'maozedong'
      
      
      age = et.SubElement(stu, 'Age')
      age.text = 18
      
      et.dump(stu)
      

    • minidom写入，案例v05

      import xml.dom.minidom
      
      # 在内存中创建一个空的文档
      doc = xml.dom.minidom.Document()
      # 创建一个根节点Managers对象
      root = doc.createElement('Managers')
      # 设置根节点的属性
      root.setAttribute('company', 'xx科技')
      root.setAttribute('address', '科技软件园')
      # 将根节点添加到文档对象中
      doc.appendChild(root)
      
      managerList = [{'name':'joy', 'age':24, 'sex':'女'},
                     {'name':'tom', 'age':20, 'sex':'男'},
                     {'name':'ruby', 'age':30, 'sex':'女'}
      ]
      
      for i in managerList:
          nodeManager = doc.createElement('Manager')
          nodeName = doc.createElement('name')
          # 给叶子节点name设置一个文本节点，用于显示玩文本内容
          nodeName.appendChild(doc.createTextNode(str(i['name'])))
      
          nodeAge = doc.createElement('Age')
          nodeAge.appendChild(doc.createTextNode(str(i['age'])))
      
          nodeSex = doc.createElement('sex')
          nodeSex.appendChild(doc.createTextNode(str(i['sex'])))
      
          # 将各子叶节点添加到父节点Manager中，
          # 最后将Manager添加到根节点Managers中
          nodeManager.appendChild(nodeName)
          nodeManager.appendChild(nodeAge)
          nodeManager.appendChild(nodeSex)
          root.appendChild(nodeManager)
      
      # 开始写xml文件
      fp = open('Manager.xml', 'w')
      doc.writexml(fp, indent='\t', addindent='\t', newl='\n', encoding='utf-8')
      

    • Manager.xml

      <?xml version="1.0" encoding="utf-8"?>
      <Managers address="科技软件园" company="xx科技">
      	<Manager>
      		<name>joy</name>
      		<Age>24</Age>
      		<sex>女</sex>
      	</Manager>
      	<Manager>
      		<name>tom</name>
      		<Age>20</Age>
      		<sex>男</sex>
      	</Manager>
      	<Manager>
      		<name>ruby</name>
      		<Age>30</Age>
      		<sex>女</sex>
      	</Manager>
      </Managers>
      

    • etree创建，案例v06

      import xml.etree.ElementTree as et
      
      # 在内存中创建一个空的文档
      
      etree = et.ElementTree()
      
      e = et.Element('Student')
      
      etree._setroot(e)
      
      e_name = et.SubElement(e, 'Name')
      e_name.text = 'hahaha'
      
      
      etree.write('v06.xml')
      

    • v06.xml

      <Student><Name>hahaha</Name></Student>