python常用文件操作和解析xml文件_python关闭xml文件

---

1 文件操作的作用

背景介绍：我是java程序员需要去了解一下python，对于里面的一些数据结构，循环判断直接就看看代码就知道了，所以文章没有体现这类基础知识的学习，对于文件操作肯定是python最重要的，因为要做数据分析肯定需要读文件。

java文件操作入门：

Java文件类File

Java文件上传下载删除文件输入输出流IO
’

2 文件的基本操作

2.1 打开文件

在Python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件，语法如下：
open(name, mode)
name: 是要打开的目标文件名的字符串（可以包含文件所在的具体路径）
mode：设置打开文件的模式（访问模式）：只读、写入、追加等。
(有涉及到读写等操作）

list1 = 'aaa'
# 1.打开open()
f = open('test.txt', 'w')
# 2.读写操作    write() read()
f.write(list1)

# 3.关闭
f.close()
1
2
3
4
5
6
7
8

运行结果：

"""
测试目标：
1. 访问模式对文件的影响
2. 访问模式对write（）的影响
3. 访问模式是否可以省略
"""
# r  如果文件不存在，报错
f = open("test1.txt", "r")
f.close()

1
2
3
4
5
6
7
8
9
10

该错误是由于读取的时候发现读取不到文件test1.txt而产生的报错

f = open("test.txt", "r")
f.write('aa')

1
2
3

该错误是由于写入的时候发现前面定义的test.txt只用于读取而产生的报错

f1 = open("2.txt",'a')
f1.write('abc')
f1.close()

1
2
3
4

运行的时候会往2.txt之后增加abc字符串，abc字符串数量取决于运行次数追加到后面字符串

# 访问模式参数是否可以省略
f = open('100.txt')
f.close()

1
2
3
4

f = open('2.txt')
f.close()

1
2
3

由以上两次代码实验得出，当不写访问模式参数的时候，默认视为只读模式（其中2.txt为已经创建的文本文档，100.txt为未创建的）

2.2 读写等操作

2.2.1 read()文件内容读取

文件对象.read(num)
num表示要从文件中读取的数据的长度(单位是字节)，如果没有传入num，那么就表示读取文件中所有的数据。
test.txt 已经建立：

f = open('test.txt', 'r')
# 文件内容如果换行，底层有\n,会有字节占位，导致read书写参数读取出来的眼睛看到的个数和参数值不匹配 
print(f.read(6))			# aaaa
							# b

# read不写参数表示读取所有：
print(f.read())				# aaaa
							# bbbb
							# cccc
							# dddd

1
2
3
4
5
6
7
8
9
10
11

2.2.2 readline()一次读取一行内容

readline()一次读取一行内容。

f = open('test.txt', 'r')
con = f.readline()
print(con)						# aaaa
print(con)						# aaaa
print(con)						# aaaa

f = open('test.txt', 'r')
con = f.readline()
print(con)						# aaaa
con = f.readline()
print(con)						# bbbb
con = f.readline()
print(con)						# cccc

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.2.3 readlines()按每行返回列表

readlines可以按照行的方式把整个文件中的内容进行一次性读取，返回的是一个列表，其中每一行的数据为一个元素。

# readlines测试
f = open('test.txt', 'r')
con = f.readlines()
print(con)
f.close()		#['aaaa\n', 'bbbb\n', 'cccc\n', 'dddd\n']

1
2
3
4
5
6

2.2.4 seek（）指定位置进行读取

作用：用来移动文件指针。
语法如下：
文件对象.seek(偏移量，起始位置)
起始位置：
·0：文件开头
·1：当前位置
·2：文件结尾

"""
语法： 文件对象.seek（偏移量， 起始位置） 0 开头 1 当前 2 结尾
目标：
    1.r改变文件指针位置：改变读取数据开始位置或把文件指针放借位（无法读取数据）
    2.a改变文件指针位置，做到可以读取出来数据

"""
f = open('test.txt', 'r+')
# 1.改变读取数据开始位置
# f.seek(2, 0)

# 1.文件指针放结尾，就读不出数据了
f.seek(0, 2)

con = f.read()
print(con)

f.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

将r+改为a+即可利用a访问模式访问

2.3 关闭文件

.close()

注意：可以只打开和关闭文件，不进行任何读写操作。

3 文件备份

需求：用户输入当前目录下任意文件名，程序完成对该文件的备份功能（备份文件名为XX[备份]后缀，例如：test[备份].txt）

步骤：

1.接受用户输入的文件名
2.规划备份文件名
3.备份文件写入数据
1
2
3

代码实现:接受用户输入目标文件名：

# 1.用户输入目标文件
old_name = input('请输入您要备份的文件名：')
# print(old_name)
# print(type(old_name))
# 2.规划备份文件的名字
# 2,1 提取后缀 -- 找到名字中的点 -- 名字和后缀分离 -- 最右侧的点才是后缀的点--字符串查找某个字串rfind
index = old_name.rfind('.')
# print(index)

# 2,2 组织新名字 = 原名字 + [备份] + 后缀
# 原名字就是字符串中的一部分子串 -- 切片[开始：结束：步长]
new_name = old_name[:index] + '[备份]' + old_name[index:]
print(new_name)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

备份文件写入数据

			a)打开源文件和备份文件
			b)将原文件数据写入备份文件
			c)关闭文件
