文件操作

目录

• 文件操作
  • 1 文件
    • 1.1 文件的定义:
    • 1.2 文件的作用:
    • 1.3 如何用文件：
      • 1.3.1控制文件读写内容的模式：
        • 1.3.1.1 t模式,文本模式（默认的模式）
        • 1.3.1.2 b模式,二进制/bytes模式
        • 1.3.1.3 总结：
      • 1.3.2控制文件读写操作的模式
  • 2. 文件基本操作流程
    • 2.1 打开文件
      • windows路径分隔符问题:
        • 解决方案一：(推荐)
        • 解决方案二：
    • 2.2 操作文件
    • 2.3 关闭文件
      • 关闭文件的原因:
    • 2.4 with上下文管理
  • 3. 文件操作具体方法
    • 以t模式为例进行内存操作
    • 3.1、r（默认的操作模式）：
      • 循环读取文件
    • 3.2、w只写模式:
    • 3.3、a只追加写：
    • 3.4、 w 模式与 a 模式的异同：
    • 3.5、 了解：r+, w+, a+
    • 3.6、 了解：x模式
    • 3.7、 其他操作方法
      • 3.7.1 读相关
      • 3.7.2 写相关
      • 3.7.3 flush
      • 3.7.4 其他了解方法
    • 以b模式为例进行内存操作
    • 3.8、rb模式：
      • 循环读取文件
    • 3.9、wb模式：
    • 3.10、文件中指针的移动：
      • 3.10.1 模式0
      • 3.10.2 模式1
      • 3.10.3 模式2
      • 3.10.4 指针位置
      • 3.10.5 指针应用实例
  • 4 文件修改
    • 4.1 方式一：
    • 4.2 方式二：

文件操作

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'\xe5\x93\x88\xe5\x93\x88\xe5\x93\x88a' <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\nb\c\d.txt')中\n等特殊组合可能会导致路径错误

解决方案一：(推荐)

在字符串前加上r

open(r'C:\a.txt\nb\c\d.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'\xe5\x93\x88\xe5\x93\x88\xe5\x93\x88a' <class 'bytes'>----------------哈哈哈a

硬盘的二进制读入内存--------->b模式下，不做任何转换，直接读入内存

b'\xe5\x93\x88\xe5\x93\x88\xe5\x93\x88a' <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\n
        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('哈哈哈\n')

强调1：
在以w模式打开文件没有关闭的情况下，连续写入，新的内容总是跟在旧的之后

with open('d.txt',mode='wt',encoding='utf-8') as f:
    f.write('擦勒1\n')
    f.write('擦勒2\n')
    f.write('擦勒3\n')
# 结果为:
# 擦勒1
# 擦勒2
# 擦勒3
# 

强调2：
如果重新以w模式打开文件，则会清空文件内容

with open('d.txt',mode='wt',encoding='utf-8') as f:
    f.write('擦勒1\n')
with open('d.txt',mode='wt',encoding='utf-8') as f:
    f.write('擦勒2\n')
with open('d.txt',mode='wt',encoding='utf-8') as f:
    f.write('擦勒3\n')
# 结果为:
# 擦勒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\n')
    f.write('擦嘞2\n')
    f.write('擦嘞3\n')
# 结果为:
# 擦勒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('{}:{}\n'.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\n')
    f.write('222\n')
    f.write('333\n')
    print('====>',f.read())


with open('g.txt',mode='a+t',encoding='utf-8') as f:
    print(f.read())
    f.write('444\n')
    f.write('5555\n')
    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\n', '222\n', '333\n', '444\n', '5555']

3.7.2 写相关

writelines:将一个可迭代对象中的元素for循环分次写入

注意: 是分次写入,不是分行写入,不会自动产生换行符

with open('h.txt',mode='wt',encoding='utf-8') as f:
    l=['11111\n','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'\xe5\x93\x88\xe5\x93\x88\xe5\x93\x88a' <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()以字节为单位

注意: 换行符为\r\n,算为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'aaaa\xe5\x90\xb4\r'------长度为8
# b'\n\r\n'------长度为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\n'

补充：'上'.encode('utf-8') == bytes('上',encoding='utf-8')

with open('h.txt', mode='wb') as f:
	l = [
        b'1111aaa1\n',
	    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)