文件操作
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 """
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()
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'xe7xaax97xe5x89x8dxe5x90x8dxe5xa4x9cxe5x85x89
'
27 print(data_str.decode(encoding="utf-8"))
28
29 # 关闭通道
30 handle.close()
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) # 结果： ['窗前名夜光
', '疑是地上霜
', '举头望明月
', '低头思故乡']
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("
夜来风雨声")
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("
夜来风雨声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 = ["花落知多少
","小桥流水人家aaa
"]
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 = ["花落知多少
".encode("utf-8"),"小桥流水人家
".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