账不能只存在内存里:Python 文件读写
账只存在内存里,程序一关就全没了。本文按 Python 官方教程第 7 章与 csv 模块文档讲清楚:f 字符串与 format、str 与 repr、open 的 r/w/a/r+ 四种模式、with、五种读法、write 与 tell/seek、JSON 整存整取、CSV 的 DictReader/DictWriter,另附虚构晨光书店记账脚本第五个月 100 次翻车的分布。

先把这篇的边界说清楚。这是「Python 基础」系列第五篇,接着前四篇往下走:第一篇讲了变量、类型和流程控制,第二篇讲了函数与模块,第三篇讲了类与继承,第四篇讲了异常处理。这篇讲文件读写:进货单和日报总不能只存在内存里,程序一关就全没了。下面用到的「晨光书店」还是那个虚构的练手项目:一家街边小书店,店主的记账小脚本已经会算库存、会打折、会用类管书、会接住异常了。这篇要解决的新问题是:把账写进文件里存下来,下次打开接着用;把进货单从文件里读进来,不用一遍遍手输。所有关于文件读写的说法,都来自 Python 官方教程第 7 章《Input and Output》和官方 csv 模块文档,来源见每篇的 meta 信息与 evidence 记录;本文所有以晨光书店为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。读完这篇,你应该能做到五件事:会用 f 字符串和 format 把数字排成整齐的表格;知道 open 的 r、w、a、r+ 四种模式各会发生什么;会用 with 读文件、写文件,知道文件什么时候关;会把一堆字典存成 JSON、读回来接着用;会用 csv 模块读写带表头的表格文件。跟第四篇的划界是:第四篇的 with 和 open 只讲「收尾」——文件用完一定关上;这篇讲「读写本身」——读几种方法、写几种格式、存几种结构,异常处理只在必要时提一句,不重讲 try/except 的规矩。
第一步:先把字排好看——f 字符串
官方教程第 7 章开头说,程序输出有好几种办法:数据可以打印成人能读的样子,也可以写进文件留着以后用。最常用的办法你已经会了:表达式语句和 print()。但光会 print() 不够,账单得排得整齐才好看。第一种排版办法是格式化字符串字面量,也就是 f 字符串:在字符串前面加个 f 或 F,大括号里可以直接写 Python 表达式:
>>> year = 2016
>>> event = 'Referendum'
>>> f'Results of the {year} {event}'
'Results of the 2016 Referendum'
大括号后面还能跟格式说明,控制数字长什么样。官方例子是把圆周率保留三位小数:
>>> import math
>>> print(f'The value of pi is approximately {math.pi:.3f}.')
The value of pi is approximately 3.142.
:.3f 的意思是:按小数格式,保留三位。冒号后面跟一个整数,可以指定这一格最少占几个字符宽,排表格就靠它。官方例子是一张电话表:
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
... print(f'{name:10} ==> {phone:10d}')
...
Sjoerd ==> 4127
Jack ==> 4098
Dcab ==> 7678
{name:10} 是名字最少占 10 个字符宽,不够的在右边补空格;{phone:10d} 是电话号码按整数格式、最少占 10 个字符宽,不够的在左边补空格。两列的箭头就对齐了。书店的版本:店主的日报要列每本书的单价和库存,一行一个,价格保留一位小数:
books = [('三体', 59.0, 7), ('海底两万里', 39.5, 12), ('活着', 29.0, 5)]
for title, price, stock in books:
print(f'{title:8} 单价 {price:5.1f} 元 库存 {stock:2d} 本')
三体 单价 59.0 元 库存 7 本
海底两万里 单价 39.5 元 库存 12 本
活着 单价 29.0 元 库存 5 本
还有两个 f 字符串的小写法,调试的时候很好用。!r 会先对值用 repr() 再放进来,字符串会带着引号出现;= 会把表达式本身也印出来,等于自带说明:
>>> animals = 'eels'
>>> print(f'My hovercraft is full of {animals!r}.')
My hovercraft is full of 'eels'.
>>> bugs = 'roaches'
>>> count = 13
>>> area = 'living room'
>>> print(f'Debugging {bugs=} {count=} {area=}')
Debugging bugs='roaches' count=13 area='living room'
我的判断是:写给人看的账单和日志,优先用 f 字符串——表达式直接写在大括号里,读代码的人一眼就能看出这一格印的是什么;等你需要把格式字符串本身存起来、晚点再填数的时候,再用下一步的 format()。
第二步:format() 与手动排版——格式字符串晚点再填
第二种办法是字符串的 format() 方法:大括号里留空等着填,调用的时候再把值传进去。官方例子:
>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"
>>> print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
>>> print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam
大括号里写数字,就按位置取;写名字,就按关键字参数取;位置和关键字还能混着用:
>>> print('This {food} is {adjective}.'.format(
... food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.
>>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
... other='Georg'))
The story of Bill, Manfred, and Georg.
格式说明和 f 字符串是一套写法。官方例子是赞成票的统计:数字靠右对齐占 9 位宽,百分比保留两位小数:
>>> yes_votes = 42_572_654
>>> total_votes = 85_705_149
>>> percentage = yes_votes / total_votes
>>> '{:-9} YES votes {:2.2%}'.format(yes_votes, percentage)
' 42572654 YES votes 49.67%'
{:2.2%} 是把小数乘以 100、保留两位小数、再添一个百分号,所以 0.4967… 印出来是 49.67%。注意 42_572_654 里的下划线只是为了让人读着方便,Python 会把它当成 42572654,数字本身没有下划线。官方还用 format() 印了一张 1 到 10 的平方与立方表:
>>> for x in range(1, 11):
... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
第三种办法是自己动手拼字符串:字符串有 rjust()、ljust()、center(),可以把字符串撑到指定宽度;zfill() 可以在数字字符串左边补零。官方例子:
>>> for x in range(1, 11):
... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
... # Note use of 'end' on previous line
... print(repr(x*x*x).rjust(4))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
注意两点:rjust() 这些方法不改原字符串,只返回一个新字符串;如果字符串本身比指定宽度还长,它不会截断,原样返回——官方说,排版乱了,也比把值说错了强。想截断得自己再切片。还有一种老写法是用 % 号做格式化,官方教程 7.1.4 节只提了一句:
>>> print('The value of pi is approximately %5.3f.' % math.pi)
The value of pi is approximately 3.142.
老代码里常见,新代码优先用 f 字符串。我的判断是:三种排版办法不用全记,记住分工就行——平时写 f 字符串,格式要存起来复用就用 format(),补零编号就用 zfill(),比如把单号排成 '00012' 这样。
第三步:str 和 repr——给人看的和给机器看的
排版之前先分清两个函数:str() 和 repr()。官方教程说,str() 返回的是给人看的样子,repr() 返回的是能让解释器读回去的样子——没有等价写法的时候也会报错。很多值用哪个都一样,但字符串不一样:
>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print(s)
The value of x is 32.5, and y is 40000...
>>> hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, world\n'
>>> repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"
repr('hello, world\n') 会把换行符写成看得见的 \n、外面再加一层引号,印出来是 'hello, world\n',而不是真的换一行。调试的时候这个区别很有用:字符串末尾到底有没有换行、空格是几个,print() 看不出来,repr() 看得出来。书店的例子:进货单文件里某一行读出来不对劲,店主想知道它到底是什么,先印 repr():
>>> line = '三体,59.0,7\n'
>>> print(line)
三体,59.0,7
>>> print(repr(line))
'三体,59.0,7\n'
print(line) 后面多了一个空行,因为字符串末尾的 \n 自己又换了一行;repr(line) 把 \n 原样亮出来,问题一下就清楚了。我的判断是:给人看的日报用 str()、用 f 字符串;查「文件里到底读到了什么」这种问题,用 repr()。官方教程还提了一句:string.Template 是另一种简单的模板写法,用 $x 这样的占位符,控制力弱一些,这里知道有这回事就行。
第四步:open()——四种模式,先分清再动手
文件读写从 open() 开始。官方教程 7.2 节:open() 返回一个文件对象,最常用的写法带两个位置参数,open(filename, mode):
>>> f = open('workfile', 'w')
第一个参数是文件名,第二个是模式字符串。模式一共四种,意思要背下来:'r' 只读,文件不存在会报错;'w' 只写,同名文件已经存在会被清空——这个最危险,下面第九步的图里排第一的就是它;'a' 是追加,写的东西自动加到文件末尾;'r+' 是又读又写。模式参数可以省略,省略就是 'r'。正常情况下文件以文本模式打开,读和写都是字符串,编码默认是 UTF-8;模式里加一个 'b' 就变成二进制模式,读和写都是 bytes 对象,而且不能再指定编码。文本模式读的时候,会把不同系统的换行符(Unix 的 \n、Windows 的 \r\n)统一转成 \n;写的时候再转回去。这个暗地里的转换对文本文件是好事,但会弄坏 JPEG、EXE 这样的二进制数据——读写真照片、程序文件,一定要用二进制模式。
书店的例子:进货单叫 stock.csv,日报叫 daily.txt。读进货单用默认的 'r',写日报用 'w',追加一条新记录用 'a'。第一次写日报的时候,'w' 会新建一个空文件;第二天再用 'w' 写同一份日报,昨天的就没了——想留着昨天的,要么换个文件名,要么用 'a' 往后追加。我的判断是:动手写文件之前,先问自己一句「这个文件里已经有的东西还要不要」——要就用 'a',不要才用 'w';不确定的时候,先用 'r' 读一眼再说。
第五步:with——文件用完一定关上
官方教程的好习惯是:处理文件对象用 with 关键字。好处是,with 里面的代码跑完之后,文件一定会被正确关上,哪怕中间出了异常也一样;而且比自己写等价的 try/finally 短得多:
>>> with open('workfile') as f:
... read_data = f.read()
>>> # We can check that the file has been automatically closed.
>>> f.closed
True
不写 with,就要自己调 f.close() 关文件、立刻释放它占用的系统资源。官方还警告:不写 with、也不调 close(),直接调 f.write(),写的东西可能没有完全写进磁盘,哪怕程序正常退出了也一样。文件关上之后再用它,会直接失败:
>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file.
第四篇讲过 with 是「自带 finally 的简写」,这里是它真正的主场:读文件、写文件,统统用 with open(...) as f。我的判断是:这条不用商量——所有打开文件的代码都写成 with,别给自己留「记得关文件」的记忆负担。第四篇的异常处理规矩在这里不用重讲:with 只管收尾,文件不存在、内容不对这些错,该接的 try 还是要另写。
第六步:读文件的五种办法——整篇读还是一行一行读
文件对象有好几个读的办法,官方教程 7.2.1 节挨个讲了。f.read(size) 读一定量的数据,返回字符串(文本模式)或 bytes(二进制模式);size 不写或者写负数,就把整个文件都读回来——文件比内存还大就麻烦了,那是你的问题;读到文件末尾再读,返回空字符串 '':
>>> f.read()
'This is the entire file.\n'
>>> f.read()
''
f.readline() 一次读一行,行尾的换行符 \n 会留在字符串末尾,只有文件最后一行没有换行符的时候才没有。这样返回值不会含糊:读到空字符串就是读到头了,读到 '\n' 就是碰上了一个空行:
>>> f.readline()
'This is the first line of the file.\n'
>>> f.readline()
'Second line of the file\n'
>>> f.readline()
''
要逐行读一个文件,最好的办法是直接循环文件对象本身:省内存、速度快、代码也简单:
>>> for line in f:
... print(line, end='')
...
This is the first line of the file.
Second line of the file
想把所有行一次拿进一个列表,用 list(f) 或者 f.readlines()。书店的例子:进货单 stock.csv 只有三行,整篇读没问题;但店主的十年流水账有几十万行,整篇读进内存就吃不消了,得一行一行读。下面这段代码用的是临时文件,数字是虚构示例:
with open('stock.csv', encoding='utf-8') as f:
lines = f.readlines()
# lines 是 ['title,price,stock\n', '三体,59.0,7\n', '海底两万里,39.5,12\n', '活着,29.0,5\n']
# 每行末尾都带着 '\n',用 line.strip() 去掉再拆
with open('stock.csv', encoding='utf-8') as f:
for line in f:
title, price, stock = line.strip().split(',')
print(title, float(price), int(stock))
三体 59.0 7
海底两万里 39.5 12
活着 29.0 5
注意一个容易踩的坑:read() 会把读指针推到文件末尾,读完再调一次 read(),拿到的是空字符串 '',不是「再读一遍」。想重读,得先把指针移回去——那是第八步的 seek()。我的判断是:小文件用 read() 或 readlines(),大文件用 for line in f;读一行处理一行,别先把整个文件搬进内存再说。
第七步:写文件——write 返回写了几个字符
f.write(string) 把字符串写进文件,返回写了几个字符:
>>> f.write('This is a test\n')
15
'This is a test\n' 是 14 个字母加一个换行符,一共 15 个字符。写别的东西之前,先转成字符串(文本模式)或 bytes(二进制模式):
>>> value = ('the answer', 42)
>>> s = str(value) # convert the tuple to string
>>> f.write(s)
18
str(('the answer', 42)) 是 "('the answer', 42)",一共 18 个字符。直接 f.write(42) 会报错:write() 只接受字符串。书店的例子:写日报,把算好的数字先拼成一行字再写进去:
total = 59.0 * 7 + 39.5 * 12 + 29.0 * 5 # 1032.0
with open('daily.txt', 'w', encoding='utf-8') as f:
f.write('晨光书店日报\n')
f.write(f'库存总价值:{total:.1f} 元\n')
f.write('在库书种:3 种\n')
三本书的库存总价值是 1032.0 元:59.0 乘 7 是 413.0,39.5 乘 12 是 474.0,29.0 乘 5 是 145.0,加起来 1032.0。注意 write() 不会自动加换行符,想换行就自己在字符串末尾加 \n——print() 会自动换行,write() 不会,这是最容易漏掉的一行。
第八步:tell 和 seek——文件里的指针
文件对象里有个看不见的指针,记录现在读到、写到哪里了。f.tell() 返回指针现在的位置:二进制模式下是离文件开头多少个字节,文本模式下是一个不透明的数字。想移动指针,用 f.seek(offset, whence):位置等于参考点加上偏移量,参考点由 whence 决定——0 是从文件开头算,1 是从当前位置算,2 是从文件末尾算;whence 可以省略,默认是 0。官方例子用二进制模式:
>>> f = open('workfile', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5) # Go to the 6th byte in the file
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # Go to the 3rd byte before the end
13
>>> f.read(1)
b'd'
'rb+' 是又读又写的二进制模式。写进 16 个字节之后,指针移到第 5 个字节(从 0 开始数,第 6 个字节),读一个字节是 b'5';再从文件末尾往前移 3 个字节,位置是 13,读一个字节是 b'd'。文本模式下限制更多:只允许从文件开头算的 seek(除了 seek(0, 2) 移到文件末尾),偏移量也只能用 tell() 返回过的数或者 0,别的数行为未定义。书店的例子:日报写完之后想回到开头再读一遍核对,seek(0) 就够了:
with open('daily.txt', 'w+', encoding='utf-8') as f:
f.write('晨光书店日报\n')
f.seek(0)
first_line = f.readline()
# first_line 是 '晨光书店日报\n'
我的判断是:tell() 和 seek() 不用天天用,但要知道有这回事——第六步那个「读完再读是空的」坑,解法就是 seek(0) 回到开头;平时读文件一行一行往下读,根本不用管指针。
第九步:JSON——把一堆数据整个存下来、整个读回来
字符串写进文件、读出来都很容易;数字麻烦一点,因为 read() 只返回字符串,读回来得再用 int() 转回去;想存嵌套的列表、字典这样更复杂的数据,自己一个个拼、一个个拆就更麻烦了。官方教程 7.2.2 节的办法是 JSON:一种流行的数据交换格式,标准库里的 json 模块能把 Python 的数据层级转成字符串,这个过程叫序列化;再从字符串还原回数据,叫反序列化。中间那个字符串可以存在文件里,也可以发给远处的另一台机器。官方例子:
>>> import json
>>> x = [1, 'simple', 'list']
>>> json.dumps(x)
'[1, "simple", "list"]'
dumps() 是把对象转成 JSON 字符串;还有个 dump(),直接把对象序列化进一个打开写模式的文本文件:
json.dump(x, f)
读回来用 load():
x = json.load(f)
注意 JSON 文件必须用 UTF-8 编码,而这正好是文本文件的默认编码。书店的例子:把整份库存存成 JSON,下次打开脚本直接读回来接着用,不用再一行行拆字符串:
import json
stock = [
{'title': '三体', 'price': 59.0, 'stock': 7},
{'title': '海底两万里', 'price': 39.5, 'stock': 12},
{'title': '活着', 'price': 29.0, 'stock': 5},
]
with open('stock.json', 'w', encoding='utf-8') as f:
json.dump(stock, f, ensure_ascii=False)
with open('stock.json', encoding='utf-8') as f:
loaded = json.load(f)
# loaded 和 stock 一模一样:三本书的书名、单价、库存都在
# json.dumps(stock, ensure_ascii=False) 里能看到中文书名:'[{"title": "三体", ...}]'
ensure_ascii=False 是让中文书名直接以中文写进文件,而不是转成 \u4e09 这样的转义。读回来的 loaded 是列表套字典,数字还是数字,loaded[0]['price'] * loaded[0]['stock'] 直接就是 413.0,不用再转类型。官方教程还提了一句:pickle 模块能序列化任意复杂的 Python 对象,但它只认 Python,而且默认不安全——反序列化不信任来源的数据可能执行任意代码。我的判断是:存数据、换数据,优先用 JSON——别的语言也认得,打开文件人也能看懂;pickle 只在「确定是自己写的、自己读的」时候再考虑。
第十步:CSV——表格文件有专门的读法,以及一张翻车分布图
最后一件工具是表格文件。CSV 是逗号分隔值格式,电子表格和数据库最常用的导入导出格式。Python 标准库的 csv 模块专门读写它:reader 和 writer 读写一行的列表,DictReader 和 DictWriter 按字典读写。官方文档的规矩只有一条,但很重要:打开 CSV 文件对象的时候要传 newline='',否则在 Windows 上每行之间会多出空行。读的例子:
import csv
with open('eggs.csv', newline='') as csvfile:
spamreader = csv.reader(csvfile, delimiter=' ', quotechar='|')
for row in spamreader:
print(', '.join(row))
每行读出来是一个字符串列表,不会自动转类型——价格那一列读出来是 '59.0' 字符串,得自己 float() 转。写的时候也一样,非字符串数据写之前会先被 str() 转掉;None 会被写成空字符串。书店的例子:进货单就是 CSV,带表头,用 DictReader 读、用 DictWriter 写,列名就是字典的键:
import csv
# 读进货单:第一行是表头 title,price,stock
with open('stock.csv', newline='', encoding='utf-8') as f:
reader = csv.DictReader(f)
rows = list(reader)
# rows 是 [{'title': '三体', 'price': '59.0', 'stock': '7'}, ...],共 3 行
# 注意 price 和 stock 读出来是字符串,要转:float('59.0') 是 59.0,int('7') 是 7
# 写进货单:先写表头,再一行行写
with open('stock.csv', 'w', newline='', encoding='utf-8') as f:
writer = csv.DictWriter(f, fieldnames=['title', 'price', 'stock'])
writer.writeheader()
writer.writerow({'title': '三体', 'price': 59.0, 'stock': 7})
writer.writerow({'title': '海底两万里', 'price': 39.5, 'stock': 12})
writer.writerow({'title': '活着', 'price': 29.0, 'stock': 5})
最后把整篇串起来:店主每天的工作流就是三步——读进货单 CSV,算库存总价值,写日报 TXT、再把库存备份成 JSON:
import csv
import json
with open('stock.csv', newline='', encoding='utf-8') as f:
rows = list(csv.DictReader(f))
total = 0.0
for row in rows:
total += float(row['price']) * int(row['stock'])
# total 是 1032.0
with open('daily.txt', 'w', encoding='utf-8') as f:
f.write('晨光书店日报\n')
f.write(f'在库书种:{len(rows)} 种\n')
f.write(f'库存总价值:{total:.1f} 元\n')
with open('stock.json', 'w', encoding='utf-8') as f:
json.dump(rows, f, ensure_ascii=False)
三行进货单,算出来还是 1032.0 元,和第七步手算的一致。注意 json.dump(rows, ...) 存的是 CSV 读出来的字符串版——price 是 '59.0' 字符串不是数字 59.0;想让 JSON 里也是数字,存之前先把每行转好:{'title': row['title'], 'price': float(row['price']), 'stock': int(row['stock'])}。这个小转换,就是第九步说的「CSV 不自动转类型」。
最后是这篇的翻车分布图。示例:虚构晨光书店记账脚本学 Python 第五个月,100 次和文件读写有关的翻车,原因分布如下。图里排第一的错,是用 'w' 打开旧文件,把里面的数据清空了。