# 备份文件写入数据（数据和源文件一样）
# 1.打开原文件和备份文件
old_f = open(old_name, 'rb')
new_f = open(new_name, 'wb')
# 2.原文件读取，备份文件写入
# 如果不确定目标文件大小，循环读取写入，当读取出来的数据没有了终止循环
while True:
    con = old_f.read(1024)
    if len(con) == 0:
        # 表示读取完成了
        break
    new_f.write(con)
# 3.关闭文件
old_f.close()
new_f.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.思考：如果文件名为.txt该怎么办？

# 4.思考：有效文件才备份.txt
if index > 0:
    # 提取后缀
    postfix = old_name[index:]
# 同时将后面 new_name 改为这种写法
new_name = old_name[:index] + '[备份]' + postfix
1
2
3
4
5
6

当文件名为.txt的时候，将old_name 进行倒叙切片，因为.txt之前没有内容，所以无法定义postfix

4 文件和文件夹的操作

在python中文件和文件夹的操作要借助os模块里面的相关功能，具体步骤如下：

1. 导入os模块：import os
2. 使用os模块相关功能 os.函数名()

import os
# 1.rename():重命名
# os.rename('test1.txt', '10.txt')

# 2.remove():删除文件
# os,remove('10.txt')
# 3.mkdir():创建文件夹
# os.mkdir('aa')

# 4.rmdir():删除文件夹
# os.rmdir('aa')

# 5.getcwd(): 返回当前文件所在目录路径
# print(os.getcwd())

# 6.chdir():改变目录路径
# os.mkdir('aa')
# 需求：在aa里面创建bb文件夹
# os.mkdir('bb')
# os.chdir('aa')
# os.mkdir('bb')

# 7.listdir(路径) 以列表形式返回某个文件夹下所有文件名字
# print(os.listdir())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

5 应用案例

需求：批量修改文件名，既可添加指定字符串，又能删除指定字符串。
··········•步骤

1. 设置添加删除字符串的标识
2. 获取指定目录的所有文件
3. 将原有文件名添加/删除指定字符串，构造新名字
4. os.rename()重命名

# 需求1：把code文件夹所有文件重命名 Python_xxxxx
# 需求2：删除Python_重命名： 1.构造条件的数据 2. 书写if
import os

# 构造条件的数据
flag = 1
# 当需要把前缀删除的时候可以将flag改为2，一键快捷删除
# 1.找到所有文件：获取code文件夹的目录列表 -- listdir()
file_list = os.listdir()
print(file_list)


# 2，构造名字
for i in file_list:
    if flag == 1:
        # new_name = 'Python_' + 原文件i
        new_name = 'Python_' + i
    elif flag == 2:
        # 删除前缀
        num = len('Python_')
        new_name = i[num:]
	# 3.重命名
    os.rename(i, new_name)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

6 Python3 XML解析

6.1 什么是XML？

XML 指可扩展标记语言（eXtensible Markup Language），标准通用标记语言的子集，是一种用于标记电子文件使其具有结构性的标记语言。

XML 被设计用来传输和存储数据。

XML 是一套定义语义标记的规则，这些标记将文档分成许多部件并对这些部件加以标识。

它也是元标记语言，即定义了用于定义其他与特定领域有关的、语义的、结构化的标记语言的句法语言。

---

6.2 python对XML的解析

常见的 XML 编程接口有 DOM 和 SAX，这两种接口处理 XML 文件的方式不同，当然使用场合也不同。

Python 有三种方法解析 XML，SAX，DOM，以及 ElementTree:

6.2.1.SAX (simple API for XML )

Python 标准库包含 SAX 解析器，SAX 用事件驱动模型，通过在解析 XML 的过程中触发一个个的事件并调用用户定义的回调函数来处理 XML 文件。

6.2.2.DOM(Document Object Model)

将 XML 数据在内存中解析成一个树，通过对树的操作来操作 XML。

本章节使用到的 XML 实例文件 movies.xml 内容如下：

<collection shelf="New Arrivals">
<movie title="Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title="Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title="Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

---

6.3 Python 使用 SAX 解析 xml

SAX 是一种基于事件驱动的 API。

利用 SAX 解析 XML 文档牵涉到两个部分:解析器和事件处理器。

解析器负责读取 XML 文档,并向事件处理器发送事件,如元素开始跟元素结束事件;

而事件处理器则负责对事件作出相应,对传递的 XML 数据进行处理。

