Python初学者的第八天（😀）

Python进阶 -- 文件处理（IO技术）

一个完整的程序一般都包括数据的存储和读取；在实际开发中我们常常需要从外部存储介质（硬盘、光盘、U盘等）读取数据，或者将程序产生的数据存储到文件中实现“持久化”保存。

文本文件和二进制文件

1. 文本文件
   文本文件存储的是普通“字符”文本，默认为 unicode 字符集，可以使用记事本打开。
2. 二进制文件
   二进制文件把数据内容用“字节”进行存储，无法用记事本打开。必须使用相应的软件解码；如：MP4、Mp3、JPG、doc文档等。

文件操作相关模块

创建文件对象 open()

open() 函数用于创建文件对象，基本语法格式：

open(文件名[，打开方式])
复制代码

如果只是文件名，代表在当前目录下的文件。文件名可以录入全路径如：D:\a\b.txt 。

打开方式：

基本的文件写入和其他操作

三个步骤：

1. 创建文件对象
2. 写入数据
3. 关闭文件对象

【操作】写入数据

# 绝对路径
# file = open(
#     "D:/00.study/Study-Python/02.Python 进阶/day02 - Python进阶/code/file.txt",
#     "a",
#     encoding="utf-8")
# a = "芜湖！！！"
# file.write(a)
# file.close()

# 相对路径（需更改vscode配置）
file = open("file.txt", "a", encoding="utf-8")
a = "芜湖！！！"
file.write(a)
file.close()
复制代码

常用编码介绍

在操作中文时，会遇到乱码问题。
编码关系：

中文乱码问题

window 操作系统默认的编码为 GBK，Linux操作系统默认的编码为 UTF-8。当我们用 open() 时，调用的是操作系统打开的文件夹，没默认的编码为 GBK。

write() / writeLines() 写入数据

write(a)：把字符串 a 写入到文件中
writelines(b)：把字符串列表写入文件中，不添加换行符(可以自己添加)。

【操作】测试

f = open(r"file.txt", "w", encoding="utf-8")
s = ["sue\n", "Jason\n", "Eason\n", "Forrest\n"]
f.writelines(s)
f.close()
复制代码

结果：file.txt

sue
Jason
Eason
Forrest
复制代码

close() 关闭文件流

文件底层是由操作系统控制，所以打开文件对象必须先显示调用 close() 方法关闭文件对象。当调用 close() 方法时，首先会把缓冲区数据写入文件（也可以直接调用 flush() 方法），再关闭文件，释放文件对象。

为了确保打开的文件对象正常关闭，一般结合异常机制的 finally 或者 with 关键字实现无论何种情况都能关闭打开的文件对象。

【操作】使用异常并结合finally确保文件关闭

try:
    file = open(r"file.txt", "a", encoding="utf-8")
    str = "Sue,大帅逼！！！\n"
    file.write(str)
except BaseException as e:
    print(e)
finally:
    file.close()
复制代码

with 语句（上下文管理）⭐

with 关键字（上下文管理器）可以自动管理上下文资源，不论什么原因跳出 with 模块，都能确保文件正常关闭，并且可以在代码块执行完毕后自动还原进入代码块时的现场。

【操作】测试

arr = ["primary\n", "middle\n", "high\n"]
with open(r"file.txt", "a", encoding="utf-8") as file:
    file.writelines(arr)
复制代码

with将开启和关闭操作都执行了一边，无需我们自己再关闭

文本文件的读取

文件的读取一般使用有三个方法：

1. read([size])
   在文件中读取 size 个字符，并作为结果返回。如果没有 size 参数，则读取整个文件。读取到文件末尾，返回空字符串。
2. readline()
   读取一行内容作为结果返回。读取到文件末尾，返回空字符串。
3. readlines()
   文本文件中，每一行作为一个字符串存入列表中，返回该列表。

【操作】read()方法

with open(r"file.txt", "r", encoding="utf-8") as f:
    print(f.read(10)) # sue，Jason，
复制代码

【操作】readline()方法

