文章目录
在磁盘上读写文件的功能都是由操作系统提供的，现代操作系统不允许普通的程序直接操作磁盘，所以，读写文件就是请求操作系统打开一个文件对象（通常称为文件描述符），然后，通过操作系统提供的接口从这个文件对象中读取数据（读文件），或者把数据写入这个文件对象（写文件）。
1. 文件读
read():
1、读取整个文件，返回的是一个字符串，字符串包括文件中的所有内容。
2、若想要将每一行数据分离，即需要对每一行数据进行操作，此方法无效。
3、一次性读取文件内容装入内存，若内存不足无法使用此方法。
try:
f = open('file.txt', 'r') # 标示符'r'表示读
print(f.read())
finally:
if f:
f.close() # 文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源
## 输出结果
# hello world
# 浣犲ソ 涓栫晫\n（乱码，原文为‘你好 世界’）
这里有个问题，我的文件存储时采用的编码是utf-8，但是在python中输出的中文是乱码的。把file.txt文件编码改为ASCII后，不再乱码。这是为什么呢？
这是因为Python默认采用ASCII编码读取文件，而源文件file.txt采用的是utf-8编码，编码不一致导致乱码。可以在打开文件的时候指定编码解决这个乱码问题。
f = open('file.txt', 'r', encoding='utf-8')
但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法：
with open('file.txt', 'r', encoding='utf-8') as f:
print(f.read())
这和前面的try … finally是一样的，但是代码更佳简洁，并且不必调用f.close()方法。
readline():
1、每次读取下一行文件。
2、可将每一行数据分离。
3、主要使用场景是当内存不足时，使用readline()可以每次读取一行数据，只需要很少的内存。
# 下面是readline()方法的使用，“r”表示read
with open('file.txt', 'r', encoding='UTF-8') as f:
line = f.readline() # 读取第一行
while line is not None and line != '':
print(line.strip())
line = f.readline() # 读取下一行
readlines():
1、一次性读取所有行文件。
2、可将每一行数据分离，从代码中可以看出，若需要对每一行数据进行处理，可以对readlines()求得的结果进行遍历。
3、一次性装入内存，若内存不足无法使用此方法。
如果文件很小，read()一次性读取最方便；如果不能确定文件大小，反复调用read(size)比较保险；如果是配置文件，调用readlines()最方便：
with open('file.txt', 'r', encoding='utf-8') as f: # 标示符'r'表示读
for line in f.readlines(): # f.readlines() : ['hello world\n', '你好 世界\\n \n']
print(line.strip()) # 把末尾的'\n'删掉
假如连续两次调用readlines()，像下面代码所示：
f = open('file.txt', 'r', encoding='utf-8') # 标示符'r'表示读
print(f.readlines())
print(f.readlines())
## 结果
# ['hello world\n', '你好 世界\\n ']
# []
原因：文件是一个可迭代对象，第一次readlines()执行完后，返回该文件的字符串列表，当readlines()语句执行完后，指针指向后列表的最后一行。所以下一次再readlines()时得到的是空列表，最终导致读取不出东西来。所以要特别注意read(), write(), readlines()这些方法会移动文件指针。
2. 文件写
with open('/Users/michael/test.txt', 'w') as f:
f.write('Hello, world!')
要写入特定编码的文本文件，请给open()函数传入encoding参数，将字符串自动转换成指定编码。
细心的童鞋会发现，以’w’模式写入文件时，如果文件已存在，会直接覆盖（相当于删掉后新写入一个文件）。如果我们希望追加到文件末尾怎么办？可以传入’a’以追加（append）模式写入。
3. 内存读写
3.1 StringIO
很多时候，数据读写不一定是文件，也可以在内存中读写。
StringIO顾名思义就是在内存中读写str。要把str写入StringIO，我们需要先创建一个StringIO，然后，像文件一样写入即可：
from io import StringIO
with open('file.txt', 'r', encoding='utf-8') as f:
f = StringIO()
f.write('hello')
print(f.getvalue()) # getvalue()方法用于获得写入后的str
3.2 BytesIO
StringIO操作的只能是str，如果要操作二进制数据，就需要使用BytesIO。
BytesIO实现了在内存中读写bytes，我们创建一个BytesIO，然后写入一些bytes：
from io import BytesIO
with open('file.txt', 'r', encoding='utf-8') as f:
f = BytesIO()
f.write('中文'.encode('utf-8'))
f.write('english'.encode('utf-8'))
print(f.getvalue()) # 结果：b'\xe4\xb8\xad\xe6\x96\x87english'
要注意的是，写入的不是str，而是经过UTF-8编码的bytes。
4 操作文件和目录
import os
print(os.path.abspath('.')) # 查看当前目录的绝对路径
print(os.path.join('/Users/michael', 'testdir')) # 路径拼接
print(os.path.split('/Users/michael/testdir/file.txt')) # 路径分离
print(os.path.splitext('/path/to/file.txt')) # 获取文件扩展名
os.rename('test.txt', 'test.py') # 文件重命名
## 结果
# E:\CODE\python
# /Users/michael\testdir
# ('/Users/michael/testdir', 'file.txt')
# ('/path/to/file', '.txt')
5. 序列化
5.1 什么是序列化
在程序运行的过程中，所有的变量都是在内存中，比如，定义一个dict：
d = dict(name='Bob', age=20, score=88)
可以随时修改变量，比如把name改成’Bill’，但是一旦程序结束，变量所占用的内存就被操作系统全部回收。如果没有把修改后的’Bill’存储到磁盘上，下次重新运行程序，变量又被初始化为’Bob’。
我们把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
Python提供了pickle模块来实现序列化。
5.2 pickle的使用
首先，我们尝试把一个对象序列化并写入文件：
import pickle
d = dict(name='Bob', age=20, score=88)
print(pickle.dumps(d))
# b'\x80\x04\x95$\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x04name\x94\x8c\x03Bob\x94\x.'
pickle.dumps()方法把任意对象序列化成一个bytes，然后，就可以把这个bytes写入文件。或者用另一个方法pickle.dump()直接把对象序列化后写入一个file-like Object：
import pickle
d = dict(name='Bob', age=20, score=88)
f = open('dump.txt', 'wb')
pickle.dump(d, f)
f.close()
看看写入的dump.txt文件，一堆乱七八糟的内容，这些都是Python保存的对象内部信息。
当我们要把对象从磁盘读到内存时，可以先把内容读到一个bytes，然后用pickle.loads()方法反序列化出对象，也可以直接用pickle.load()方法从一个file-like Object中直接反序列化出对象。我们打开另一个Python命令行来反序列化刚才保存的对象：
import pickle
d = dict(name='Bob', age=20, score=88)
f = open('dump.txt', 'wb')
pickle.dump(d, f)
f.close()
f2 = open('dump.txt', 'rb')
d2 = pickle.load(f2)
f2.close()
print(d2)
变量的内容又回来了！
当然，这个变量和原来的变量是完全不相干的对象，它们只是内容相同而已。
Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
5.3 JSON
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
| JSON类型 | Python类型 |
|---|---|
| {} | dict |
| [] | list |
| “string” | str |
| 1234.56 | int或float |
| true/false | True/False |
| null | None |
5.3.1 Python对象转JSON
Python内置的json模块提供了非常完善的Python对象到JSON格式的转换。我们先看看如何把Python对象变成一个JSON：
import json
d = dict(name='Bob', age=20, score=88)
print(json.dumps(d)) # {"name": "Bob", "age": 20, "score": 88}
dumps()方法返回一个str，内容就是标准的JSON。类似的，dump()方法可以直接把JSON写入一个file-like Object。
5.3.2 JSON反序列化为Python对象
要把JSON反序列化为Python对象，用loads()或者对应的load()方法，前者把JSON的字符串反序列化，后者从file-like Object中读取字符串并反序列化：
import json
json_str = '{"age": 20, "score": 88, "name": "Bob"}'
print(json.loads(json_str)) # {'age': 20, 'score': 88, 'name': 'Bob'}
5.3.3 JSON进阶
Python的dict对象可以直接序列化为JSON的{}，不过，很多时候，我们更喜欢用class表示对象，比如定义Student类，然后序列化：
import json
class Student(object):
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
s = Student('Bob', 20, 88)
print(json.dumps(s))
运行代码，毫不留情地得到一个TypeError：
Traceback (most recent call last):
...
TypeError: <__main__.Student object at 0x10603cc50> is not JSON serializable
错误的原因是Student对象不是一个可序列化为JSON的对象。如果连class的实例对象都无法序列化为JSON，这肯定不合理！别急，我们仔细看看dumps()方法的参数列表，可以发现，除了第一个必须的obj参数外，dumps()方法还提供了一大堆的可选参数：
这些可选参数就是让我们来定制JSON序列化。前面的代码之所以无法把Student类实例序列化为JSON，是因为默认情况下，dumps()方法不知道如何将Student实例变为一个JSON的{}对象。
可选参数default就是把任意一个对象变成一个可序列为JSON的对象，我们只需要为Student专门写一个转换函数，再把函数传进去即可：
def student2dict(std):
return {
'name': std.name,
'age': std.age,
'score': std.score
}
这样，Student实例首先被student2dict()函数转换成dict，然后再被顺利序列化为JSON：
print(json.dumps(s, default=student2dict))
{"age": 20, "name": "Bob", "score": 88}
不过，下次如果遇到一个Teacher类的实例，照样无法序列化为JSON。我们可以偷个懒，把任意class的实例变为dict：
print(json.dumps(s, default=lambda obj: obj.__dict__))
因为通常class的实例都有一个__dict__属性，它就是一个dict，用来存储实例变量。也有少数例外，比如定义了__slots__的class。
同样的道理，如果我们要把JSON反序列化为一个Student对象实例，loads()方法首先转换出一个dict对象，然后，我们传入的object_hook函数负责把dict转换为Student实例：
def dict2student(d):
return Student(d['name'], d['age'], d['score'])
## 运行结果如下：
>>> json_str = '{"age": 20, "score": 88, "name": "Bob"}'
>>> print(json.loads(json_str, object_hook=dict2student))
<__main__.Student object at 0x10cd3c190>
打印出的是反序列化的Student实例对象。
参考
