Python基础知识（九）2021.2.7

本文主要是介绍Python基础知识（九）2021.2.7，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

异常的本质_调试核心理念

异常指程序运行过程中出现的非正常现象，例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。所谓异常处理，就是指程序在出现问题时依然可以正确的执行剩余的程序，而不会因为异常而终止程序执行。
python 中，引进了很多用来描述和处理异常的类，称为异常类。异常类定义中包含了该类异常的信息和对异常进行处理的方法。

python 中一切都是对象，异常也采用对象的方式来处理。处理过程：

1.抛出异常：在执行一个方法时，如果发生异常，则这个方法生成代表该异常的一个对象，停止当前执行路径，并把异常对象提交给解释器。

a = 3/0

抛出如下异常，解释器会将异常包装成一个对象抛出！（ZeroDivisionError）

Traceback (most recent call last):File "C:/Users/hp/PycharmProjects/pythonProject/main.py", line 1, in <module>a = 3/0
ZeroDivisionError: division by zero

捕获异常：解释器得到该异常后，寻找相应的代码来处理该异常。
异常解决的关键：定位当发生异常时，解释器会报相关的错误信息，并会在控制台打印出相关错误信息。我们只需按照从上到下的顺序即可追溯（Trackback）错误发生的过程，最终定位引起错误的那一行代码。
【示例】追溯异常发生的过程

def a():print("run in a() start!")num = 1/0print("run in a() end!")def b():print("run in b() start!")a()print("run in b() end!")def c():print("run in c() start!")b()print("run in c() end!")print("step1")
c()
print("step2")