with open(r"file.txt", "r", encoding="utf-8") as f:
    print(f.readline())  # sue，Jason，Eason，Forrest，primary，middle，high
复制代码

【操作】readlines() 方法

with open(r"file.txt", "r", encoding="utf-8") as f:
    print(f.readlines())
    # ['sue，Jason，\n', 'Eason，Forrest，\n', 'primary，middle，\n', 'high\n']
复制代码

【操作】练习：

with open(r"file.txt", "r", encoding="utf-8") as file:
    lines = file.readlines()
    print(lines)
    lines = [
        line.strip() + "---" + str(index + 1) + "\n"
        for index, line in enumerate(lines)
    ]
    print(lines)

with open(r"file.txt", "w", encoding="utf-8") as file:
    file.writelines(lines)
复制代码

二进制文件的读取和写入

二进制文件的处理流程和文本文件的流程是一致的。首先还是要创建文件对象，不过需要指定为二进制模式，才能创建出二进制文件对象。

示例：

file = open(r"xxx.txt","wb") # 可写、重写模式的二进制文件对象
file = open(r"xxx.txt","ab") # 可写、追加模式的二进制文件对象
file = open(r"xxx.txt","rb") # 可读的二进制文件对象
复制代码

创建完成后仍可以使用 write()、read() 实现文件的读写操作

【操作】拷贝一份二进制文件

with open(r"cat.gif", "rb") as f:  # 要拷贝的二进制文件
    with open(r"copy_one.gif", "wb") as w:  # 拷贝后的二进制文件
        for line in f.readlines():
            w.write(line)
print("拷贝结束")
复制代码

文件对象的常用属性和方法

文件对象封装了文件相关的操作。一下举例说明了常用的属性和方法

属性:

文件对象的打开模式：

文件对象的常用方法：

【操作】测试 seek 方法和 name、mode、closed 属性

with open(r"file.txt", "r", encoding="utf-8") as f:
    f.seek(2)  # 索引 --- 指针
    print(f.read())
    # e，---1
    # Jason，---2
    # Eason，---3
    # Forrest，---4
    # primary，---5
    # middle，---6
    # high，---7
    print(f.name)  # file.txt
    print(f.mode)  # r
    print(f.closed)  # False
print(f.closed)  # True
复制代码

【操作】测试 truncate、flush方法

# -------------flush------------------
file = open(r"file.txt", "r", encoding="utf-8")
file.flush()  # write也并不是直接写入，也会将数据放入缓冲区中
file.close()

# ----------truncate--------------
f = open("file.txt", "a", encoding="utf-8")
f.truncate(20)
f.close()

f = open("file.txt", "r", encoding="utf-8")
print(f.read())
# sue，---1
# Jason，
复制代码

pickle 序列化

Python中，对象的本质就是一个 “存储数据内存块” 。当我们需要把内存块中的数据保存到硬盘，或通过网络传输到其他电脑上时。我们就需要“对象的序列化和反序列化”。序列化机制管饭的应用在分布式、并行系统上。

可以实现内存中的对象与方便持久化在磁盘中或在网络中进行交互的数据格式（str、bites)之间的相互转换。这种机制就叫序列化与发序列化

序列化：将内存中的不可持久化和传输对象转换为可方便持久化和传输对象的过程。

反序列化：将可持久化和传输对象转换为不可持久化和传输对象的过程。

pickle模块的dumps()、dump()、loads()、load()是个函数按功能划分可以分为两组：
序列化：dumps()、dump()
反序列化：loads()、load()

语法格式：

pickle.dump(obj,file)  # obj就是要被序列化的对象，file指的是存储文件
pickle.load(file) # 从 file 读取数据，反序列化成对象。
复制代码

【操作】将对象序列化到文件中

import pickle
with open(r"file.txt", "wb") as f:
    name = "Dantes"
    age = 18
    arr = [1, 2, 3, 4, 5, 6, 7]

    pickle.dump(name, f)
    pickle.dump(age, f)
    pickle.dump(arr, f)
复制代码

【操作】将获得到的数据反序列化

