文件处理

# 简介

内存无法永久保存数据, 硬盘可以. 用户对文件进行读写操作, 就是在向操作系统发起调用请求.
操作系统将用户/应用程序对文件的读写操作转换成具体的硬盘指令
这些指令将控制盘片转动、控制机械手臂移动来读写数据

打开一个文件包含两部分资源: 应用程序的变量f和操作系统打开的文件

# -- 操作系统打开文件,返回一个文件对象赋值给变量f
f = open('a.txt','r',encoding='utf-8',errors='ignore')  # -- ignore表示忽略编码错误
# -- 调用文件对象下的读/写方法，会被操作系统转换为读/写硬盘的操作
data=f.read()
# -- 向操作系统发起关闭文件的请求,回收系统资源
#    若不close关闭文件,可能会造成资源泄露!!!
f.close()

注意编码问题:
    open()是由操作系统打开文件,若打开的是"文本文件",会涉及到字符编码问题.
		若open没有指定编码,那么操作系统会用自己的默认编码去打开文件.windows是gbk,linux是utf8!
    若要保证不乱码,文件以什么方式存入硬盘的,就要以什么方式打开!

1
2
3
4
5
6
7
8
9
10
11
12

资源泄漏 是指计算机程序不释放自己已获得的资源, 导致资源被白白浪费

f.close()  # -- 回收操作系统打开的文件资源
del f      # -- 回收应用程序级的变量, 在程序结束的时候

1
2

Tips:
close( )方法用于关闭文件, Python的垃圾回收机制, 会在文件对象f 的引用计数降至零的时候自动关闭文件;
(也就是程序运行结束,命名空间的生命周期结束,引用计数降为0)
So, 在python编程里, 如果忘记关闭文件柄不会造成内存泄露那么危险的结果;
But, 若对文件进行了写操作, 因为缓存机制, 中途发生断电之类事故, 那么缓存的数据将会丢失..
因此, 安全起见, 要养成使用文件后立刻关闭的好习惯!!!文件关闭或缓冲区已满,数据才会同步到磁盘.

# -- with关键字帮我们管理上下文,在执行完子代码块后,with会自动执行f.close()
# -- 可用with同时打开多个文件,用逗号分隔开即可
with open('a.txt','r') as read_f,open('b.txt','w') as write_f:  
    data = read_f.read()
    write_f.write(data)

1
2
3
4
5

文件句柄、文件描述符、上下文管理器这是查阅博客时, 经常看到的名词, linux的学习中接触过文件描述符(若进程拥有1024个文件描述符,该进程就能同时打开1024个文件), 本质就是数字, 文件句柄应该差不多, 上下文管理器暂且放一放, 我们暂时只需要知道, with会自动帮我们关闭文件, 避免资源泄露即可.. 学完面向对象后再深究!!!

# 文件操作模式

模式	含义
r (默认)	只读
w	写入,会覆盖
a	追加
t (默认)	文本模式
b	二进制

# 文件内容模式 r w a

r (默认):只读 w :只写 a:只追加写

r: 只读模式
只能读,不能写
在文件不存在时,会报错,在文件存在的时候会将文件指针移动到开头

with open('a.txt',mode='r',encoding='utf-8') as f:
    res=f.read()

1
2

w: 只写模式
只能写,不能读
在文件不存在时会创建空文件,文件存在会清空文件,文件指针跑到文件开头

with open('b.txt',mode='w',encoding='utf-8') as f:
    f.write('Hello\n')
    f.write('World\n')

1
2
3

a: 只追加写模式
只能写,不能读
在文件不存在时会创建空文件,文件存在会将文件指针直接移动到文件末尾

with open('b.txt',mode='a',encoding='utf-8') as f:
    f.write('egon\n')
    f.write('yyds\n')

1
2
3

强调 w 模式与 a 模式的异同:
1> 相同点: 在打开的文件不关闭的情况下, 连续的写入, 新写的内容总会跟在前写的内容之后
2> 不同点: 重新打开文件. a模式不会清空原文件内容, w模式会！

我们通常只使用r/w/a, 要么只读, 要么只写; 一般不用可读可写的模式r+/w+/a+ . 遇到了也不怕, 现学呗!

# 文件读写模式 t b

大前提: tb模式均不能单独使用, 必须与r/w/a之一结合使用
只有文本文件才能用t模式, 也只有 文本文件才有字符编码的概念

t (默认的) : 文本模式
○ 读写文件都是以 字符串 为单位的
○ 只能针对文本文件
○ 必须指定 encoding参数

