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

文件操作

 """
 在程序中操作的文件内容：
     1. 读取文件中的内容
     2. 向文件中写入内容

 首先：
     在程序中与文件建立一个通道，通过通道操作文件指针，达到所要的结果
     向文件中不管读和写，在程序中都需要打开一个文件

 文件打开方式：open()。会返回一个操作文件的手柄，可以理解为程序与文件之间建立的通道
     handle = open(文件的路径，打开文件的模式--读、写，encoding="操作的文件到的编码方式")
 详解：
     1。文件路径既可以使用相对路径，也可以使用绝对路径
     2。打开方式：
         r --- 只读，如果指定路径对应文件不存在，回报错
         w --- 只写，如果文件不存在，会创建新文件，如果文件存在 会清空文件中原来的内容 文件指针位于0处
         a --- 只写，如果文件不存在，会创建新文件，如果存在 不会清空原文件的内容 文件指针位于文件的末尾

         r/w/a 这种模式，操作的字符串数据
         rb/wb/ab  这种模式操作的是字节数据
         r+/w+/rb+/wb+/ab+ 带有 + 号的是可读可写
     3。编码方式：
         urg-8/gbk
 注意：程序无法处理程序之外产生的垃圾。需要手动处理垃圾（手动把通道关闭）
 　　　如果是字节模式处理数据打开文件时，不需要设置编码方式，否则会报错
 """

文件读取

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

• read()

 # read()。以 r 的形式 读取数据

 # 设置操作文件的路径
 path = r"静夜思.txt"
 # 在程序中打开文件，建立文件与程序的通道。 以字符型数据读取
 handle = open(path,"r",encoding="utf-8")

 # 通过手柄操作文件指针，读取数据
 data_str = handle.read()
 print(data_str)

 # 设置读取大小时，读取部分之后 文件指针到了3的位置，再读的话从第4位置开始读取
 data_string = handle.read(3)
 print(data_string) # 结果：窗前名

 # 关闭通道
 handle.close()

 # ------------------------------------------------------------------ #

 # read()。以 rb 的形式 读取数据

 # 设置操作文件的路径
 path = r"静夜思.txt"
 # 在程序中打开文件，建立文件与程序的通道。 以字节型数据读取
 handle = open(path,"rb")

 # 以rb形式进行读取
 data = handle.read(3)
 print(data)
 print(data.decode(encoding="utf-8"))

 # 关闭通道
 handle.close()

• readline()

 # readline()。以 r 的形式读取一行数据

 # 设置操作文件的路径
 path = r"静夜思.txt"
 # 在程序中打开文件，建立文件与程序的通道。 以字符型数据读取
 handle = open(path,"r",encoding="utf-8")

 # 通过手柄操作文件指针，读取数据
 data_str = handle.readline()
 print(data_str)

 # 关闭通道
 handle.close()

 # ------------------------------------------------------------------------ #

 # readline()。以 rb 的形式读取一行数据

 # 设置操作文件的路径
 path = r"静夜思.txt"
 # 在程序中打开文件，建立文件与程序的通道。 以字符型数据读取
 handle = open(path,"rb")

 # 通过手柄操作文件指针，读取数据
 data_str = handle.readline()
 print(data_str) # 结果：b'\xe7\xaa\x97\xe5\x89\x8d\xe5\x90\x8d\xe5\xa4\x9c\xe5\x85\x89\n'
 print(data_str.decode(encoding="utf-8"))

 # 关闭通道
 handle.close()

• readlins()

 # readlines()。以 r 的形式读取一行数据

 # 设置操作文件的路径
 path = r"静夜思.txt"
 # 在程序中打开文件，建立文件与程序的通道。 以字符型数据读取
 handle = open(path,"r",encoding="utf-8")

 lines = handle.readlines()
 print(lines) # 结果： ['窗前名夜光\n', '疑是地上霜\n', '举头望明月\n', '低头思故乡']

 # 关闭通道
 handle.close()
 # ------------------------------------------------------------------------------#

 # readlines()。以 rb 的形式读取一行数据

 # 设置操作文件的路径
 path = r"静夜思.txt"
 # 在程序中打开文件，建立文件与程序的通道。 以字符型数据读取
 handle = open(path,"rb")

 lines = handle.readlines()
 print(lines)
 # 此时 列表中的数据全部是字节类型的。将列表中的数据 全部设置成字符串类型的
 # 注意：⚠️ 字节数据只能和字符串进行编码解码，列表不可以
 new_list = [ele.decode("utf-8") for ele in lines]
 print(new_list)

 # 关闭通道
 handle.close()