with open(r"file.txt", "rb") as f:
    a1 = pickle.load(f)
    a2 = pickle.load(f)
    a3 = pickle.load(f)
    print(a1) # Dantes
    print(a2) # 18
    print(a3) # [1, 2, 3, 4, 5, 6, 7]
复制代码

CSV 文件操作

CSV（Cooma Separated Values） 是逗号分隔符文本格式，常用于数据交换、Excel文件和数据库数据的导入和导出。与 Excel 文件不同，在 CSV 文件中：

• 值没有类型，所有值都是字符串
• 不能指定字体颜色和样式
• 不能指定单元格的宽高，不能合并单元格
• 没有多个工作表
• 不能嵌入图像图表

Excel 表格中建立的表格为：

另存为“csv”格式的，打开后的内容为以下：

CSV 文件的读取和写入

1. CSV 文件的读取

在使用前记得需要引入 csv 包

import csv
with open(r"xxx.csv", "r") as f:
    after_read = csv.reader(f)
    # print(after_read)  # <_csv.reader object at 0x000001B7C5F1DAC8>
    print(list(after_read))
复制代码

通过 csv.reader() 函数建立一个读入数据的对象

2. CSV 文件的写入

a1 = [5, "jj", 21, "doctor"]
a2 = [6, "gg", 25, "runner"]
a3 = [7, "kk", 31, "player"]

with open(r"xxx.csv", "w") as f:
    write_csv = csv.writer(f)
    write_csv.writerow(a1)
    write_csv.writerow(a2)
    write_csv.writerow(a3)
复制代码

OS 模块(⭐)

OS 模块可以让我们直接对操作系统进行控制。直接调用操作系统的可执行文件、命令，操作文件、目录等。是系统运维的核心基础

OS 调用操作系统文件和命令

• os.system system函数可以将字符串转化成命令在服务器上运行；其原理是每一条system函数执行时，其会创建一个子进程在系统上执行命令行，子进程的执行结果无法影响主进程；

【操作】打开记事本

import os
os.system("notepad.exe")
复制代码

【操作】调用系统的 ping 命令

os.system("ping www.google.com")
# Pinging www.google.com [157.240.12.35] with 32 bytes of data:
# Request timed out. ...
复制代码

【操作】打开 cmd 和 powershell

os.system("cmd")
os.system("powershell")
复制代码

• os.startfile 可以根据文件的根目录代开该文件

os.startfile(r"D:/WeChat/WeChat.exe")
复制代码

OS 模块 - 文件和目录操作

如果需要对文件和目录做其他操作，可以使用 os 和 os.path 模块

os 模块的常用文件操作：

使用：

os.rename("./cat.gif", "rename_cat.gif")
复制代码

os.remove("./file1.txt")
复制代码

file_pro = os.stat("file.txt")
print(file_pro)  
# os.stat_result(st_mode=33206, st_ino=3659174697668209, st_dev=1986293374, st_nlink=1, st_uid=0, st_gid=0, st_size=43, st_atime=1633682811, st_mtime=1633607574, st_ctime=1633508935)
复制代码

file_list = os.listdir("D:/00.study/")
print(file_list)
# ['Basic-Study', 'Full-Stack-Study', 'hooks-app', 'Study-C And C++', 'Study-Deep-JavaScript', 'Study-JavaScript-Deeper', 'Study-Python', 'vue-manage-system-master', '作业', '复习文档']
print(os.name)  # nt --> windows; linux&unix -->posix
复制代码

os 模块下关于目录操作的相关方法：

使用：

os.mkdir("works")
复制代码

os.makedirs("works/jobs/stu")
复制代码

os.rmdir("works")
复制代码

os.removedirs("works/jobs/stu")
复制代码

os.getcwd()
os.chdir("xxx")
os.walk()
复制代码

os.path 模块 - 目录操作

os.path 模块提供了目录相关(路径判断、路径切分、路径链接、文件夹遍历)的操作