在这里插入图片描述按照调用顺序调用c/b/a函数，然后num=1/0时抛出异常，到b调用的位置，然后到c调用的位置(追溯最近的一次调用过程）。

try_except基本结构

try…except 是最常见的异常处理结构。结构如下：

try: 被监控的可能引发异常的语句块 
except BaseException [as e]: 异常处理语句块

try 块包含着可能引发异常的代码，except 块则用来捕捉和处理发生的异常。执行的时候，如果 try 块中没有引发异常，则跳过 ecept 块继续执行后续代码；执行的时候，如果 try块中发生了异常，则跳过 try 块中的后续代码，跳到相应的 except 块中处理异常；异常处理完后，继续执行后续代码。

# 正常执行，跳过except部分直接输出
try:print("step1")a = 3/2print("step2")
except BaseException as e:print("step3")print(e)print("step4")

在这里插入图片描述

# 跳过try块中产生异常之后的部分
try:print("step1")a = 3/0print("step2")
except BaseException as e:print("step3")print(e)print("step4")

在这里插入图片描述
【示例】输入数字，如果不是数字，则处理异常；直到输入100，程序退出

while True:try:a = float(input("please input a number: (if number = 100, exit!)"))if a == 100:print("exit!")breakexcept BaseException as e:print("please input a right number!")

在这里插入图片描述

try多个except结构

上面的结构可以捕获所有的异常，工作中也很常见。但是，从经典理论考虑，一般建议尽量捕获可能出现的多个异常（按照先子类后父类的顺序），并且针对性的写出异常处理代码。为了避免遗漏可能出现的异常，可以在最后增加 BaseException。结构如下：

try: 被监控的、可能引发异常的语句块 
except Exception1: 处理 Exception1 的语句块 
except Exception2: 处理 Exception2 的语句块 ... 
except BaseException: 处理可能遗漏的异常的语句块

while True:try:a = float(input("请输入被除数："))b = float(input("请输入除数："))c = a/bprint(c)except ZeroDivisionError:print("除数不能为0")except TypeError:print("被除数和除数都应该是数值类型！")except NameError:print("变量不存在")except BaseException as e:print(e)print(type(e))

在这里插入图片描述

else结构

except和else部分二选一输出!

try…except…else 结构增加了“else 块”。如果 try 块中没有抛出异常，则执行 else 块。如果 try 块中抛出异常，则执行 except 块，不执行 else 块。

while True:try:a = input("请输入被除数：")b = input("请输入除数：")c = float(a)/float(b)except BaseException as e:print(e)else:print("结果是：",c)

在这里插入图片描述

finally结构

try…except…finally 结构中，finally 块无论是否发生异常都会被执行；通常用来释放 try 块中申请的资源。

while True:try:a = input("请输入被除数：")b = input("请输入除数：")c = float(a)/float(b)except BaseException as e:print(e)else:print("结果是：",c)finally:print("finally中语句，无论正常与否，都执行！")

在这里插入图片描述【示例】读取文件，finally保证关闭文件资源

while True:try:f = open('a.txt',"r",encoding="utf=8")content = f.readline()print(content)except BaseException as e:print(e)finally:print("finally中语句，无论正常与否，都执行！")# 释放资源# 此处也有可能发生异常，若发生异常，则程序终止，不会继续往下执行，所以再加一个try...except结构比较完善try:f.close()breakexcept BaseException as e:print(e)

正确执行结果：

错误执行结果：
在这里插入图片描述

return语句和异常处理问题

由于 return 有两种作用：结束方法运行、返回值。我们一般不把 return 放到异常处理结构中，而是放到方法最后。

一般不要将return语句放在try、except、else、finally块中，会发生一些意想不到的错误，建议放到方法最后。

def test01():print("step1")try:x = 3/0#return "a"except:print("step2")print("Error:0")#return "b"finally:print("step4")#return "d"print("step5")return "e"print(test01())

留下return a
在这里插入图片描述
留下a/b【仍然会执行finally中的语句，最后返回b】

留下abd【第一个return b失效了】

留下abde【最后的return e并没有执行】

常见异常汇总和说明

常见异常：

SynataxError:invalid syntax
int a = 3NameError:
# 尝试访问一个没有申明的变量
print(A)ValueError:
# 数值错误
float("string")TypeError:
212+"abc"AttributeError:
# 访问的对象不存在
a = 100
a.sayhi()indexError:
# 索引越界
a = [4,5,6]
a[10]KeyError:
# 字典关键字不存在
a = {"name":"Cairo","age":18}
a["salary"]

在这里插入图片描述

with上下文管理

finally 块由于是否发生异常都会执行，通常放置释放资源的代码。其实，我们可以通过 with 上下文管理，更方便的实现释放资源的操作。 with 上下文管理的语法结构如下：

with context_expr [ as var]:语句块

with 上下文管理可以自动管理资源，在 with 代码块执行完毕后自动还原进入该代码之前的现场或上下文。不论何种原因跳出 with 块，不论是否有异常，总能保证资源正常释放。极大的简化了工作，在文件操作、网络通信相关的场合非常常用。

with open("a.txt",'w',encoding="utf-8") as f:f.writelines("I love you")

trackback模块的使用_异常写入日志文件

使用trackback模块打印异常信息。

import tracebacktry:print("step1")num = 1/0
except:with open("log.txt","w") as f:traceback.print_exc(file=f)# 直接打印异常信息
traceback.print_exc()

在这里插入图片描述

自定义异常类_raise抛出异常

程序开发中，有时也需要自己定义异常类。自定义异常类一般都是运行时异常，通常继承 Exception 或其子类即可。命名一般以 Error、Exception 为后缀。自定义异常由 raise 语句主动抛出。

【注意🐖】
if __name__ == '__main__'的意思是：当.py文件被直接运行时，if __name__ == '__main__'之下的代码块将被运行；当.py文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行。

class AgeError(Exception):# 通常需要重写构造器# 需要调用父类的构造函数def __init__(self,errorInfo):Exception.__init__(self)self.errorInf = errorInfo# 需要返回异常信息，重写str方法def __str__(self):return str(self.errorInf)+"年龄错误，应该在1-150之间"if __name__ == "__main__":age = int(input("输入一个年龄："))if age<1 or age>150:raise AgeError(age)else:print("正常的年龄：",age)

在这里插入图片描述

pycharm的调试模式

一些图标和快捷键的作用：
在这里插入图片描述

编码知识

在这里插入图片描述

ASCII

全称为 American Standard Code for Information Interchange，美国信息交换标准代码，这是世界上最早最通用的单字节编码系统，主要用来显示现代英语及其他西欧语言。

ASCII 码用 7 位表示，只能表示 128 个字符。只定义了 27=128 个字符，用 7bit 即可完全编码，而一字节 8bit 的容量是 256，所以一字节 ASCII 的编码最高位总是 0。

0～31 表示控制字符如回车、退格、删除等；32～126 表示打印字符即可以通过键盘输入并且能显示出来的字符；其中 48～57 为 0 到 9 十个阿拉伯数字， 65～90 为 26 个大写英文字母，97～122 号为 26 个小写英文字母，其余为一些标点符号、运算符号等，具体可以参考 ASCII 标准表。

ISO8859-1

ISO-8859-1 又称 Latin-1，是一个 8 位单字节字符集，它把 ASCII 的最高位也利用起来，并兼容了 ASCII，新增的空间是 128，但它并没有完全用完。

在 ASCII 编码之上又增加了西欧语言、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号，它是向下兼容 ASCII 编码

GB2312,GBK,GB18030

GB2312
GB2312 全称为信息交换用汉字编码字符集，是中国于 1980 年发布，主要用于计算机系统中的汉字处理。GB2312 主要收录了 6763 个汉字、682 个符号。 GB2312覆盖了汉字的大部分使用率，但不能处理像古汉语等特殊的罕用字，所以后来出现了像 GBK、GB18030 这种编码。 GB2312 完全兼容 ISO8859-1。
GBK
GBK全称为 Chinese Internal Code Specification，即汉字内码扩展规范，于 1995 年制定。它主要是扩展了 GB2312，在它的基础上又加了更多的汉字，它一共收录了 21003 个汉字 ·GB18030 现在最新的内码字集于 2000 年发布，并于 2001 年强制执行，包含了中国大部分少数民族的语言字符，收录汉字数超过 70000 余个。它主要采用单字节、双字节、四字节对字符编码，它是向下兼容 GB2312 和 GBK 的，虽然是我国的强制使用标准，但在实际生产中很少用到，用得最多的反而是 GBK 和 GB2312

Unicode

Unicode 编码设计成了固定两个字节，所有的字符都用 16 位(2^16=65536) 表示，包括之前只占 8 位的英文字符等，所以会造成空间的浪费，UNICODE 在很长的一段时间内都没有得到推广应用。Unicode 完全重新设计，不兼容 iso8859-1，也不兼容任何其他编码。

UTF-8

UTF-8对于英文字母，unicode 也需要两个字节来表示。所以 unicode 不便于传输和存储。因此而产生了 UTF 编码，UTF-8 全称是（8-bit Unicode Transformation Format）。
UTF 编码兼容 iso8859-1 编码，同时也可以用来表示所有语言的字符，不过，UTF 编码是不定长编码，每一个字符的长度从 1-4 个字节不等。其中，英文字母都是用一个字节表示，而汉字使用三个字节。

【建议】一般项目都会使用 UTF-8。unicode 中虽然汉字是两个字节， UTF-8 中汉字是 3 个字节。但是互联网中一个网页也包含了大量的英文字母，这些英文字母只占用 1 个字节，整体占用空间，UTF-8 仍然由于 Unicode。

中文乱码问题

乱码是因为编码和解码不一致造成的。（正常os打开txt文件GBK,但是使用python打开的时候用的Unicode，所以出现乱码）
windows 操作系统默认的编码是 GBK，Linux 操作系统默认的编码是 UTF-8。当我们用 open()时，调用的是操作系统打开的文件，默认的编码是 GBK（解释器去调用os，os默认GBK，而python默认Unicode）

在这里插入图片描述

# 通过指定文件编码解决中文乱码问题
f = open(r"a.txt","a",encoding="utf-8")

在这里插入图片描述

文件操作（IO技术）

一个完整的程序一般都包括数据的存储和读取；在前面写的程序数据都没有进行实际的存储，因此 python 解释器执行完数据就消失了。实际开发中，经常需要从外部存储介质（硬盘、光盘、U 盘等）读取数据，或者将程序产生的数据存储到文件中，实现“持久化”保存。

很多软件系统是将数据存储的数据库中；数据库实际也是基于文件形式存储的。

文件操作相关模块概述

在这里插入图片描述

文本文件和二进制文件

按文件中数据组织形式，把文件分为文本文件和二进制文件两大类。

文本文件
文本文件存储的是普通“字符”文本，python 默认为 unicode 字符集（两个字节表示一个字符，最多可以表示：65536 个），可以使用记事本程序（纯文本）打开。但是，像 word 软件编辑的文档不是文本文件（word不仅可以放文本也可以放图片等其他内容）。
二进制文件
二进制文件把数据内容用“字节”进行存储，无法用记事本打开。必须使用专用的软件解码。常见的有：MP4 视频文件、MP3 音频文件、JPG 图片、doc 文档等等。

创建文件对象

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

 open(文件名[,打开方式])

如果只是文件名，代表在当前目录下的文件。文件名可以录入全路径，比如：D:\a\b.txt。
为了减少“\”的输入，可以使用原始字符串：r“d:\b.txt”。示例如下：

 f = open(r"d:\b.txt","w")

常见打开方式如下：
在这里插入图片描述
文本文件对象和二进制文件对象的创建：

如果没有增加模式“b”，则默认创建的是文本文件对象，处理的基本单元是“字符”。
如果是二进制模式“b”，则创建的是二进制文件对象，处理的基本单元是“字节”。

f = open(r"a.txt","a")
s = "I love you!"
f.write(s)
f.close()

在这里插入图片描述

文本文件的写入

基本文件写入操作

文本文件的写入一般就是三个步骤：

创建文件对象
写入数据
关闭文件对象

write/writelines写入数据

write(a) #把字符串 a 写入到文件中 
writelines(b) #把字符串列表写入文件中，不添加换行符,想添加换行符自己写

f = open(r"a.txt","w",encoding="utf-8")
s = ["\n我爱你","\n没道理","\n伊利，巧乐兹！"]
f.writelines(s)
f.close()

在这里插入图片描述

close关闭文件流

由于文件底层是由操作系统控制，所以打开的文件对象必须显式调用 close()方法关闭文件对象。

当调用 close()方法时，首先会把缓冲区数据写入文件(也可以直接调用 flush() 方法)，再关闭文件，释放文件对象。为了确保打开的文件对象正常关闭，一般结合异常机制的 finally 或者 with 关键字实现 无论何种情况都能关闭打开的文件对象。

在这里插入图片描述

with语句（上下文管理器)

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