回头看这篇的十步,其实只讲了三件事。第一,输出先排好:f 字符串写给人看的账单,format() 留着晚点填,查文件内容用 repr()。第二,文件分清模式再打开:'r' 读、'w' 写(会清空)、'a' 追加、'r+' 又读又写;打开了一律用 with,不用自己记着关。第三,读法按大小挑、存法按用途挑:小文件整篇读,大文件一行一行读;整份数据存 JSON,表格存 CSV,打开 CSV 记得 newline=''。下一篇留给列表推导式和生成器:进货单读进来是一堆字典,挑出「库存不够 10 本的书」这种活,一行推导式就能写完——到时候这篇读出来的行,会直接变成下一篇的原材料。
评论 (0)
原始来源
相关文章
推导式先说要什么,生成器一次只吐一个。本文按 Python 官方教程第 5 章与第 9 章讲清楚:列表、字典、集合推导式,双重 for 与嵌套推导式,* 解包,yield 与生成器函数,生成器表达式,以及列表和生成器怎么选,另附虚构晨光书店记账脚本第六个月 100 次翻车的分布。
异常不是程序坏了,是 Python 在用有名字的办法告诉你哪里出了问题。本文按 Python 官方教程第 8 章讲清楚:语法错误与异常、try/except、except 按继承匹配、哪些错该接哪些不该接、raise、else、finally、with、自定义异常、异常链与 ExceptionGroup,另附虚构晨光书店记账脚本第四个月 100 次翻车的分布。
类是把数据和规矩打包在一起的办法:一个 Book 类做出每本书自己的状态,方法让对象自己干活,继承让电子书站在纸书肩膀上。本文按 Python 官方教程第 9 章讲清楚:class 与 __init__、self、方法、类变量与实例变量、属性查找、继承与覆盖、super()、下划线私有约定、dataclass、__iter__ 与 __next__,另附虚构晨光书店记账脚本第三个月 100 次翻车的分布。