文章目录
在磁盘上读写文件的功能都是由操作系统提供的,现代操作系统不允许普通的程序直接操作磁盘,所以,读写文件就是请求操作系统打开一个文件对象(通常称为文件描述符),然后,通过操作系统提供的接口从这个文件对象中读取数据(读文件),或者把数据写入这个文件对象(写文件)。
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实例对象。