s = ["\n我爱你","\n没道理","\n巧乐兹！"]with open(r"a.txt","w",encoding="utf-8") as f:f.writelines(s)

在这里插入图片描述

文本文件的读取

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

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

【示例】读取前4个字符

with open(r"a.txt","r",encoding="utf-8") as f:print(f.read(4))

在这里插入图片描述

【示例】文件较小，一次性读取
在这里插入图片描述
【示例】按行读取文件

with open(r"a.txt","r",encoding="utf-8") as f:i = 1while True:fragment = f.readline()if not fragment:breakelse:print("{0}".format(i),fragment,end='')i += 1

在这里插入图片描述
【示例】使用迭代器读取文本文件（也是按行读取的）

with open(r"a.txt","r",encoding="utf-8") as f:for i in f:print(i)

在这里插入图片描述
【注意】读入的时候和写入的时候对换行的操作

enumerate()函数和推导式生成列表

enumerate()生成由列表中元素序号和列表中元素共同构成的元组的列表:[(0,string1),(1,string2),...]

with open(r"a.txt","r",encoding="utf-8") as f:lines = f.readlines()lines = [line.rstrip()+"#"+str(index+1)+"\n" for index,line in enumerate(lines)]with open(r"a.txt","w",encoding="utf-8") as f:f.writelines(lines)

