python高级之(五) --- 文件操作

关注

转载最新推荐文章于 2026-06-14 12:59:05 发布 219 阅读 AI 写同款· GEO 优化 ›

文件操作

 1 """
 2 在程序中操作的文件内容：
 3     1. 读取文件中的内容
 4     2. 向文件中写入内容
 5 
 6 首先：
 7     在程序中与文件建立一个通道，通过通道操作文件指针，达到所要的结果
 8     向文件中不管读和写，在程序中都需要打开一个文件
 9 
10 文件打开方式：open()。会返回一个操作文件的手柄，可以理解为程序与文件之间建立的通道
11     handle = open(文件的路径，打开文件的模式--读、写，encoding="操作的文件到的编码方式")
12 详解：
13     1。文件路径既可以使用相对路径，也可以使用绝对路径
14     2。打开方式：
15         r --- 只读，如果指定路径对应文件不存在，回报错
16         w --- 只写，如果文件不存在，会创建新文件，如果文件存在 会清空文件中原来的内容 文件指针位于0处
17         a --- 只写，如果文件不存在，会创建新文件，如果存在 不会清空原文件的内容 文件指针位于文件的末尾
18 
19         r/w/a 这种模式，操作的字符串数据
20         rb/wb/ab  这种模式操作的是字节数据
21         r+/w+/rb+/wb+/ab+ 带有 + 号的是可读可写
22     3。编码方式：
23         urg-8/gbk
24 注意：程序无法处理程序之外产生的垃圾。需要手动处理垃圾（手动把通道关闭）
25 　　　如果是字节模式处理数据打开文件时，不需要设置编码方式，否则会报错
26 """

文件读取

 1 #  文件读取
 2 """
 3 读取文件内容，是通过文件手柄来完成的
 4 读取的方式：
 5     read([size])
 6         如果不为size设值，默认是将文件中的内容全部读取
 7         如果设置size值：若文件中所剩内容小于size，文件剩多少读多少
 8             模式设置为"r", 表示读取size个字符
 9             模式设置为"rb", 表示读取size个字节
10     readling()
11         一行一行读取
12             模式设置为"r", 表示读取的是一行的字符串数据
13             模式设置为"rb", 表示读取是一行的字节数据
14     readlines()
15         按照行的样式，将文件中所有的数据读出。结果是列表类型的，一行为一个元素存放在列表中
16             模式设置为"r", 列表中的每个元素是字符串类型
17             模式设置为"rb", 列表中每个元素是字节数据类型的 
18 """

read()

 1 # read()。以 r 的形式 读取数据
 2 
 3 # 设置操作文件的路径
 4 path = r"静夜思.txt"
 5 # 在程序中打开文件，建立文件与程序的通道。 以字符型数据读取
 6 handle = open(path,"r",encoding="utf-8")
 7 
 8 # 通过手柄操作文件指针，读取数据
 9 data_str = handle.read()
10 print(data_str)
11 
12 # 设置读取大小时，读取部分之后 文件指针到了3的位置，再读的话从第4位置开始读取
13 data_string = handle.read(3)
14 print(data_string) # 结果：窗前名
15 
16 # 关闭通道
17 handle.close()
18 
19 # ------------------------------------------------------------------ #
20 
21 # read()。以 rb 的形式 读取数据
22 
23 # 设置操作文件的路径
24 path = r"静夜思.txt"
25 # 在程序中打开文件，建立文件与程序的通道。 以字节型数据读取
26 handle = open(path,"rb")
27 
28 # 以rb形式进行读取
29 data = handle.read(3)
30 print(data)
31 print(data.decode(encoding="utf-8"))
32 
33 # 关闭通道
34 handle.close()

readline()

 1 # readline()。以 r 的形式读取一行数据
 2 
 3 # 设置操作文件的路径
 4 path = r"静夜思.txt"
 5 # 在程序中打开文件，建立文件与程序的通道。 以字符型数据读取
 6 handle = open(path,"r",encoding="utf-8")
 7 
 8 # 通过手柄操作文件指针，读取数据
 9 data_str = handle.readline()
