文件操作
1 文件
1.1 文件的定义:
文件是操作系统提供给用户(人和应用软件)的一种用来操作硬盘的接口(虚拟概念)
1.2 文件的作用:
用户可以通过文件将数据永久存储,并不会断电就丢失(存入硬盘).
用户/应用程序直接操作的是文件，对文件进行的所有的操作，都是
在向操作系统发送系统调用，然后再由操作将其转换成具体的硬盘操作
操作文件最终通过操作系统其实是操作了硬盘
1.3 如何用文件：
使用open()方法
f = open("a.txt",mode="rt",encoding="utf-8")
# 指定文件路径+文件名,模式,如果是t模式还要输入编码类型
f.read()
f.close()
1.3.1控制文件读写内容的模式：
控制文件读写内容的模式可以分为:t和b
t为text的意思,即文本模式
b为binary的意思,即二进制模式
b模式相对更通用,原始
t模式是以b模式为基础开发的
强调：t和b不能单独使用，必须跟r/w/a连用
1.3.1.1 t模式,文本模式（默认的模式）
1、读写都以str（unicode）为单位的
2、文本文件
3、必须指定encoding='utf-8'
1.3.1.2 b模式,二进制/bytes模式
1、b模式能对所有类型的文件进行操作,包括text,图片,视频等
2、b模式读写都以字节(bytes)为单位,1个字节等于8位二进制
3、不允许指定encoding参数,即字符编码,否则报错
with open(r'd.txt', mode='rb') as f:
res = f.read() # utf-8的二进制
print(res, type(res))
# b'xe5x93x88xe5x93x88xe5x93x88a' <class 'bytes'>
print(res.decode('utf-8'))
# 哈哈哈a
with open(r'd.txt', mode='rt', encoding='utf-8') as f:
res = f.read() # utf-8的二进制->unicode
print(res)
# 哈哈哈a
1.3.1.3 总结：
1、在操作纯文本文件方面t模式帮我们省去了编码与解码的环节，
b模式则需要手动编码与解码，所以此时t模式更为方便
2、针对非文本文件（如图片、视频、音频等）只能使用b模式
1.3.2控制文件读写操作的模式
读写操作模式包括:
r只读模式
w只写模式
a只追加写模式
+模式：r+、w+、a+
x模式:只写的一种特殊模式
U模式:已废弃
2. 文件基本操作流程
2.1 打开文件
打开文件涉及到两部分的空间开辟:
第一部分为应用程序python为变量f开辟的内存空间,
第二部分为操作系统为文件aaa.txt保留的内存空间
windows路径分隔符问题:
如open('C:a.txt bcd.txt')中 等特殊组合可能会导致路径错误
解决方案一：(推荐)
在字符串前加上r
open(r'C:a.txt bcd.txt')
解决方案二：
使用/斜杠替换反斜杠
open('C:/a.txt/nb/c/d.txt')
f = open(r'aaa.txt', mode='rt') # f的值是一种变量，占用的是应用程序的内存空间
print(f)
# <_io.TextIOWrapper name='aaa.txt' mode='rt' encoding='cp936'>
上面代码中的f可以称为文件对象也可以称为文件句柄,我们可以使用这个文件句柄进行对应的操作
2.2 操作文件
读/写文件，应用程序对文件的读写请求都是应用程序在向操作系统发送
系统调用，然后由操作系统控制硬盘把输入读入内存、或者写入硬盘
f = open(r'aaa.txt', mode='rt')
res=f.read()
print(type(res))
# <class 'str'>
print(res)
# 文件中的所有数据
2.3 关闭文件
关闭文件的原因:
文件打开产生了python中变量f的内存空间和操作系统中aaa.txt的内存空间
操作系统为文件保留了内存空间,操作系统的空间是有限的,如果长时间白白占用资源会对操作系统的速度,内存空间产生影响,所以需要关闭文件
f = open(r'aaa.txt', mode='rt')
res=f.read()
f.close() # 回收操作系统资源
print(f) # f变量还存在
# <_io.TextIOWrapper name='D:\工具\python\python代码练习\day11\aaa.txt' mode='rt' encoding='cp936'>
f.read() # 变量f存在，但是不能再读了
del f # 回收应用程序资源,但一般我们不需要作出这个操作,因为有垃圾回收机制
2.4 with上下文管理
2.3中提到了,我们打开文件使用完毕后要关闭文件,但是这一步骤容易遗漏,这时我们能使用with管理上下文,防止出现忘记关闭文件的情况
当我们使用with打开文件时会在with的缩进代码执行完毕后自动关闭打开的文件
with open('a.txt', mode='rt') as f1: # f1=open('a.txt',mode='rt')
res = f1.read()
print(res)
with open('a.txt', mode='rt') as f1,
open('b.txt', mode='rt') as f2:
res1 = f1.read()
res2 = f2.read()
print(res1)
print(res2)
3. 文件操作具体方法
文件操作的按读写内容不同,可以分为t和b两种
其中t代表文本文件,即全为字符串的内容
而b代表bytes类型,可以用于存储图片,视频等内容
强调：t和b不能单独使用，必须跟r/w/a连用
在代码中不指定读写内容分类默认文件为文本文件,即t模式
之前在字符编码中提到,在内存中,字符串类型都用unicode类型显示,
也就是说我们在pycharm中看到的所有字符串本质上都是Unicode
打开文件时,操作系统需要指定将文件转入内存中,而内存中要使用unicode的形式,
如果一个文件存到硬盘时使用的是gbk,我们就应该使用GBK-unicode对应解码
如果一个文件存到硬盘时使用的是utf-8,我们就应该使用utf-8-unicode对应解码
当我们不指定解码方式时,操作系统会把文件按自己的默认编码转换成unicode
linux系统默认utf-8,
windows系统默认gbk,
os系统默认utf-8
with open('c.txt',mode='rt',encoding='utf-8') as f:
res=f.read() # t模式会将f.read()读出的结果解码成unicode
print(res,type(res))
# 哈哈 <class 'str'>
# (str就是unicode)
# 内存：utf-8格式的二进制-----解码----->unicode
# 硬盘（c.txt内容：utf-8格式的二进制）
以t模式为例进行内存操作
3.1、r（默认的操作模式）：
只读模式，当文件不存在时报错，当文件存在时文件指针跳到开始位置
硬盘的二进制读入内存--------->t模式会将读入内存的内容进行decode解码操作
b'xe5x93x88xe5x93x88xe5x93x88a' <class 'bytes'>----------------哈哈哈a
硬盘的二进制读入内存--------->b模式下，不做任何转换，直接读入内存
b'xe5x93x88xe5x93x88xe5x93x88a' <class 'bytes'>
with open('c.txt',mode='rt',encoding='utf-8') as f:
print('第一次读'.center(50,'*'))
res=f.read() # 把所有内容从硬盘读入内存
print(res)
with open('c.txt', mode='rt', encoding='utf-8') as f:
print('第二次读'.center(50,'*'))
res1=f.read()
print(res1)
两次内容相同
# ===============案例==================
inp_username = input('your name>>: ').strip()
inp_password = input('your password>>: ').strip()
# 验证账号密码
with open('user.txt', mode='rt', encoding='utf-8') as f:
for line in f:
print(line, end='') # egon:123
username, password = line.strip().split(':')
if inp_username == username and inp_password == password:
print('login successfull')
break
else:
print('账号或密码错误')
应用程序>文件
应用程序>数据库管理软件=====>文件
循环读取文件
方式一：自己控制每次读取的数据的数据量
注意: read()不再以字节为单位,而是以字符为单位
换行符也算一个字符
with open(r'b.txt', mode='rt',encoding="utf-8") as f:
while True:
res = f.read(10)
if len(res) == 0:
break
print("{}------长度为{}".format(res,len(res)))
# aaaa吴
# bbbb------长度为10
# b吴
# ------长度为3
方式二：以行为单位读，当一行内容过长时会导致一次性读入内容的数据量过大
with open(r'b.txt', mode='rt', encoding='utf-8') as f:
for line in f:
print(len(line), line)
3.2、w只写模式:
当文件不存在时会创建空文件，
当文件存在会清空文件，指针位于开始位置
with open('d.txt',mode='wt',encoding='utf-8') as f:
f.read() # 报错，不可读
f.write('哈哈哈
')
强调1：
在以w模式打开文件没有关闭的情况下，连续写入，新的内容总是跟在旧的之后
with open('d.txt',mode='wt',encoding='utf-8') as f:
f.write('擦勒1
')
f.write('擦勒2
')
f.write('擦勒3
')
# 结果为:
# 擦勒1
# 擦勒2
# 擦勒3
#
强调2：
如果重新以w模式打开文件，则会清空文件内容
with open('d.txt',mode='wt',encoding='utf-8') as f:
f.write('擦勒1
')
with open('d.txt',mode='wt',encoding='utf-8') as f:
f.write('擦勒2
')
with open('d.txt',mode='wt',encoding='utf-8') as f:
f.write('擦勒3
')
# 结果为:
# 擦勒3
#
案例：w模式用来创建全新的文件
文件文件的copy工具
src_file=input('源文件路径>>: ').strip()
dst_file=input('拷贝文件路径>>: ').strip()
with open(r'{}'.format(src_file),mode='rt',encoding='utf-8') as f1,
open(r'{}'.format(dst_file),mode='wt',encoding='utf-8') as f2:
res=f1.read()
f2.write(res)
3.3、a只追加写：
在文件不存在时会创建空文档，在文件存在时文件指针会直接调到末尾
with open('e.txt',mode='at',encoding='utf-8') as f:
# f.read() # 报错，不能读
f.write('擦嘞1
')
f.write('擦嘞2
')
f.write('擦嘞3
')
# 结果为:
# 擦勒1
# 擦勒2
# 擦勒3
#
案例：a模式用来在原有的文件内存的基础之上写入新的内容，比如记录日志、注册
# 注册功能
name=input('your name>>: ')
pwd=input('your name>>: ')
with open('db.txt',mode='at',encoding='utf-8') as f:
f.write('{}:{}
'.format(name,pwd))
3.4、 w 模式与 a 模式的异同：
1 相同点：在打开的文件不关闭的情况下，连续的写入，新写的内容总会跟在前写的内容之后
2 不同点：以 a 模式重新打开文件，不会清空原文件内容，会将文件指针直接移动到文件末尾，新写的内容永远写在最后
3.5、 了解：r+, w+, a+
+不能单独使用，必须配合r、w、a
r+ 有r的特性:不能创建文件,指针初始位置在开头,进行写操作时为覆盖
w+有w的特性:清空文件
a+有a的特性:光标在末尾
with open('g.txt',mode='rt+',encoding='utf-8') as f:
# print(f.read())
f.write('中国')
with open('g.txt',mode='w+t',encoding='utf-8') as f:
f.write('111
')
f.write('222
')
f.write('333
')
print('====>',f.read())
with open('g.txt',mode='a+t',encoding='utf-8') as f:
print(f.read())
f.write('444
')
f.write('5555
')
print(f.read())
3.6、 了解：x模式
x模式同样为只写模式,进行读操作会报错
它有一个的特性:文件不存在时写操作会创建文件,文件存在时会报错
with open('a.txt',mode='x',encoding='utf-8') as f:
pass
# 执行第一次创建了a.txt文件
with open('a.txt',mode='x',encoding='utf-8') as f:
pass
# 执行第二次报错
# FileExistsError: [Errno 17] File exists: 'a.txt'
with open('a.txt',mode='x',encoding='utf-8') as f:
f.read()
# io.UnsupportedOperation: not readable
3.7、 其他操作方法
3.7.1 读相关
readline：一次读一行
with open(r'g.txt', mode='rt', encoding='utf-8') as f:
res1 = f.readline()
print(res1)
res2 = f.readline()
print(res2)
while True:
line = f.readline()
if len(line) == 0:
break
print(line)
readlines:
将文件内数据一次读入内存,按行分割放入列表
注意: f.read()与f.readlines()都是将内容一次性读入内存，如果内容过大会导致内存溢出,不推荐使用
with open(r'g.txt', mode='rt', encoding='utf-8') as f:
res = f.readlines()
print(res)
# ['111
', '222
', '333
', '444
', '5555']
3.7.2 写相关
writelines:将一个可迭代对象中的元素for循环分次写入
注意: 是分次写入,不是分行写入,不会自动产生换行符
with open('h.txt',mode='wt',encoding='utf-8') as f:
l=['11111
','2222','3333']
# 相当于for循环写入
# for line in l:
# f.write(line)
f.writelines(l)
# 文件内内容: 11111
# 22223333
3.7.3 flush
flush---------冲(抽水马桶)
文件内容并非程序运行中马上写入,而是攒到一定量写入一次,
flush的作用便像是冲了一下抽水马桶,不再积攒,直接将数据写入
with open('h.txt', mode='wt',encoding='utf-8') as f:
f.write('哈')
f.flush()
3.7.4 其他了解方法
readable---------返回文件是否可读的布尔值
writable---------返回文件是否可写的布尔值
encoding---------返回打开文件使用的编码格式
name---------返回文件的名字
closed---------返回文件是否已关闭的布尔值
以b模式为例进行内存操作
3.8、rb模式：
不允许输入encoding参数,即编码类型
with open(r'test.jpg', mode='rb', encoding='utf-8') as f:
res = f.read() # 硬盘的二进制读入内存—>b模式下，不做任何转换，直接读入内存
print(res) # bytes类型—》当成二进制
print(type(res))
# ValueError: binary mode doesn't take an encoding argument
对于文本文件说,rb与rt对比时比rt少了decode的过程
with open(r'd.txt', mode='rb') as f:
res = f.read() # utf-8的二进制
print(res, type(res))
# b'xe5x93x88xe5x93x88xe5x93x88a' <class 'bytes'>
print(res.decode('utf-8'))
# 哈哈哈a
with open(r'd.txt', mode='rt', encoding='utf-8') as f:
res = f.read() # utf-8的二进制->unicode
print(res)
# 哈哈哈a
循环读取文件
方式一：自己控制每次读取的数据的数据量:
注意: read()以字节为单位
注意: 换行符为 ,算为2个字节,可拆分
注意: 中文字符算作3个字节,可拆分
with open(r'b.txt', mode='rb') as f:
while True:
res = f.read(8)
if len(res) == 0:
break
print("{}------长度为{}".format(res,len(res)))
# b'aaaaxe5x90xb4
'------长度为8
# b'
'------长度为3
方式二：以行为单位读，当一行内容过长时会导致一次性读入内容的数据量过大
with open(r'b.txt', mode='rb') as f:
for line in f:
print(line)
3.9、wb模式：
with open(r'e.txt', mode='wb') as f:
f.write('你好hello'.encode('gbk'))
# 创建了e.txt文件,内容为GBK编码的'你好hello'
with open(r'f.txt', mode='wb') as f:
f.write('你好hello'.encode('utf-8'))
f.write('哈哈哈'.encode('gbk'))
# 创建了f.txt文件,内容为utf-8编码的'你好hello'+内容为GBK编码的'哈哈哈'
# 不要进行这样的操作
如果想以二进制模式写入字符串,需要将字符串编码,转换成bytes类型,即二进制类型
补充：如果是字符串是纯英文+数字组成的，可以直接加前缀b得到bytes类型
b'1111aaa1 '
补充：'上'.encode('utf-8') == bytes('上',encoding='utf-8')
with open('h.txt', mode='wb') as f:
l = [
b'1111aaa1
',
bytes('上啊',encoding='utf-8'),
bytes('冲呀',encoding='utf-8'),
bytes('小垃圾们',encoding='utf-8'),
]
f.writelines(l)
# 1111aaa1
# 上啊冲呀小垃圾们
3.10、文件中指针的移动：
指针移动的单位都是以bytes/字节为单位
只有一种情况特殊：
t模式下的read(n),n代表的是字符个数
f.seek(n,模式):
n指的是移动的字节个数
模式有3种: 0 , 1 , 2
3.10.1 模式0
模式0：参照物是文件开头位置
f.seek(9,0) # 0--->9
f.seek(3,0) # 0--->3
3.10.2 模式1
模式1：参照物是当前指针所在位置
f.seek(9,1) # 0------>9
f.seek(3,1) # 9------>12
3.10.3 模式2
模式2：参照物是文件末尾位置，应该倒着移动
f.seek(-9,2) # 结尾:12------>3
f.seek(-3,2) # 结尾:12------>9
强调：只有0模式可以在t下使用，1、2必须在b模式下用
3.10.4 指针位置
f.tell()
# 获取文件指针当前位置
3.10.5 指针应用实例
用文件处理实现tail-f功能
动态显示文件内的新增行的内容
import time
with open('access.log', mode='rb') as f:
# 1、将指针跳到文件末尾
f.seek(0, 2)
while True:
line = f.readline()
if len(line) == 0:
time.sleep(0.3)
else:
print(line.decode('utf-8'), end='')
4 文件修改
我们使用指针与写功能组合时会产生覆盖的问题,所以不能直接通过这种方法修改文件
with open('a.txt',mode='r+t',encoding='utf-8') as f:
f.seek(9,0)
f.write('<男妇女主任>')
文件修改一般有两种方式
4.1 方式一：
文本编辑采用的就是这种方式
实现思路：将文件内容发一次性全部读入内存,然后在内存中修改完毕后再覆盖写回原文件
优点: 在文件修改过程中同一份数据只有一份
缺点: 会过多地占用内存
with open('c.txt',mode='rt',encoding='utf-8') as f:
res=f.read()
data=res.replace('alex','dsb')
print(data)
with open('c.txt',mode='wt',encoding='utf-8') as f1:
f1.write(data)
4.2 方式二：
开发过程中一般使用的方法
实现思路：以读的方式打开原文件,以写的方式打开一个临时文件,一行行地读取,并修改，改完后写入临时文件，逐行执行,最终删掉原文件,并将临时文件重命名原文件名
优点: 不会占用过多的内存
缺点: 在文件修改过程中同一份数据存了两份
import os
with open('c.txt', mode='rt', encoding='utf-8') as f,
open('.c.txt.swap', mode='wt', encoding='utf-8') as f1:
for line in f:
f1.write(line.replace('alex', 'dsb'))
os.remove('c.txt')
os.rename('.c.txt.swap', 'c.txt')
f = open('a.txt')
res = f.read()
print(res)