1.文件的打开与关闭

1.1 打开文件

1.2 关闭文件

2.文件的读取和写入

2.1 文件的读写

3.CSV文件的读写

3.1 CSV文件的写入

4.将数据写入

4.1 StingIO

4.2 BytesIO

5.练习：实现文件拷贝

6.序列化和反序列化

6.1 使用JSON实现列化

6.2 使用JSON实现反序列化

6.3 pickle模块

7.异常处理

7.1 读取文件异常

7.2 try...except语句

7.3 try...else语句

7.4 try...finally语句

8.with关键字的使用

9.自定义异常

1.文件的打开与关闭

想一想：

如果想用word编写一份简历，应该有哪些流程呢？

打开word软件，新建一个word文件

写入个人简历信息

保存文件

关闭word软件

同样，在操作文件的整体过程与使用word编写一份简历的过程是很相似的

打开文件，或者新建立一个文件

读/写数据

关闭文件

1.1 打开文件

在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件

open(文件路径，访问模式)

示例如下：

 f = open('test.txt', 'w')

说明:

文件路径

文件的路径分为相对路径和绝对路径两种。

绝对路径：指的是绝对位置，完整地描述了目标的所在地，所有目录层级关系是一目了然的。
- 例如：C:/Users/chris/AppData/Local/Programs/Python/Python37/python.exe，从电脑的盘符开始，表示的就是一个绝对路径。
相对路径：是从当前文件所在的文件夹开始的路径。
- test.txt，是在当前文件夹查找 test.txt 文件
- ./test.txt，也是在当前文件夹里查找test.txt文件， ./ 表示的是当前文件夹。
- ../test.txt，从当前文件夹的上一级文件夹里查找 test.txt 文件。../ 表示的是上一级文件夹
- demo/test.txt，在当前文件夹里查找 demo这个文件夹，并在这个文件夹里查找 test.txt文件。

访问模式：

访问模式	说明
r	以只读方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，则报错。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+	以二进制格式打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

1.2 关闭文件

close( )

示例如下

 # 新建一个文件，文件名为:test.txt
 f = open('test.txt', 'w')
 
 # 关闭这个文件
 f.close()

2.文件的读取和写入

2.1 文件的读写

2.1.1 写数据（write）

使用write()可以完成向文件写入数据

demo: 新建一个文件 file_write_test.py,向其中写入如下代码:

 f = open('test.txt', 'w')
 f.write('hello world, i am here!\n' * 5)
 f.close()

运行之后会在file_write_test.py文件所在的路径中创建一个文件test.txt,并写入内容，运行效果显示如下:

注意：

如果文件不存在，那么创建；如果存在那么就先清空，然后写入数据

2.1.2 读数据（read）

使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据

demo: 新建一个文件file_read_test.py，向其中写入如下代码:

 f = open('test.txt', 'r')
 content = f.read(5)  # 最多读取5个数据
 print(content)
 
 print("-"*30)  # 分割线，用来测试
 
 content = f.read()  # 从上次读取的位置继续读取剩下的所有的数据
 print(content)
 
 f.close()  # 关闭文件，这个可是个好习惯哦

运行现象：

 hello
 ------------------------------
  world, i am here!

注意：

如果用open打开文件时，如果使用的"r"，那么可以省略 open('test.txt')

2.1.3 读数据（readline）

readline只用来读取一行数据。

 f = open('test.txt', 'r')
 
 content = f.readline()
 print("1:%s" % content)
 
 content = f.readline()
 print("2:%s" % content)
 
 
 f.close()

2.1.4 读数据（readlines）

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

 f = open('test.txt', 'r')
 content = f.readlines()
 print(type(content))
 
 for temp in content:
     print(temp)
 
 f.close()

2.1.5 指针定位

tell()方法用来显示当前指针的

 f = open('test.txt')
 print(f.read(10))  # read 指定读取的字节数
 print(f.tell())    # tell()方法显示当前文件指针所在的文字
 f.close()

xseek(offset,whence) 方法用来重新设定指针的位置。

f = open('test.txt','rb')  # 需要指定打开模式为rb,只读二进制模式

print(f.read(3))
print(f.tell())

f.seek(2,0)   # 从文件的开头开始，跳过两个字节
print(f.read())

f.seek(1,1) # 从当前位置开始，跳过一个字节
print(f.read())