10 print(data_str)
11 
12 # 关闭通道
13 handle.close()
14 
15 # ------------------------------------------------------------------------ #
16 
17 # readline()。以 rb 的形式读取一行数据
18 
19 # 设置操作文件的路径
20 path = r"静夜思.txt"
21 # 在程序中打开文件，建立文件与程序的通道。 以字符型数据读取
22 handle = open(path,"rb")
23 
24 # 通过手柄操作文件指针，读取数据
25 data_str = handle.readline()
26 print(data_str) # 结果：b'\xe7\xaa\x97\xe5\x89\x8d\xe5\x90\x8d\xe5\xa4\x9c\xe5\x85\x89\n'
27 print(data_str.decode(encoding="utf-8"))
28 
29 # 关闭通道
30 handle.close()

readlins()

 1 # readlines()。以 r 的形式读取一行数据
 2 
 3 # 设置操作文件的路径
 4 path = r"静夜思.txt"
 5 # 在程序中打开文件，建立文件与程序的通道。 以字符型数据读取
 6 handle = open(path,"r",encoding="utf-8")
 7 
 8 lines = handle.readlines()
 9 print(lines) # 结果： ['窗前名夜光\n', '疑是地上霜\n', '举头望明月\n', '低头思故乡']
10 
11 # 关闭通道
12 handle.close()
13 # ------------------------------------------------------------------------------#
14 
15 # readlines()。以 rb 的形式读取一行数据
16 
17 # 设置操作文件的路径
18 path = r"静夜思.txt"
19 # 在程序中打开文件，建立文件与程序的通道。 以字符型数据读取
20 handle = open(path,"rb")
21 
22 lines = handle.readlines()
23 print(lines)
24 # 此时 列表中的数据全部是字节类型的。将列表中的数据 全部设置成字符串类型的
25 # 注意：⚠️ 字节数据只能和字符串进行编码解码，列表不可以
26 new_list = [ele.decode("utf-8") for ele in lines]
27 print(new_list)
28 
29 # 关闭通道
30 handle.close()

大文件读取

1 """
2 读取大型文件：
3     流程，读取模式是rb。以字节的形式进行读取的
4     将文件内容分批按照1024的倍数进行读取
5     分批读取结束点：可以获取文件的大小后，与每次读取的累加数量进行比较，
6 
7 """

 1 import os
 2 path = r"/Users/guoyapeng/Downloads/day12/20.数据持久化.mp4"
 3 
 4 
 5 # 打开路径指向的文件
 6 handle = open(path,"rb")
 7 
 8 # 获得文件的大小
 9 file_size = os.path.getsize(path)
10 print(file_size)
11 
12 # 分批进行读取。设置每批读取数据的大小，一般设置为1024的倍数。
13 read_size = 1024
14 
15 # 已经读取的字节数据
16 has_read = 0
17 
18 # 循环读取，已读的 < 文件大小
19 while has_read < file_size:
20     data = handle.read(read_size)
21     print(data)
22     # 为已读取进行累加
23     has_read  +=  read_size
24     print("读取完毕")
25 
26 # 关闭通道
27 handle.close()

文件写入

 1 # 写入文件
 2 """
 3 打开文件模式：
 4     w/wb --- 以字符串/字节数据向文件中写入内容
 5         如果文件不存在，创建文件；文件存在，会清空文件中的内容，文件指针位于0处
 6     a/ab --- 以字符串/字节数据向文件中写入内容
 7         如果文件不存在，创建文件；文件存在，不会清空文件中的内容，文件指针位于末尾处
 8 
 9 写入的方法：
10     write(字符串/字节数据)
11         w/a --- 字符串数据
12         wb/ab --- 字节数据
13     writelines(列表)
14         与readlines是一对。
15         列表中的数据 是要写入的内容
16         如果写入模式是 w/a --- 写入的列表内容是字符串类型
17         如果写入模式是 wb/ab --- 写入的列表内容是字节类型
18 
19 刷新 flush()
20     刷新通道，将通道中的数据快速到达文件中
21 
22 """
23 """==========================================================="""
24 
25 # write() 以a/w的形式写入
26 # 打开文件获得与文件关联的通道
27 path = r"春晓.txt"
28 
29 # 创建写入文件，并设置通道
30 handle = open(path,"a",encoding="utf-8")
31 
32 # 写的方法
33 handle.write("\n夜来风雨声")
34 handle.flush()
35 
36 # 关闭通道
37 handle.close()
38 
39 """=========================================================="""
40 
41 # write()  以ab/wb的形式写入
42 # 打开文件获得与文件关联的通道
43 path = r"春晓.txt"
44 
45 # 创建写入文件，并设置通道
46 handle = open(path,"ab")
47 
48 # 写的方法
49 handle.write("\n夜来风雨声ab".encode("utf-8"))
50 handle.flush()
51 
52 # 关闭通道
53 handle.close()
54 
55 """============================================================="""
56 
57 # writelines() 以a/w的形式写入
58 # 打开文件获得与文件关联的通道
59 path = r"春晓.txt"
60 
61 # 创建写入文件，并设置通道
62 handle = open(path,"a",encoding="utf-8")
63 
64 # 写的方法
65 lines = ["花落知多少\n","小桥流水人家aaa\n"]
66 handle.writelines(lines)
67 handle.flush()
68 
69 # 关闭通道
70 handle.close()
71 
72 """=============================================================="""
73 
74 # writelines()  以ab/wb的形式写入
75 # 打开文件获得与文件关联的通道
76 path = r"春晓.txt"
77 
78 # 创建写入文件，并设置通道
79 handle = open(path,"ab")
80 
81 # 写的方法
82 lines = ["花落知多少\n".encode("utf-8"),"小桥流水人家\n".encode("utf-8")]
83 handle.writelines(lines)
84 handle.flush()
85 
86 # 关闭通道
87 handle.close()