在这里插入图片描述

二进制文件的读写_图片文件拷贝(直接二进制赋值粘贴即可）

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

f = open(r"d:\a.txt", 'wb') #可写的、重写模式的二进制文件对象
f = open(r"d:\a.txt", 'ab') #可写的、追加模式的二进制文件对象
f = open(r"d:\a.txt", 'rb') #可读的二进制文件对象

创建好二进制文件对象后，仍然可以使用 write()、read()实现文件的读写操作

文件对象常用方法和属性总结

文件对象的属性：

name # 返回文件的名字
mode # 返回文件的打开方式
closed # 若文件被关闭则返回True

文件对象的常用方法：

read([size]) #从文件中读取 size 个字节或字符的内容返回。若省略[size]，则读 取到文件末尾，即一次读取文件所有内容
readline() # 从文本文件中读取一行内容
readlines() # 把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回write(str) #  将字符串 str 内容写入文件
writelines(s) #将字符串列表 s 写入文件文件，不添加换行符seek(offset[,whence])
# 把文件指针移动到新的位置，offset 表示相对于 whence 的多少个字节的偏移量；
# offset：off 为正往结束方向移动，为负往开始方向移动 
# whence 不同的值代表不同含义： 
# 0: 从文件头开始计算（默认值） 1：从当前位置开始计算 2：从文件尾开始计算
tell() # 返回文件指针的当前位置
truncate([size]) 
# 不论指针在什么位置，只留下指针前 size 个字节的内容，其余全部删除； 
# 如果没有传入 size，则当指针当前位置到文件末尾内容全部删除flush() # 把缓冲区的内容写入文件，但不关闭文件
close() # 把缓冲区内容写入文件，同时关闭文件，释放文件对象相关资源

使用pickle实现序列化和反序列化

Python 中，一切皆对象，对象本质上就是一个“存储数据的内存块”。有时候，需要将“内存块的数据”保存到硬盘上，或者通过网络传输到其他的计算机上。这时候，就需要“对象的序列化和反序列化”。对象的序列化机制广泛的应用在分布式、并行系统上。
序列化指的是：将对象转化成“串行化”数据形式，存储到硬盘或通过网络传输到其他地方。
反序列化是指相反的过程，将读取到的“串行化数据”转化成对象。

可以使用 pickle 模块中的函数，实现序列化和反序列操作。序列化使用：

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

【示例】将对象序列化到文件中

import pickle
with open("a.txt","wb") as f:a1 = "Cairo"a2 = 123a3 = [123,45]pickle.dump(a1,f)pickle.dump(a2,f)pickle.dump(a3,f)

【示例】将获得的数据反序列化成对象

import pickle
with open("a.txt","rb") as f:# 恢复成对象a1 = pickle.load(f)a2 = pickle.load(f)a3 = pickle.load(f)# 序列化和反序列化操作后的对象不是同一个对象！print(a1)print(a2)print(a3)

在这里插入图片描述

csv文件的读取和写入

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

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

【操作】csv.reader 对象于从 csv 文件读取数据

import csvwith open("000001.csv") as f:# 产生指针，文件读取到末尾之后需要重新访问文件才可以f_csv = csv.reader(f)# 因为第一行是描述类别的数据，单独打印headers = next(f_csv)print(headers)# iterator遍历每一个数据for row in f_csv:print(row)

在这里插入图片描述

【操作】csv.writer 对象写一个 csv 文件

import csvheaders = ["name","age","salary"]
data = [("Cairo","18","29999"),("Quinn","18","30000")]with open("000002.csv","w") as f:# 获得csv写入器f_csv = csv.writer(f)f_csv.writerow(headers)f_csv.writerows(data)

在这里插入图片描述

os模块

os 模块可以直接对操作系统进行操作。可以直接调用操作系统的可执行件、命令，直接操作文件、目录等等。在系统运维的核心基础。

os 模块-调用操作系统命令

1. os.system 可以帮助我们直接调用系统的命令

os.system("firefox.exe")os.system("ping www.baidu.com")

【注】Linux 是命令行操作更容易，可以通过 os.system 可以更加容易的调用相关的命令
2.os.startfile：直接调用可执行文件

os.startfile("文件路径")

os模块-文件和目录操作

在这里插入图片描述【示例】os 模块：创建、删除目录、获取文件信息等

#############获取文件和文件夹相关的信息################
#coding=utf-8
import os
# 操作系统信息 windows->nt linux/unix -> posix
print(os.name)
# 分隔符信息
print(os.sep)
# 返回当前系统下的换行符
# repr(obj) 将对象转化为供解释器读取的形式，返回对象的一个string形式
print(repr(os.linesep))

在这里插入图片描述

开始报错如下：添加了#coding=utf-8后得以解决。
在这里插入图片描述

##############关于工作目录的操作###############
#coding=utf-8
import os
# 获得当前系统目录
print(os.getcwd())
os.chdir("D:")
os.mkdir("书籍")
print(os.getcwd())

在这里插入图片描述

################创建目录、创建多级目录、删除#############
#coding=utf-8
import os
# 获得当前系统目录
print(os.getcwd())
os.chdir("D:")
os.mkdir("pure_water")
os.makedirs("fruit/melon/watermelon")

在这里插入图片描述

# 删除
#coding=utf-8
import os
# 获得当前系统目录
print(os.getcwd())
os.chdir("D:")
os.rmdir("pure_water")
os.removedirs("fruit/melon/watermelon")

os.path部分

os.path模块提供了目录相关（路径判断、路径切分、路径连接、文件夹遍历）的操作
在这里插入图片描述

在这里插入图片描述

#coding=utf-8
import os
import os.pathdir = os.getcwd()
print(os.path.isabs("a.txt"))
print(os.path.isabs(dir+r"\a.txt"))print(os.path.isdir(dir+r"\a.txt"))
print(os.path.isfile("a.txt"))print(os.path.exists("a.txt"))
print(os.path.getsize("a.txt"))# 输出绝对路径
print(os.path.abspath("a.txt"))
print(os.path.dirname("a.txt"))# 获得创建时间、访问时间、最后修改时间
print(os.path.getctime("a.txt"))
print(os.path.getatime("a.txt"))
print(os.path.getmtime("a.txt"))# 对路径进行分割
abspath = os.path.abspath("a.txt") 
print(os.path.split(abspath)) # 返回元组：目录+文件
print(os.path.splitext(abspath)) # 返回元组：路径+扩展名
# 对路径进行连接
print(os.path.join("aa","bb","cc"))

在这里插入图片描述

【示例】列出指定目录下所有的.py文件，并输出文件名

#coding=utf-8
import os# 列出当前目录下所有文件
path = os.getcwd()
file_list = os.listdir(path)# 写法一
for file in file_list:if os.path.splitext(file)[1] == ".py" :print(file)# 写法二
# 直接用生成式生成
file_list1 = [filename for filename in os.listdir(os.getcwd()) if filename.endswith(".py")]
for i in file_list1:print(i)

在这里插入图片描述

walk()递归遍历所有文件和目录

os.walk()方法：
返回一个 3 个元素的元组：(dirpath, dirnames, filenames)
dirpath：要列出指定目录的路径
dirnames：目录下的所有文件夹
filenames：目录下的所有文件

#coding=utf-8
import osall_files = []# 获得当前路径
path = os.getcwd()
list_files = os.walk(path)# 三元组取出
for dirpath,dirnames,filenames in list_files:# 将指定路径目录+文件目录for dir in dirnames:all_files.append(os.path.join(dirpath,dir))for name in filenames:all_files.append(os.path.join(dirpath,name))for file in all_files:print(file)

部分结果：
在这里插入图片描述

shutil和zipfile模块

shutil 模块是 python 标准库中提供的，主要用来做文件和文件夹的拷贝、移动、删除等；还可以做文件和文件夹的压缩、解压缩操作。
os 模块提供了对目录或文件的一般操作。shutil 模块作为补充，提供了移动、复制、压缩、解压等操作，这些 os 模块都没有提供。

【示例】实现文件的拷贝

#coding=utf-8
import os
import shutil# copy文件内容
shutil.copyfile("a.txt","a_copy.txt")

在这里插入图片描述
【示例】实现递归的拷贝文件夹内容（使用shutil模块）

#coding=utf-8
import os
import shutil# copy文件内容
# test_copy文件夹不存在才能使用
shutil.copytree("test/inner_test01","test_copy",ignore=shutil.ignore_patterns("*.html","*.htm"))
# ignore  忽略的文件类型

在这里插入图片描述
【实例】实现将文件夹所有内容压缩

#coding=utf-8
import os
import shutil
import zipfile# 将“test_copy"文件夹下的所有文件都压缩到test文件夹下生成music.zip
shutil.make_archive("test/music","zip","test_copy")# 压缩：将指定的多个文件压缩到一个zip文件
# 类似文件读写操作！
z = zipfile.ZipFile("a.zip","w")
z.write("a.txt")
z.write("log.txt")
z.close()

在这里插入图片描述

递归算法原理

【示例】使用递归算法遍历目录下所有文件


#coding=utf-8
import os
import shutil
import zipfileall_file = []def getFiles(path,level):chileFiles = os.listdir(path)for file in chileFiles:filepath = os.path.join(path,file)if os.path.isdir(filepath):getFiles(filepath,level+1)# 根据层数添加空白符，体现递归层次all_file.append("\t"*level+filepath)getFiles(os.getcwd(),0)for f in reversed(all_file):print(f)