f.seek(-4,2) # 从文件末尾开始，往前跳过四个字节
print(f.read())

f.close()

0表示从文件头开始
1表示从当前位置开始
2 表示从文件的末尾开始
offset:表示偏移量
whence:只能传入012中的一个数字。

3.CSV文件的读写

CSV文件：Comma-Separated Values，中文叫逗号分隔值或者字符分割值，其文件以纯文本的形式存储表格数据。可以把它理解为一个表格，只不过这个表格是以纯文本的形式显示的，单元格与单元格之间，默认使用逗号进行分隔；每行数据之间，使用换行进行分隔。

name,age,score
zhangsan,18,98
lisi,20,99
wangwu,17,90
jerry,19,95

Python中的csv模块，提供了相应的函数，可以让我们很方便的读写csv文件。

3.1 CSV文件的写入

import csv

# 以写入方式打开一个csv文件
file = open('test.csv','w')

# 调用writer方法，传入csv文件对象，得到的结果是一个CSVWriter对象
writer = csv.writer(file)

# 调用CSVWriter对象的writerow方法，一行行的写入数据
writer.writerow(['name', 'age', 'score'])

# 还可以调用writerows方法，一次性写入多行数据
writer.writerows([['zhangsan', '18', '98'],['lisi', '20', '99'], ['wangwu', '17', '90'], ['jerry', '19', '95']])
file.close()

3.2 CSV文件的读取

import csv

# 以读取方式打开一个csv文件
file = open('test.csv', 'r')

# 调用csv模块的reader方法，得到的结果是一个可迭代对象
reader = csv.reader(file)

# 对结果进行遍历，获取到结果里的每一行数据
for row in reader:
    print(row)

file.close()

4.将数据写入

内存中写入数据

除了将数据写入到一个文件以外，我们还可以使用代码，将数据暂时写入到内存里，可以理解为数据缓冲区。Python中提供了StringIO和BytesIO这两个类将字符串数据和二进制数据写入到内存里。

4.1 StingIO

StringIO可以将字符串写入到内存中，像操作文件一下操作字符串。

from io import StringIO

# 创建一个StringIO对象
f = StringIO()
# 可以像操作文件一下，将字符串写入到内存中
f.write('hello\r\n')
f.write('good')

# 使用文件的 readline和readlines方法，无法读取到数据
# print(f.readline())
# print(f.readlines())

# 需要调用getvalue()方法才能获取到写入到内存中的数据
print(f.getvalue())

f.close()

4.2 BytesIO

如果想要以二进制的形式写入数据，可以使用BytesIO类，它的用法和StringIO相似，只不过在调用write方法写入时，需要传入二进制数据。

from io import BytesIO

f = BytesIO()
f.write('你好\r\n'.encode('utf-8'))
f.write('中国'.encode('utf-8'))

print(f.getvalue())
f.close()

5.练习：实现文件拷贝

目标：输入文件的名字，然后程序自动完成对文件进行备份

参考代码

# 提示输入文件
file_name = input("请输入要拷贝的文件名字:")

# 以读的方式打开文件
old_file = open(file_name, 'rb')

# 分割文件名和后缀名
file_names =file_name.rsplit('.', maxsplit=1)

# 组织新的文件名字
new_file_name = file_names[0] + '.bak.'+file_names[1]

# 创建新文件
newFile = open(new_file_name, 'wb')

# 把旧文件中的数据，一行一行的进行复制到新文件中
for lineContent in old_file.readlines():
    newFile.write(lineContent)

# 关闭文件
old_file.close()
newFile.close()

6.序列化和反序列化

通过文件操作，我们可以将字符串写入到一个本地文件。但是，如果是一个对象(例如列表、字典、元组等)，就无法直接写入到一个文件里，需要对这个对象进行序列化，然后才能写入到文件里。

设计一套协议，按照某种规则，把内存中的数据转换为字节序列，保存到文件，这就是序列化，反之，从文件的字节序列恢复到内存中，就是反序列化。

Python中提供了JSON和pickle两个模块用来实现数据的序列化和反序列化。

JSON模块

JSON(JavaScriptObjectNotation, JS对象简谱)是一种轻量级的数据交换格式，它基于 ECMAScript 的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。JSON的本质是字符串！

6.1 使用JSON实现列化

JSON提供了dump和dumps方法，将一个对象进行序列化。

dumps方法的作用是把对象转换成为字符串，它本身不具备将数据写入到文件的功能。