• 大文件读取

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

 """

 import os
 path = r"/Users/guoyapeng/Downloads/day12/20.数据持久化.mp4"

 # 打开路径指向的文件
 handle = open(path,"rb")

 # 获得文件的大小
 file_size = os.path.getsize(path)
 print(file_size)

 # 分批进行读取。设置每批读取数据的大小，一般设置为1024的倍数。
 read_size = 1024

 # 已经读取的字节数据
 has_read = 0

 # 循环读取，已读的 < 文件大小
 while has_read < file_size:
     data = handle.read(read_size)
     print(data)
     # 为已读取进行累加
     has_read  +=  read_size
     print("读取完毕")

 # 关闭通道
 handle.close()

文件写入

 # 写入文件
 """
 打开文件模式：
     w/wb --- 以字符串/字节数据向文件中写入内容
         如果文件不存在，创建文件；文件存在，会清空文件中的内容，文件指针位于0处
     a/ab --- 以字符串/字节数据向文件中写入内容
         如果文件不存在，创建文件；文件存在，不会清空文件中的内容，文件指针位于末尾处

 写入的方法：
     write(字符串/字节数据)
         w/a --- 字符串数据
         wb/ab --- 字节数据
     writelines(列表)
         与readlines是一对。
         列表中的数据 是要写入的内容
         如果写入模式是 w/a --- 写入的列表内容是字符串类型
         如果写入模式是 wb/ab --- 写入的列表内容是字节类型

 刷新 flush()
     刷新通道，将通道中的数据快速到达文件中

 """
 """==========================================================="""

 # write() 以a/w的形式写入
 # 打开文件获得与文件关联的通道
 path = r"春晓.txt"

 # 创建写入文件，并设置通道
 handle = open(path,"a",encoding="utf-8")

 # 写的方法
 handle.write("\n夜来风雨声")
 handle.flush()

 # 关闭通道
 handle.close()

 """=========================================================="""

 # write()  以ab/wb的形式写入
 # 打开文件获得与文件关联的通道
 path = r"春晓.txt"

 # 创建写入文件，并设置通道
 handle = open(path,"ab")

 # 写的方法
 handle.write("\n夜来风雨声ab".encode("utf-8"))
 handle.flush()

 # 关闭通道
 handle.close()

 """============================================================="""

 # writelines() 以a/w的形式写入
 # 打开文件获得与文件关联的通道
 path = r"春晓.txt"

 # 创建写入文件，并设置通道
 handle = open(path,"a",encoding="utf-8")

 # 写的方法
 lines = ["花落知多少\n","小桥流水人家aaa\n"]
 handle.writelines(lines)
 handle.flush()

 # 关闭通道
 handle.close()

 """=============================================================="""

 # writelines()  以ab/wb的形式写入
 # 打开文件获得与文件关联的通道
 path = r"春晓.txt"

 # 创建写入文件，并设置通道
 handle = open(path,"ab")

 # 写的方法
 lines = ["花落知多少\n".encode("utf-8"),"小桥流水人家\n".encode("utf-8")]
 handle.writelines(lines)
 handle.flush()

 # 关闭通道
 handle.close() 

文件拷贝

 """
 文件拷贝：操作的还是文件的内容
     通过读取文件内容 和写入文件内容完成拷贝
 拷贝思路：
     源文件 读取文件
     目标文件 写入文件

 """
 import os

 # 源文件路径
 src_path = r"/Users/guoyapeng/Downloads/day12/20.数据持久化.mp4"

 # 目标存储路径
 desc_path = r"/Users/guoyapeng/Downloads/数据持久化.mp4"

 # 在程序中打开这两个路径文件
 src_handle = open(src_path,"rb")
 desc_handle = open(desc_path,"wb")

 # 循环读取。设置每次读取的数量
 read_size = 1024 * 10

 # 已经读取的数据的大小
 has_read = 0

 # 文件大小
 file_size = os.path.getsize(src_path)

 while  has_read < file_size:
     data = src_handle.read(read_size)
     # 向目的文件内 写入
     desc_handle.write(data)
     desc_handle.flush()
     # 设置已读的数据
     has_read += read_size

 # 关闭路径
 src_handle.close()
 desc_handle.close()

with语句

 """
 为了简化代码
     程序无法处理程序之外产生的垃圾，所以需要手动关闭通道
     使用with语句打开通道 可以不用手动关闭。with语句执行完通道会自动关闭

 格式：
     with open(文件路径，打开模式，编码方式) as 变量名1，open(文件路径，打开模式，编码方式) as 变量名2，、、、[后面可以拼多个open()]
 、、open(文件路径，打开模式，编码方式) as 变量名n:
         [缩紧]执行文件的操作
 """

 # 读
 with open("静夜思.txt","r",encoding="utf-8") as handle:
     data_str = handle.read()
     print(data_str)

 # 写
 with open("春晓.txt","w",encoding="utf-8") as handle:
     handle.write("with用法")
     handle.flush()

数据持久化

 """
 永久性的保存数据，没有数据库想要进行本地保存，只能借助于文件
 可以保存任意类型的数据 需要借助模块：pickle

 保存数据
     pickle.dump(保存的数据，数据存入的指定文件)
     保存数据，将数据写入到指定文件。这种情况打开文件的模式只能使用字节模式打开

 读取数据
     变量名 = pickle.load(数据存入的指定文件)
     将数据在文件中读取出来。需要打开文件，只能使用字节模式
 """

 import pickle

 # 存入数据 一般情况存入的是一个容器
 with open("data.txt","wb") as handle:
     pickle.dump([10,20,3,45,"a"],handle)

 # 取出数据
 with open("data.txt","rb") as handle:
     data = pickle.load(handle)
     print(data)