• 1、对大型文件进行处理；
• 2、只需要文件的部分内容，或者只需从文件中得到特定信息。
• 3、想建立自己的对象模型的时候。

在 Python 中使用 sax 方式处理 xml 要先引入 xml.sax 中的 parse 函数，还有 xml.sax.handler 中的 ContentHandler。

6.3.1 ContentHandler 类方法介绍

characters(content) 方法

调用时机：

从行开始，遇到标签之前，存在字符，content 的值为这些字符串。

从一个标签，遇到下一个标签之前， 存在字符，content 的值为这些字符串。

从一个标签，遇到行结束符之前，存在字符，content 的值为这些字符串。

标签可以是开始标签，也可以是结束标签。

startDocument() 方法

文档启动的时候调用。

endDocument() 方法

解析器到达文档结尾时调用。

startElement(name, attrs) 方法

遇到XML开始标签时调用，name 是标签的名字，attrs 是标签的属性值字典。

endElement(name) 方法

遇到XML结束标签时调用。

---

6.4 make_parser 方法

以下方法创建一个新的解析器对象并返回。

xml.sax.make_parser( [parser_list] )
1

参数说明:

• parser_list - 可选参数，解析器列表

---

6.5 parser 方法

以下方法创建一个 SAX 解析器并解析xml文档：

xml.sax.parse( xmlfile, contenthandler[, errorhandler])
1

参数说明:

• xmlfile - xml文件名
• contenthandler - 必须是一个 ContentHandler 的对象
• errorhandler - 如果指定该参数，errorhandler 必须是一个 SAX ErrorHandler 对象

---

6.6 parseString 方法

parseString 方法创建一个 XML 解析器并解析 xml 字符串：

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])
1

参数说明:

• xmlstring - xml字符串
• contenthandler - 必须是一个 ContentHandler 的对象
• errorhandler - 如果指定该参数，errorhandler 必须是一个 SAX ErrorHandler对象

---

6.7 Python 解析XML实例

#!/usr/bin/python3

import xml.sax

class MovieHandler( xml.sax.ContentHandler ):
   def __init__(self):
      self.CurrentData = ""
      self.type = ""
      self.format = ""
      self.year = ""
      self.rating = ""
      self.stars = ""
      self.description = ""

   # 元素开始调用
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print ("*****Movie*****")
         title = attributes["title"]
         print ("Title:", title)

   # 元素结束调用
   def endElement(self, tag):
      if self.CurrentData == "type":
         print ("Type:", self.type)
      elif self.CurrentData == "format":
         print ("Format:", self.format)
      elif self.CurrentData == "year":
         print ("Year:", self.year)
      elif self.CurrentData == "rating":
         print ("Rating:", self.rating)
      elif self.CurrentData == "stars":
         print ("Stars:", self.stars)
      elif self.CurrentData == "description":
         print ("Description:", self.description)
      self.CurrentData = ""

   # 读取字符时调用
   def characters(self, content):
      if self.CurrentData == "type":
         self.type = content
      elif self.CurrentData == "format":
         self.format = content
      elif self.CurrentData == "year":
         self.year = content
      elif self.CurrentData == "rating":
         self.rating = content
      elif self.CurrentData == "stars":
         self.stars = content
      elif self.CurrentData == "description":
         self.description = content
  
if ( __name__ == "__main__"):
   
   # 创建一个 XMLReader
   parser = xml.sax.make_parser()
   # 关闭命名空间
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)

   # 重写 ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )
   
   parser.parse("movies.xml")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

以上代码执行结果如下：

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

完整的 SAX API 文档请查阅 Python SAX APIs

---

6.8 使用xml.dom解析xml

文件对象模型（Document Object Model，简称DOM），是W3C组织推荐的处理可扩展置标语言的标准编程接口。

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

python中用xml.dom.minidom来解析xml文件，实例如下：

#!/usr/bin/python3

from xml.dom.minidom import parse
import xml.dom.minidom

# 使用minidom解析器打开 XML 文档
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print ("Root element : %s" % collection.getAttribute("shelf"))

# 在集合中获取所有电影
movies = collection.getElementsByTagName("movie")

# 打印每部电影的详细信息
for movie in movies:
   print ("*****Movie*****")
   if movie.hasAttribute("title"):
      print ("Title: %s" % movie.getAttribute("title"))

   type = movie.getElementsByTagName('type')[0]
   print ("Type: %s" % type.childNodes[0].data)
   format = movie.getElementsByTagName('format')[0]
   print ("Format: %s" % format.childNodes[0].data)
   rating = movie.getElementsByTagName('rating')[0]
   print ("Rating: %s" % rating.childNodes[0].data)
   description = movie.getElementsByTagName('description')[0]
   print ("Description: %s" % description.childNodes[0].data)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

以上程序执行结果如下：

Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

完整的 DOM API 文档请查阅 Python DOM APIs。