print(os.path.isabs("file.txt"))  # False
print(os.path.isdir("file.txt"))  # False
print(os.path.isfile("file.txt"))  # True
print(os.path.exists("file.txt"))  # True
print(os.path.getsize("file.txt"))  # 43
print(os.path.abspath("file.txt"))
# D:\00.study\Study-Python\02.Python 进阶\day02 - Python进阶\code\file.txt
print(os.path.dirname(__file__))
# d:\00.study\Study-Python\02.Python 进阶\day02 - Python进阶\code
print(os.path.getatime("file.txt"))  # 1633682811.951791
print(os.path.getmtime("file.txt"))  # 1633607574.351463
# print(os.path.join())
print(os.path.split("file.txt"))  # ('', 'file.txt')
print(os.path.splitext("file.txt"))  # ('file', '.txt')
复制代码

walk() 递归遍历所有文件

os.walk() 方法：

返回一个 3 个元素的元组。（dirpath，dirnames、filenames）：

• dirpath：列出指定目录的路径
• dirnames：目录喜爱的所有文件夹
• filenames：目录下的所有文件

用于通过在目录树中游走输出在目录中的文件名，向上或者向下。
一个简单易用的文件、目录遍历器，可以帮助我们高效的处理文件、目录方面的事情。

walk()方法语法格式如下：

os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])
复制代码

参数:

• top -- 是你所要遍历的目录的地址, 返回的是一个三元组(root,dirs,files)。
  • root 所指的是当前正在遍历的这个文件夹的本身的地址
  • dirs 是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录)
  • files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)
• topdown --可选，为 True，则优先遍历 top 目录，否则优先遍历 top 的子目录(默认为开启)。如果 topdown 参数为 True，walk 会遍历top文件夹，与top 文件夹中每一个子目录。
• onerror-- 可选，需要一个 callable 对象，当 walk 需要异常时，会调用。
• followlinks -- 可选，如果为 True，则会遍历目录下的快捷方式(linux 下是软连接 symbolic link )实际所指的目录(默认关闭)，如果为 False，则优先遍历 top 的子目录。

使用：

# os.makedirs("works/some/www")
path = os.getcwd()
# print(path)
file_lists = os.walk(path)
# print(list(file_lists))
for dirpaths, dirnames, filenames in file_lists:
    # print(dirpaths)
    # print(dirnames)
    # print(filenames)
    for dirP in dirnames:
        # print(dirP)
        print(os.path.join(dirpaths, dirP))

    for names in filenames:
        print(os.path.join(dirpaths, names))
复制代码

shutil 模块（拷贝和压缩）

shutil 模块是 python 标准库中提供的，主要又来做文件和文件夹的拷贝
移动、删除等；还可以做文件和文件夹的压缩、解压缩操作。

os 模块提供了对目录或文件的一般操作，shutil模块作为补充，提供了移动、复制、压缩、解压等操作

使用：

shutil.copyfileobj(src, dst)：

shutil.copyfileobj(open("old.txt", "r"), open("new.txt", "w"))
os.system("cat old.txt new.txt")
复制代码

须以 open("xxxx","x") 的方式打开文件后写入，否则报错
copyfileobj方法只会拷贝文件内容

shutil.copyfile(src, dct)：

shutil.copyfile("old.txt", "new1.txt")
os.system("cat old.txt new.txt")
复制代码

从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为IOException. 如果当前的dst已存在的话就会被覆盖掉
如果有文件则会覆盖文件中的内容，没有则创建

*shutil.copymode(src, dst, , follow_symlinks=True)：

shutil.copymode("old.txt", "new1.txt")
复制代码

仅拷贝文件权限，文件的内容、组、用户均不变

*shutil.copystat(src, dst, , follow_symlinks=True)：

shutil.copystat("old.txt", "new1.txt")
os.system("stat old.txt new.txt")
复制代码

拷贝文件状态的信息，文件必须存在，不copy改动时间

shutil.copy(src, dst, *, follow_symlinks=True)：

shutil.copy("old.txt", "new2.txt")
os.system("stat old.txt new2.txt")
复制代码