# -- t模式:如果我们指定的文件打开模式为r/w/a, 其实默认就是rt/wt/at
with open('a.txt', mode='rt', encoding='utf-8') as f:
    res = f.read()
    print(type(res)) # -- 输出结果为: <class 'str'>

with open('a.txt', mode='wt', encoding='utf-8') as f:
    s = 'abc'
    f.write(s) # -- 写入的也必须是字符串类型

# -- 强调: t模式只能用于操作文本文件,无论读写,都应该以字符串为单位
#         而存取硬盘本质都是二进制的形式,当指定t模式时,内部帮我们做了编码与解码

1
2
3
4
5
6
7
8
9
10
11

b : 二进制模式一种通用的文件读取模式, 因为所有的文件在硬盘中都是以二进制形式存放的
○ 读写文件都是以bytes/二进制为单位的
○ 可以针对所有文件
○ 一定 不能指定 encoding参数

# -- b模式:读写都是以二进制位单位
with open('1.mp4', mode='rb') as f:
    data = f.read()
    print(type(data))  # -- 输出结果为：<class 'bytes'>

with open('a.txt', mode='wb') as f:
    msg = "你好"
    res = msg.encode('utf-8')  # -- res为bytes类型
    f.write(res)  # -- 在b模式下写入文件的只能是bytes类型

1
2
3
4
5
6
7
8
9

强调: b模式对比t模式
1> 在操作纯文本文件方面 t模式帮我们省去了编码与解码的环节,b模式则需要手动编码与解码
2> 针对非文本文件( 如图片、视频、音频等) 只能使用b模式

# 练习: 拷贝工具

src_file = input('源文件路径: ').strip()
dst_file = input('目标文件路径: ').strip()
with open(r'%s' % src_file, mode='rb') as read_f, open(r'%s' % dst_file, mode='wb') as write_f:
    for line in read_f:
        # print(line)
        write_f.write(line)

1
2
3
4
5
6

# 操作文件的方法

# 读 read

○ f.read([size=-1])
     从文件中读取size个字符的数据;
     若未指定size或给定为负值时,读取剩余的所有内容,执行完该操作后, 文件指针会移动到文件末尾;
注意: 指定size后, 若是 rt模式 读取的是指定 数据/字符的长度 . 若是 rb模式 读取的是 字节数 !!
在utf-8编码下, 一个汉子占用三个字节, 一个字母和数字占用一个字节!!!
○ f.readline([size=-1])
     读取一行内容(包括换行符), 光标移动到第二行首部;
     若指定了size, 返回size个字符
○ f.readlines()    读取每一行内容, 存放于列表中
○ 直接 list(f)、直接迭代读取.

再次强调: 只有在t模式下的read(n),n代表的是字符个数; 除此之外但凡涉及文件指针的移动都是以字节为单位

"""train.txt(utf-8编码)的内容如下:
ab哈哈
b
z
"""
with open('train.txt', 'rt', encoding='utf-8') as f:
    res_len = f.read(5)  # -- 读取的是指定长度的数据/字符(/n换行符、一个字母、一个汉字都算作一个字符)

print(res_len, type(res))  # -- ab哈哈/n  <class 'str'>

# --- --- ---

with open('train.txt', 'rb') as f:
    res = f.read(9)  # -- 读取的是Bytes字节数 分析:ab哈哈\n 1+1+3+3+1=9

# -- b'ab\xe5\x93\x88\xe5\x93\x88\n' <class 'bytes'> ab哈哈\n
print(res, type(res), res.decode('utf-8'))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

强调: f.read() 与 f.readlines() 都是将内容一次性读入内容, 如果内容过大会导致内存溢出.
若还想将内容全读入内存，则必须分多次读入

# -- 方式一
with open('a.txt', mode='rt', encoding='utf-8') as f:
    for line in f:
        print(line)  # -- 同一时刻只读入一行内容到内存中

# -- 方式二
with open('1.mp4', mode='rb') as f:
    while True:
        data = f.read(1024)  # -- 同一时刻只读入1024个Bytes到内存中
        if len(data) == 0:
            break
        print(data)  # -- yield data

1
2
3
4
5
6
7
8
9
10
11
12

# 写 write

f.write('1111\n222\n')  # -- 针对文本模式的写,需要自己写换行符
f.write('1111\n222\n'.encode('utf-8'))  # -- 针对b模式的写,需要自己写换行符
f.writelines(['333\n', '444\n'])  # -- 文件模式,写入多行数据
f.writelines([bytes('333\n', encoding='utf-8'), '444\n'.encode('utf-8')])  # -- b模式,写入多行