文件拷贝

 1 """
 2 文件拷贝：操作的还是文件的内容
 3     通过读取文件内容 和写入文件内容完成拷贝
 4 拷贝思路：
 5     源文件 读取文件
 6     目标文件 写入文件
 7 
 8 """
 9 import os
10 
11 # 源文件路径
12 src_path = r"/Users/guoyapeng/Downloads/day12/20.数据持久化.mp4"
13 
14 # 目标存储路径
15 desc_path = r"/Users/guoyapeng/Downloads/数据持久化.mp4"
16 
17 # 在程序中打开这两个路径文件
18 src_handle = open(src_path,"rb")
19 desc_handle = open(desc_path,"wb")
20 
21 # 循环读取。设置每次读取的数量
22 read_size = 1024 * 10
23 
24 # 已经读取的数据的大小
25 has_read = 0
26 
27 # 文件大小
28 file_size = os.path.getsize(src_path)
29 
30 while  has_read < file_size:
31     data = src_handle.read(read_size)
32     # 向目的文件内 写入
33     desc_handle.write(data)
34     desc_handle.flush()
35     # 设置已读的数据
36     has_read += read_size
37 
38 # 关闭路径
39 src_handle.close()
40 desc_handle.close()

with语句

 1 """
 2 为了简化代码
 3     程序无法处理程序之外产生的垃圾，所以需要手动关闭通道
 4     使用with语句打开通道 可以不用手动关闭。with语句执行完通道会自动关闭
 5 
 6 格式：
 7     with open(文件路径，打开模式，编码方式) as 变量名1，open(文件路径，打开模式，编码方式) as 变量名2，、、、[后面可以拼多个open()]
 8 、、open(文件路径，打开模式，编码方式) as 变量名n:
 9         [缩紧]执行文件的操作
10 """

 1 # 读
 2 with open("静夜思.txt","r",encoding="utf-8") as handle:
 3     data_str = handle.read()
 4     print(data_str)
 5 
 6 
 7 # 写
 8 with open("春晓.txt","w",encoding="utf-8") as handle:
 9     handle.write("with用法")
10     handle.flush()

数据持久化

 1 """
 2 永久性的保存数据，没有数据库想要进行本地保存，只能借助于文件
 3 可以保存任意类型的数据 需要借助模块：pickle
 4 
 5 保存数据
 6     pickle.dump(保存的数据，数据存入的指定文件)
 7     保存数据，将数据写入到指定文件。这种情况打开文件的模式只能使用字节模式打开
 8 
 9 读取数据
10     变量名 = pickle.load(数据存入的指定文件)
11     将数据在文件中读取出来。需要打开文件，只能使用字节模式
12 """

 1 import pickle
 2 
 3 # 存入数据 一般情况存入的是一个容器
 4 with open("data.txt","wb") as handle:
 5     pickle.dump([10,20,3,45,"a"],handle)
 6     
 7 # 取出数据
 8 with open("data.txt","rb") as handle:
 9     data = pickle.load(handle)
10     print(data)
11