拷贝文件和状态信息，同样不copy改动时间

shutil.copy2(src,dct)：

shutil.copy("old.txt", "new2.txt")
os.system("stat old.txt new2.txt")
复制代码

拷贝文件和状态信息

shutil.copytree(src, dst, symlinks=False, ignore=None)：

os.system("tree works")
shutil.copytree(
    "works",
    "works2",
    symlinks=True,
)
os.system("tree works2")
复制代码

递归的去拷贝文件夹
works2目录必须不存在，symlinks=True只copy链接文件，如果等于False就copy源文件，ignore等于不copy的文件或者目录

shutil.rmtree(path, ignore_errors=False, onerror=None)：

os.system("ls -d works2")
shutil.rmtree("works2")
os.system("ls -d works2")  # ls: works2: No such file or directory
复制代码

shutil.move(src, dst, copy_function=copy2)：

os.system("ls -ld works")
# drwxr-xr-x 3 SUe Administrators 0 Oct  8 17:59 works

shutil.move("works", "works2")

os.system("ls -ld works")
# ls: works: No such file or directory

os.system("ls -ld works2")
# drwxr-xr-x 3 SUe Administrators 0 Oct  8 17:59 works2
复制代码

递归的去移动文件，它类似mv命令，其实就是重命名

shutil.make_archive(base_name, format[, root_dir[, base_dir[, verbose[, dry_run[, owner[, group[, logger]]]]]]])：

base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径， 如： tar_name =>保存至当前路径 如：/Users/a6/tar_name =>保存至/Users/a6/
format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
root_dir： 要压缩的文件夹路径（默认当前目录）
owner： 用户，默认当前用户
group： 组，默认当前组
logger： 用于记录日志，通常是logging.Logger对象

zipFile 模块（解压缩）

zipfile是 python 里用来做zip格式编码的压缩和解压缩的，由于是很常见的zip格式，所以这个模块使用频率也是比较高的。

常用方法：

操作使用：

# zipFile 模块的使用
import zipfile

# 1. is_zipfile 检查文件是否是一个 zip 文件
print(zipfile.is_zipfile("works2.zip"))  # True
print(zipfile.is_zipfile("works2"))  # False

# 2. ZipFile(filename[,mode[,compression[,allowZip64]]])
print(zipfile.ZipFile("works2.zip", "r"))
# <zipfile.ZipFile filename='works2.zip' mode='r'>

# 3. close() 关闭文件，结束时必须要有
z = zipfile.ZipFile("works2.zip", "r")
z.close()
print(z)  # <zipfile.ZipFile [closed]>

# 4. extract(member,path=None,pwd=None) 从 zip 中提取一个文件
print(z.extract("works2/s.txt", path=None, pwd=None))

# 5. extractall(path[,pwd]) 将文件按照 namelist 中的目录结构从当前 zip 中提取出来并放到指定目录下
z.extractall("works2")
z.close()

# 6. namelist() 返回一个列表，内容是 zip 文件中所有子文件的path
print(z.namelist())  # ['works2/', 'works2/some/', 'works2/some/www/']
z.close()

# 7. infolist() 返回一个列表，内容是每个 zip 文件中子文件的 ZipInfo 对象
print(z.infolist())
# [<ZipInfo filename='works2/' external_attr=0x10>, <ZipInfo filename='works2/some/' external_attr=0x10>, <ZipInfo filename='works2/some/www/' external_attr=0x10>]
z.close()

# 8. printdir() 将 zip 文件的目录结构打印到 stdout 上，包括了 path，修改时间和大小
print(z.printdir())
# File Name                                             Modified             Size
# works2/                                        2021-10-08 17:59:50            0
# works2/some/                                   2021-10-08 17:59:50            0
# works2/some/www/                               2021-10-08 17:59:50            0
z.close()

9. open(name[,mode[,pwd]]),获取一个子文件的文件对象，可以将其用来read、readline、write等操作

# 10. setpassword(psw)，设置zip文件的密码
z.setpassword(123456)