import json
file = open('names.txt', 'w')
names = ['zhangsan', 'lisi', 'wangwu', 'jerry', 'henry', 'merry', 'chris']
# file.write(names)  出错，不能直接将列表写入到文件里

# 可以调用 json的dumps方法，传入一个对象参数
result = json.dumps(names)

# dumps 方法得到的结果是一个字符串
print(type(result))  # <class 'str'>

# 可以将字符串写入到文件里
file.write(result)

file.close()

dump方法可以在将对象转换成为字符串的同时，指定一个文件对象，把转换后的字符串写入到这个文件里。

import json

file = open('names.txt', 'w')
names = ['zhangsan', 'lisi', 'wangwu', 'jerry', 'henry', 'merry', 'chris']

# dump方法可以接收一个文件参数，在将对象转换成为字符串的同时写入到文件里
json.dump(names, file)
file.close()

注意：如果是一个空对象，调用dumps方法转换成为一个JSON对象，得到的结果是null(JS里的空对象)

json.dumps(None)  # null

6.2 使用JSON实现反序列化

使用loads和load方法，可以将一个JSON字符串反序列化成为一个Python对象。

loads方法需要一个字符串参数，用来将一个字符串加载成为Python对象。

import json

# 调用loads方法，传入一个字符串，可以将这个字符串加载成为Python对象
result = json.loads('["zhangsan", "lisi", "wangwu", "jerry", "henry", "merry", "chris"]')
print(type(result))  # <class 'list'>

load方法可以传入一个文件对象，用来将一个文件对象里的数据加载成为Python对象。

import json

# 以可读方式打开一个文件
file = open('names.txt', 'r')

# 调用load方法，将文件里的内容加载成为一个Python对象
result = json.load(file)

print(result)
file.close()

6.3 pickle模块

和json模块类似，pickle模块也有dump和dumps方法可以对数据进行序列化，同时也有load和loads方法进行反序列化。区别在于，json模块是将对象转换成为字符串，而pickle模块是将对象转换成为二进制。

pickle模块里方法的使用和json里方法的使用大致相同，需要注意的是，pickle是将对象转换成为二进制，所以，如果想要把内容写入到文件里，这个文件必须要以二进制的形式打开。

区别(了解)

思考: json和pickle两个模块都可以将对象进行序列化和反序列化，那它们有哪些区别，在使用场景上又该如何选择？

json模块:
- 将对象转换成为字符串，不管是在哪种操作系统，哪种编程语言里，字符串都是可识别的。
- json就是用来在不同平台间传递数据的。
- 并不是所有的对象都可以直接转换成为一个字符串，下标列出了Python对象与json字符串的对应关系。

Python	JSON
dict	object
list,tuple	array
str	string
int,float	number
True	true
False	false
None	null

如果是一个自定义对象，默认无法装换成为json字符串，需要手动指定JSONEncoder.
如果是将一个json串重新转换成为对象，这个对象里的方法就无法使用了。

import json
class MyEncode(json.JSONEncoder):
    def default(self, o):
        # return {"name":o.name,"age":o.age}
        return o.__dict__

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

      def eat(self):
          print(self.name+'正在吃东西')

p1 = Person('zhangsan', 18)

# 自定义对象想要转换成为json字符串，需要给这个自定义对象指定JSONEncoder
result = json.dumps(p1, cls=MyEncode)
print(result)  # {"name": "zhangsan", "age": 18}

# 调用loads方法将对象加载成为一个对象以后，得到的结果是一个字典
p = json.loads(result)
print(type(p))

pickle模块：
- pickle序列化是将对象按照一定的规则转换成为二进制保存，它不能跨平台传递数据。
- pickle的序列化会将对象的所有数据都保存。

7.异常处理

异常的概念

程序在运行过程中，由于我们的编码不规范，或者其他原因一些客观原因，导致我们的程序无法继续运行，此时，程序就会出现异常。如果我们不对异常进行处理，程序可能会由于异常直接中断掉。为了保证程序的健壮性，我们在程序设计里提出了异常处理这个概念。

7.1 读取文件异常

在读取一个文件时，如果这个文件不存在，则会报出FileNotFoundError错误。

7.2 try...except语句

try...except语句可以对代码运行过程中可能出现的异常进行处理。语法结构:

try:
    可能会出现异常的代码块
except 异常的类型:
    出现异常以后的处理语句