1
2
3
4

# 其他(了解)

f.readable()  # -- 文件是否可读
f.writable()  # -- 文件是否可读
f.closed      # -- 文件是否关闭
f.encoding    # -- 文件编码,如果文件打开模式为b,则没有该属性
f.flush()     # -- 立刻将文件内容从内存刷到硬盘
f.name        # -- 文件名字

1
2
3
4
5
6

# 控制文件指针

上述文件内指针的移动都是由读/写操作而被动触发的, 若想读取文件某一特定位置的数据
则需要用 f.seek 方法主动控制文件内指针的移动

f.seek(offset,whence)
offset: 指针移动的字节数, 注意单位是字节bytes whence: 模式控制, 有三个取值
0: 默认的模式,该模式代表指针移动的字节数是以 文件开头 为参照的
1: 该模式代表指针移动的字节数是以 当前所在的位置 为参照的
2: 该模式代表指针移动的字节数是以 文件末尾的位置 为参照的
其中0模式可以在t或者b模式使用, 而1跟2模式只能在b模式下用

# -- a.txt用utf-8编码,内容如下 (abc各占1个字节,中文"你"、"好"各占3个字节)
abc你好

1
2

# 0模式

with open('a.txt', mode='rt', encoding='utf-8') as f:
    f.seek(3, 0)     # -- 参照文件开头移动了3个字节 简单理解前3个字节数据不考虑啦.
    print(f.tell())  # -- 查看当前文件指针距离文件开头的位置,输出结果为3 
    print(f.read())  # -- 从第4个字节开始读到文件末尾,输出结果为: 你好
    # 注意:由于在t模式下,会将读取的内容自动解码,所以必须保证读取的内容是一个完整中文数据,否则解码失败

with open('a.txt', mode='rb') as f:
    f.seek(6, 0)
    print(f.read().decode('utf-8'))  # -- 输出结果为: 好

1
2
3
4
5
6
7
8
9

# 1模式

with open('a.txt', mode='rb') as f:
    f.seek(3, 1)     # -- 从当前位置往后移动3个字节,而此时的当前位置就是文件开头
    print(f.tell())  # -- 输出结果为:3
    f.seek(4, 1)     # -- 从当前位置往后移动4个字节,而此时的当前位置为3
    print(f.tell())  # -- 输出结果为:7

1
2
3
4
5

# 2模式

with open('a.txt', mode='rb') as f:
    f.seek(0, 2)     # -- 参照文件末尾移动0个字节,即直接跳到文件末尾
    print(f.tell())  # -- 输出结果为:9
    f.seek(-3, 2)    # -- 参照文件末尾往前移动了3个字节
    print(f.read().decode('utf-8'))  # -- 输出结果为:好


# -- 小练习:实现动态查看最新一条日志的效果
import time
with open('access.log', mode='rb') as f:
    f.seek(0, 2)
    while True:
        line = f.readline()
        if len(line) == 0:  # -- 若无新增内容,睡0.5秒后再次进入循环.
            time.sleep(0.5)
        else:
            print(line.decode('utf-8'), end='')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 修改文件

硬盘空间是无法修改的,硬盘中数据的更新都是用新内容覆盖旧内容!
内存中的数据是可以修改的!

# 修改方式一

实现思路: 将文件内容发一次性全部读入内存, 然后在内存中修改完毕后再覆盖写回原文件
优点: 在文件修改过程中同一份数据只有一份
缺点: 会过多地占用内存

with open('db.txt', mode='rt', encoding='utf-8') as f:
    data = f.read()

with open('db.txt', mode='wt', encoding='utf-8') as f:
    f.write(data.replace('kevin', 'SB'))

1
2
3
4
5

# 修改方式二

实现思路:
     以读的方式打开原文件,以写的方式打开一个临时的新文件
     从原文件中循环读取每一行内容,修改完后写入临时文件
     删掉原文件,将临时文件重命名为原文件名的名字
优点: 不会占用过多的内存, 同一时刻只有一行内容存在于内存中
缺点: 在修改期间,文件内容始终存在两份,但修改完毕后会只留一份

import os

with open('db.txt',mode='rt',encoding='utf-8') as read_f,\
        open('.db.txt.swap',mode='wt',encoding='utf-8') as wrife_f:
    for line in read_f:
        wrife_f.write(line.replace('AB', 'Hhh'))

os.remove('db.txt')  # -- 删除原文件
os.rename('.db.txt.swap', 'db.txt')  # -- 临时文件重新命名为原文件的名字

1
2
3
4
5
6
7
8
9

← 函数进阶必用模块→