# 11. testzip() 读取 zip 中所有文件
a = z.testzip()
print(a is None)

# 12. write(filename[,arcname[,compression_type]]) 将其与文件写入 zip 中
z = zipfile.ZipFile("works2.zip", "w")
z.write("files.py")
z.write("os.py")
z.write("shutil.py")
z.close()
复制代码

一些使用方法：

1. 解压文件并读取

import zipfile

z = zipfile.ZipFile(filename, 'r') # 这里的第二个参数用r表示是读取zip文件，w是创建一个zip文件

for f in z.namelist():
    print(f)
复制代码

2. 压缩进文件写入

import zipfile, os

z = zipfile.ZipFile(filename, 'w') # 注意这里的第二个参数是w，这里的filename是压缩包的名字

#假设要把一个叫testdir中的文件全部添加到压缩包里（这里只添加一级子目录中的文件）：
if os.path.isdir(testdir):
    for d in os.listdir(testdir):
        z.write(testdir+os.sep+d)#os.sep是文件分隔符"//"
# close() 是必须调用的！
z.close()
复制代码

一键压缩功能：

# 导入压缩所需要的包
import zipfile
# 导入 os 模块
import os
# 导入 os.path 模块
import os.path


# 1. 创建类
class ZFile(object):
    # 2. 初始化数据 filename-文件名；mode-方式；basedir-绝对路径
    def __init__(self, filename, mode="r", basedir=""):
        self.filename = filename
        self.mode = mode
        # 如果写入的方式为 w-写入，a-追加
        if self.mode in ("w", "a"):
            # 读取zip文件并设置
            self.zfile = zipfile.ZipFile(filename,
                                         self.mode,
                                         compression=zipfile.ZIP_DEFLATED)
        else:
            # 如果没有，默认
            self.zfile = zipfile.ZipFile(filename, self.mode)
        # 绝对路径
        self.basedir = basedir
        # 如果没写，则使用os.path.dirname自动补全
        if not self.basedir:
            self.basedir = os.path.dirname(filename)

    # 添加单个文件
    def addfile(self, path, arcname=None):
        # 路径移除 // , /
        path = path.replace("//", "/")
        #
        if not arcname:
            if path.startswith(self.basedir):
                arcname = path[len(self.basedir):]
            else:
                arcname = ''
        self.zfile.write(path, arcname)

    # 是否添加多个文件
    def addfiles(self, paths):
        for path in paths:
            if isinstance(path, tuple):
                self.addfile(*path)
            else:
                self.addfile(path)

    # 关闭
    def close(self):
        self.zfile.close()

    def extract_to(self, path):
        for p in self.zfile.namelist():
            self.extract(p, path)

    def extract(self, filename, path):
        if not filename.endswith("/"):
            f = os.path.join(path, filename)
            dir = os.path.dirname(f)
            if not os.path.exists(dir):
                os.makedirs(dir)
            self.zfile(f, "wb").write(self.zfile.read(filename))


def create(zfile, files):
    z = ZFile(zfile, 'w')
    z.addfiles(files)
    z.close()


def extract(zfile, path):
    z = ZFile(zfile)
    z.extract_to(path)
    z.close()
复制代码

递归算法原理

递归，是一种常见的解决问题的方法，即把问题逐渐简单化。

其思想就是 “自己调用自己” 一个使用递归技术的方法会直接或间接的调用自己。

递归结构分为两部分：

• **定义递归头：**没有头则会进入死循环，这也是递归的结束条件
• **递归体：**调用自身的方法

【操作】求 n!

def factorial(n):
    if n == 1:
        return n
    else:
        return n * factorial(n - 1)


print(factorial(10))    
复制代码

【操作】输出目录树

import os

allFiles = []

def get_all_files(path, level):
    childFiles = os.listdir(path)
    for file in childFiles:
        filepath = os.path.join(path, file)
        if os.path.isdir(filepath):
            get_all_files(filepath, level + 1)
        allFiles.append("\t" * level + filepath)

get_all_files("works2", 0)
for f in reversed(allFiles):
    print(f)
复制代码