示例：

try:
    f = open('test.txt', 'r')
    print(f.read())
except FileNotFoundError:
    print('文件没有找到,请检查文件名称是否正确')

7.3 try...else语句

咱们应该对else并不陌生，在if中，它的作用是当条件不满足时执行的实行；同样在try...except...中也是如此，即如果没有捕获到异常，那么就执行else中的事情

try: num = 100 print(num) except NameError as errorMsg: print('产生错误了:%s'%errorMsg) else: print('没有捕获到异常，真高兴') 运行结果如下:

7.4 try...finally语句

try...finally...语句用来表达这样的情况:

在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用finally。比如文件关闭，释放锁，把数据库连接返还给连接池等。

try:
    f = open('test.txt')
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            print(content)
    except:
        #如果在读取文件的过程中，产生了异常，那么就会捕获到
        #比如 按下了 ctrl+c
        pass
    finally:
        f.close()
        print('关闭文件')
except:
    print("没有这个文件")

说明：

我们可以观察到KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍然被执行，把文件关闭。

8.with关键字的使用

对于系统资源如文件、数据库连接、socket 而言，应用程序打开这些资源并执行完业务逻辑之后，必须做的一件事就是要关闭（断开）该资源。

比如 Python 程序打开一个文件，往文件中写内容，写完之后，就要关闭该文件，否则会出现什么情况呢？极端情况下会出现 "Too many open files" 的错误，因为系统允许你打开的最大文件数量是有限的。

同样，对于数据库，如果连接数过多而没有及时关闭的话，就可能会出现 "Can not connect to MySQL server Too many connections"，因为数据库连接是一种非常昂贵的资源，不可能无限制的被创建。

来看看如何正确关闭一个文件。

普通版:

def m1():
    f = open("output.txt", "w")
    f.write("python之禅")
    f.close()

这样写有一个潜在的问题，如果在调用 write 的过程中，出现了异常进而导致后续代码无法继续执行，close 方法无法被正常调用，因此资源就会一直被该程序占用者释放。那么该如何改进代码呢？

进阶版:

def m2():
    f = open("output.txt", "w")
    try:
        f.write("python之禅")
    except IOError:
        print("oops error")
    finally:
        f.close()

改良版本的程序是对可能发生异常的代码处进行 try 捕获，使用 try/finally 语句，该语句表示如果在 try 代码块中程序出现了异常，后续代码就不再执行，而直接跳转到 except 代码块。而无论如何，finally 块的代码最终都会被执行。因此，只要把 close 放在 finally 代码中，文件就一定会关闭。

高级版:

def m3():
    with open("output.txt", "r") as f:
        f.write("Python之禅")

一种更加简洁、优雅的方式就是用 with 关键字。open 方法的返回值赋值给变量 f，当离开 with 代码块的时候，系统会自动调用 f.close() 方法， with 的作用和使用 try/finally 语句是一样的。

上下文管理器

with语句实质上是一个上下文管理器，with语句后的对象都会有__enter__()和__exit__()方法。在进入到上下文时，会自动调用__enter__()方法，程序正常执行完成，或者出现异常中断的时候，都会调用__exit__()方法。

class MyContext(object):
     def __init__(self, name, age):
         self.name = name
         self.age = age
 
     def __enter__(self):
         print('调用了enter方法')
         return self
 
     def test(self):
         1 / 0
         print(self.name + '调用了test方法')
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         print('调用了exit方法')
         print(exc_type, exc_val, exc_tb)
 
 with MyContext('zhangsan', 18) as context:
     context.test()

9.自定义异常

你可以用raise语句来引发一个异常。异常/错误对象必须有一个名字，且它们应是Error或Exception类的子类

下面是一个引发异常的例子:

class ShortInputException(Exception):
     '''自定义的异常类'''
     def __init__(self, length, atleast):
         #super().__init__()
         self.length = length
         self.atleast = atleast
 
     def __str__(self):
         return '输入的长度是 %d,长度至少应是 %d'% (self.length, self.atleast))
 
 def main():
     try:
         s = input('请输入 --> ')
         if len(s) < 3:
             # raise 引发一个自定义的异常
             raise ShortInputException(len(s), 3)
     except ShortInputException as result:  # x这个变量被绑定到了错误的实例
         print('ShortInputException:' % result)
     else:
         print('没有异常发生.')
 
 main()

运行结果如下: