python3 基础（5）-模块（1）-

模块介绍

1. 补充：

1. 通过os模块获取各种路径（目录）

   import os print(__file__)   #返回程序的相对路径 print(os.path.abspath(__file__))   #返回程序的绝对路径 print(os.path.dirname(os.path.abspath(__file__)))   #返回程序所在位置的父目录 print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))  #返回程序所在位置的父目录的父目录 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) print("----------------------------") #输出 D:/PycharmProjects/day04/Atm/bin/atm.py D:\PycharmProjects\day04\Atm\bin\atm.py D:\PycharmProjects\day04\Atm\bin D:\PycharmProjects\day04\Atm ----------------------------

2. 将路径（环境变量）添加到sys.path列表中：

   即：当sys.path路径列表没有你想要的路径时，可以通过 sys.path.append('路径') 添加。

   注：程序搜索路径时，从sys.path列表的左边顺序搜索到右边，直到有匹配的

   import os,sys print(sys.path) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  #返回程序所在位置的父目录的父目录 print(BASE_DIR) sys.path.append(BASE_DIR)   #追加环境变量到列表末尾，有时可用insert插入指定位置 print(sys.path) print("----------------------------") #输出 ['D:\\PycharmProjects\\day04\\Atm\\bin', 'D:\\PycharmProjects', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\python36.zip', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\DLLs', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\lib', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages'] D:\PycharmProjects\day04\Atm ['D:\\PycharmProjects\\day04\\Atm\\bin', 'D:\\PycharmProjects', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\python36.zip', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\DLLs', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\lib', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32', 'C:\\Users\\Thinkpad\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages', 'D:\\PycharmProjects\\day04\\Atm'] ----------------------------

2. 模块的定义：

   用来从逻辑上组织python代码，形式上就是以.py结尾的python文件（例：文件名为test.py，则模块名就为test）。可以包含内容（代码块）：变量、函数、类、逻辑等；Python之所以应用越来越广泛，在一定程度上也依赖于其为程序员提供了大量的模块以供使用。

3. 作用：

   实现程序需要的某个功能

4. 模块的分类：（后面有详细介绍）

1. 内置标准模块（又称标准库）

2. 开源模块

3. 自定义模块

模块导入这里主要讲自定义模块的导入

1. 导入模块（包括方法属性）的方式：

1. 同级（相同目录）导入

1. main.py程序对module_hello等模块及方法属性的调用？

   
   

   #导入模块   #将模块里的所有方法属性拿到当前程序执行一遍 import module_hello   #单独导入一个模块 import module_hello,module2,module3   #导入N个模块 #调用模块的方法属性：模块.属性 print(module_hello.name) module_hello.say_hello()

   #导入模块中的方法属性    #将模块里的某个或某些方法属性拿到当前程序执行一遍 from module_hello import *      #导入模块中的所有属性,建议不用 from module_hello import loggin   #从一个模块中单独导入某个方法属性 from module_hello import loggin,m2,m3   #从一个模块中导入N个方法属性 from module_hello import loggin as loggin_new #从一个模块中单独导入某个方法属性，并重命名 #调用模块的方法属性：属性 loggin_new() loggin()

2. 不同级导入

1. atm.py程序对main模块和atm_test模块及方法属性的调用？

   
   

   import os,sys BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(BASE_DIR) print("----------------------------") #导入模块或某些属性的操作 import atm_test   #导入模块 atm_test atm_test.test() print(atm_test.a) from atm_test import a   #导入模块的属性a print(a) print("----------------------------") #导入包下的模块或包下的包的操作 #方式一 from core import main   #从包core导入模块main；如果main是一个包，也用from main.login() #方式二 import core   #导入目录（包），执行的是目录下的__init__.py文件，               #所以将模块main先导入__init__.py文件               #使用 from . import main core.main.login() #输出 ---------------------------- this is Atm/atm_test.py atm_test atm_test ---------------------------- this is Atm/core/__init__.py Welcome to ICBC ATM Welcome to ICBC ATM ----------------------------

2. 导入模块（包括方法属性）的本质

1. Python解释器把被导入的“模块名.py”文件解释一遍

2. 过程：确定模块名.py文件-->搜索“模块名.py”文件路径-->sys.path路径列表（当前路径在列表的[0]位，当调用模块时，会先在程序当前路径搜索相应文件）

3. 知识补充：

1. 包的定义：用来从逻辑上组织模块（N个模块的集合），形式就是一个目录（必须带有一个__init__.py文件）

2. 包的导入：import 目录名；Python解释器解释该包下的 __init__.py 文件

3. 实例：执行main.py调用包package_test（因为不同级调用，所以这里要先确定路径）

   
   

4. 导入包的本质：执行包下的__init__.py文件。如果包内有多个模块，可以先将这些模块先导入到__init__.py文件里，这样“import 目录名”就可以调用包里的模块功能了

4. 问题：

当程序中当前定义的函数（再如变量、类等）名和导入模块的方法属性相同时，程序最终应用谁的结果？当然是后执行的结果，相当于后定义或后导入的会覆盖前面的。

5. 导入优化

1. 直接导入模块的某个或某些属性比导入整个模块执行效率高，特别是被程序多次调用时。

自定义模块

开源模块

    下载、安装、导入、使用。

    如：paramiko模块

    自定义模块和开源模块的使用参考 http://www.cnblogs.com/wupeiqi/articles/4963027.html 

标准模块（标准库）

time与datetime模块

1. 与时间处理有关的模块就包括：time，datetime以及calendar。

2. 世界标准时间，UTC（Coordinated Universal Time，世界协调时）亦即格林威治天文时间。在中国时间为UTC+8。DST（Daylight Saving Time）即夏令时。

3. 在Python中，time模块实现主要调用C库，所以各个平台可能有所不同。通常有这几种方式来表示时间：

1. 时间戳 （timestamp）方式：以秒计算的浮点数。通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。可以返回时间戳的函数主要有time()，clock()等。我们运行“type(time.time())”，返回的是float类型。

2. 格式化的时间字符串

3. 元组（struct_time）方式：struct_time元组共有9个元素。可以返回struct_time的函数主要有gmtime()，localtime()，strptime()。下面列出struct_time中的几个元素：

   属性（Attribute）	值（Values）
   tm_year（年）	如2018
   tm_mon（月）	1 - 12
   tm_mday（日）	1 - 31
   tm_hour（时）	0 - 23
   tm_min（分）	0 - 59
   tm_sec（秒）	0 - 61
   tm_wday（weekday）	0 - 6（0表示周一）
   tm_yday（一年中的第几天）	1 - 366
   tm_isdst（是否是夏令时）	默认为-1

4. 格式化时间的格式表

   格式	含义	备注
   年
   %y	去掉世纪的年份（00 - 99）
   %Y	完整的年份
   月
   %m	一年中的第几个月（01 - 12）
   %b	一年中的第几个月，月份的英文简化名称，如“Jun”
   %B	一年中的第几个月，月份的英文完整名称，如“April”
   日
   %d	一个月中的第几天（01 - 31）
   %j	一年中的第几天（001 - 366）
   %w	一个星期中的第几天（0 - 6，0是星期一）
   %a	一个星期中的第几天，星期的英文简化名称，如“Sun”
   %A	一个星期中的第几天，星期的英文完整名称，如“Wednesday”
   周
   %U	一年中的第几个星期（00 - 53 ）。（星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。	当使用strptime()函数时，只有当在这年中的周数和天数被确定的时候%U才会被计算。
   %W	和%U基本相同，不同的是%W以星期一为一个星期的开始。	当使用strptime()函数时，只有当在这年中的周数和天数被确定的时候%W才会被计算。
   小时
   %H	一天中的第几个小时（24小时制，00 - 23）
   %I	一天中的第几个小时（12小时制，01 - 12）
   分
   %M	分钟数（00 - 59）
   秒
   %S	秒（01 - 61）	不是59，因为闰年秒占两秒
   组合日期时间
   %c	日期和时间，同"%a %b %d %H:%M:%S %Y"
   %x	日期，如：04/04/18
   %X	时间，如：14:20:48
   其他
   %p	本地am或者pm的相应符	与“%I”配合使用才有效果
   %Z	时区的名字（如果不存在为空字符）
   %%	‘%’字符

5. time模块中常用的几个函数：

   import time # 获取时间戳 # time.time()：返回当前时间的时间戳，以秒为单位。 t = time.time() print(t) print(type(t)) d = t/60/60/24 print(d) # time.sleep(secs)：线程推迟指定的时间运行。单位为秒。 # time.clock()：返回时间戳。这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为精确） time.sleep(1) print("clock1:%s" % time.clock())  #其中第一个clock()输出的是程序运行时间 time.sleep(1) print("clock2:%s" % time.clock())  #第二、三个clock()输出的都是与第一个clock的时间间隔 time.sleep(1) print("clock3:%s" % time.clock()) # time.mktime(t)： 将一个struct_time转化为时间戳。 t = time.mktime(time.localtime()) print(t) t = time.mktime(time.gmtime()) print(t) t = time.mktime(time.strptime("2018-04-03 16:29:28","%Y-%m-%d %H:%M:%S")) print(t) print("------------1-------------") # 获取struct_time # time.localtime([secs])：将一个时间戳转换为当前时区的struct_time。 # 如果secs参数未提供，则以当前时间为准。 t = time.localtime()  #同time.localtime(time.time()) print(t) print(t.tm_year) t = time.localtime(1304575584.1361799) print(t) print(t.tm_year) print(t.tm_wday) # time.gmtime([secs])：将一个时间戳转换为UTC时区（0时区）的struct_time,和localtime()方法类似 t = time.gmtime() print(t) print(t.tm_mday) # time.strptime(string[, format])：把一个格式化时间字符串转化为struct_time。 # 实际上它和strftime()是逆操作； # 前面格式必须一一对应后面格式； # 在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。 t = time.strptime('Sun Jun 5 16:37:06 2011') print(t) t = time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X') print(t) t = time.strptime('16:37:06', '%X')   #此时年月日默认为19000101 print(t) t = time.strptime("2018-04-03 16:29:28","%Y-%m-%d %H:%M:%S") print(t) print("------------2-------------") # 获取格式化时间字符串 # time.strftime(format[, t])：把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串； # 如果t未指定，将传入time.localtime()。 # 如果元组中任何一个元素越界，ValueError的错误将会被抛出。 t = time.strftime("%m%d %H:%M:%S%Y") print(type(t)) print(t) t = time.strftime("%Y%m%d %H:%M:%S",time.localtime()) print(t) t = time.strftime("%Y%m%d %H:%M:%S",time.gmtime()) print(t) t = time.strftime("%Y-%m-%d %X",time.localtime()) print(t) t = time.strftime("%m-%d-%Y.  %b %d %Y is a %A on the %d day of %B.") print(t) t = time.strftime("%c",)   #同time.strftime("%a %b %d %H:%M:%S %Y") print(t) t = time.strftime("%c",time.gmtime()) print(t) t = time.strftime("%x",time.gmtime()) print(t) t = time.strftime("%H",) print(t) t = time.strftime("%H",time.gmtime()) print(t) print("------------3-------------") # 获取这种形式："%a %b %d %H:%M:%S %Y" # time.asctime([t])：把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'; # 如果没有参数，将会将time.localtime()作为参数传入。 t = time.asctime()  #同time.asctime(time.localtime()) print(t) t = time.asctime(time.localtime(23456765.24543)) print(t) t = time.asctime(time.strptime("2017-10-08 23:04:20", "%Y-%m-%d %H:%M:%S")) print(t) # time.ctime([secs])：把一个时间戳转化为time.asctime()的形式; # 如果参数未给或者为None的时候，将会默认time.time()为参数。 t = time.ctime() #同time.ctime(time.time()) print(t) t = time.ctime(23456765.24543) print(t) print("------------4-------------") #补充 print(time.clock()) #返回处理器时间,3.3开始已废弃 , 改成了time.process_time()测量处理器运算时间,不包括sleep时间,不稳定,mac上测不出来 print(time.altzone)  #返回与utc时间的时间差,以秒计算\ print(time.gmtime(time.time()-800000)) #返回utc时间的struc时间对象格式 print("------------5-------------")

6. time各表示方式的转化关系图：

   
   

7. 补充：datetime模块

1. 支持日期和时间简单和复杂的方法；

2. 实现的重点放在更有效的处理和格式化输出；

3. 该模块还支持时区处理:

   import datetime print(datetime.date.today())   #获取今天日期 print(datetime.datetime.now()) #获取当前格式化日期时间 print(datetime.datetime.fromtimestamp(time.time()) )  # 时间戳直接转成日期时间格式 print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 # 时间加减 print(datetime.datetime.now()) print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天 print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天 print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时 print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分 # 时间替换 c_time  = datetime.datetime.now() print(c_time.replace(minute=3,hour=2)) #时间替换，将原来获取的时间替换成指定的时间 #格式化输出 now = datetime.date.today() print(now.strftime("%c")) print(datetime.datetime.now().strftime("%A, %B %d %Y")) print("------------6-------------") # 实例 # 计算年龄 import datetime now = datetime.date.today() birthday = datetime.date(1989,8,16) age = now - birthday print(age.days/365) print("------------7-------------")

ramdom模块

1. 提供了生成随机数的功能

   import random #返回一个随机浮点数： print(random.random())  #用于随机生成一个0到1的符点数: 0 <= n < 1.0 print(random.uniform(1,10))   #用于随机生成一个指定范围内的符点数 #返回一个随机整数： print(random.randint(1,10))  #用于随机生成一个指定范围内的整数 a <= n <= b，其中参数a是下限，参数b是上限 print(random.randrange(1,10)) #从指定范围内range([start], stop[, step])，按指定步长递增的列表中，随机获取一个整数。 print(random.randrange(1, 100, 5)) #返回一个随机字符 print(random.choice('zhenxingzhonghua')) #从序列sequence中获取一个随机元素。序列有字符串、列表、元组等 print(random.choice("学习Python")) #返回一个随机字符串 print(random.choice(["JGood","is","a","handsome","boy"])) #从序列sequence中获取一个随机元素。 print(random.choice(("zhangsan","lisi","wangwu"))) #返回一个指定数量的随机字符的列表 print(random.sample([1,2,3,4,5],3))  #从指定序列sequence中随机获取指定数量k的片断列表。sample函数不会修改原有序列。 print(random.sample("xinzhong",5)) #洗牌 items = [1,2,3,4,5,6,7] print(items) random.shuffle(items) print(items) print("----------------------------") #输出 0.1516067281469653 8.132218238196891 2 3 21 u n a zhangsan [3, 2, 4] ['x', 'h', 'n', 'i', 'n'] [1, 2, 3, 4, 5, 6, 7] [3, 2, 7, 4, 6, 1, 5] ----------------------------

2. 实例：

   import random #随机生成一个0到100间的偶数： print(random.randrange(0, 100, 2)) #生成随机验证码： checkcode = '' for i in range(4):    current = random.randrange(0,4)    if current != i:        temp = chr(random.randint(65,90))    else:        temp = random.randint(0,9)    checkcode += str(temp) print (checkcode) print("----------------------------") #输出 20 84YW ----------------------------

os模块

1. 提供了不少与操作系统相关联的函数。

2. 提供了非常丰富的方法用来处理文件和目录。

3. 补充：表示路径path的方式（window平台下）

   #相对路径 os.属性("test\\test1\\test2") os.属性(r"test\test1\test2") os.属性("test/test1/test2") os.属性("./test/test1/test2") #绝对路径 os.属性("E:\\test") os.属性(r"E:\test") os.属性("E:/test") os.属性(".")   #属于什么路径？ os.属性("..")

4. 方法实例：

   更多参考：https://docs.python.org/3.6/library/os.html?highlight=os#module-os

   import os #获取当前程序的工作目录 p = os.getcwd() #获取当前工作目录，即当前python脚本执行的目录路径；相当于shell下pwd print(p) p = os.curdir  #以字符串"."的形式获取当前工作目录 print(p) p = os.pardir  #以字符串".."的形式获取当前工作目录的父目录 print(p) print(os.getcwd()) #更改当前程序的工作目录 os.chdir("E:/test")   #改变当前脚本工作目录为E:\test；相当于shell下cd print(os.getcwd()) print("-------------1---------------") #创建目录 os.makedirs('dirname1/dirname2')    #创建多级目录。当前工作目录下创建多层递归目录；若文件已存在时，则无法创建文件 #os.makedirs("d:/test/a/b/c/d")    #指定目录“d:/test”下创建多层递归目录；若文件已存在时，则无法创建文件 os.mkdir('dirname3')    #创建单级目录；当前工作目录下创建一层目录；相当于shell中mkdir dirname #os.mkdir("d:/test/a1")  #指定目录("d:/test/")下生成单级目录； #删除空目录 os.removedirs('dirname1/dirname2')    #删除多级目录。若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推；目录不是空的删除会报错 os.rmdir('dirname3')    #删除单级空目录，若目录不为空则无法删除；目录不是空的删除会报错；相当于shell中rmdir dirname #列表方式获取目录下的所有文档 l = os.listdir()    #列出当前工作目录的所有文件和子目录，包括隐藏文件，并以列表方式打印 print(l) l = os.listdir(".") print(l) l = os.listdir("./abc") print(l) l = os.listdir("..") print(l) l = os.listdir("d:/test")   #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印 print(l) #删除文件 os.remove("E:/test/a.txt")  #删除指定路径下的一个文件，文件不存在会报错 #重命名文件/目录 os.rename("oldname","newname")  #重命名指定路径下的目录；这里为当前路径；文件不存在会报错 os.rename("oldname.txt","newname.txt")  #重命名指定路径下的文件；这里为当前路径；文件不存在会报错 print("-------------2---------------") #获取文件或目录信息 s = os.stat('newname')  #获取文件/目录信息，创建日期、修改日期等；文件不存在会报错 print(s) #获取分隔符 s = os.sep    #输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/" print(s) l = os.linesep    #输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n" print(l) p = os.pathsep    #输出用于分割文件路径的字符串；看系统环境变量os.environ #PATH print(p) #查看当前使用系统平台 n = os.name    #输出字符串指示当前使用平台。win->'nt'; Linux->'posix' print(n) #运行当前使用系统平台的命令 #os.system("bash command")  #运行shell命令，直接显示 os.system("dir") s = os.system("ipconfig /all") print(s) #获取系统环境变量 e = os.environ  #获取系统环境变量 print(e) print("-------------3---------------") #获取路径（获取目录、文件名）  #os.chdir("E:/test")改变工作目录后，terminal和pycharm的执行结果有差异？？？？？？？？？ #不要求路径存在；路径（文件或目录）不存在不会报错，正常执行 p = os.path.abspath("bbbbb")  #返回指定path的规范化的绝对路径 print(p) print(__file__)   #返回当前程序的相对路径 p = os.path.abspath(__file__)  #返回当前程序的绝对路径 print(p) s = os.path.split(__file__)  #将当前路径分割成两段，以二元组形式返回（"路径/目录","目录名/文件名"） print(s) s = os.path.split(os.path.abspath(__file__))  #将路径path分割成两段，以二元组形式返回（"路径/目录","目录名/文件名"） print(s) s = os.path.split("")  #将路径path分割成两段，以二元组形式返回（"",""），这里两个都是空 print(s) s = os.path.split("d:/abc/abc/ttt.txt")  #将路径path分割成两段，以二元组形式返回（"路径/目录","目录名/文件名"） print(s) s = os.path.split("d:/abc/abc")  #将路径path分割成两段，以二元组形式返回（"路径/目录","目录名/文件名"） print(s) dp = os.path.dirname("d:/abc/abc")  #返回路径path的目录。其实就是os.path.split(path)的第一个元素 print(dp) bp = os.path.basename("d:/abc/abc")  #返回路径path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素 print(bp) #身份判断 print(os.path.exists("d:/test"))  #如果路径path存在，返回True；如果path不存在，返回False print(os.path.isabs("d:/test"))  #如果路径path是绝对路径，返回True print(os.path.isfile(r"E:\test\abc\abc.txt"))  #如果路径path是一个存在的文件，返回True。否则返回False print(os.path.isdir("d:/test"))  #如果路径path是一个存在的目录，则返回True。否则返回False #组合路径 # os.path.join(path1[, path2[, ...]])  #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 p = os.path.join(r"E:\test",r"abcaa",r"aaaabc.txt") print(p) #获取文件或者目录的最后存取、修改时间 print(os.path.getatime(r"E:\test\abc\abc.txt"))  #返回路径path所指向的文件或者目录的最后存取时间 print(os.path.getmtime(r"E:\test\abc"))  #返回路径path所指向的文件或者目录的最后修改时间

sys模块

1. sys

   import sys a = sys.argv   #包含命令行参数的列表，第一个元素是程序本身路径（绝对或相对）， print(a[0]) print(a[1]) print(a[2]) print(type(a)) print(a) print(sys.version)   #获取Python解释程序的版本信息 # sys.maxint         #最大的Int值 ？？？？？ print(sys.path)   #包含了一个提供给Python解释器自动查找所需模块的路径的列表，初始化时使用PYTHONPATH环境变量的值 print(sys.platform)       #返回操作系统平台名称 sys.stdout.write('please:') val = sys.stdin.readline()[:-1]                       # ？？？？？？？？？？ sys.exit(1)        #退出程序，正常退出时exit(0)            ？？？？？？？？？

shutil模块

1. 高级的 文件、文件夹、压缩包 处理模块

   import shutil # copyfileobj(fsrc, fdst[, length]) # 将文件内容拷贝到另一个文件中 # 可以拷贝部分内容；当fdst不存在时，会自动创建 f1 = open("歌词1","rb") f2 = open("歌词2","wb") shutil.copyfileobj(f1,f2) # 或 f1 = open("歌词1","r",encoding="utf-8") f2 = open("歌词2","w",encoding="utf-8") shutil.copyfileobj(f1,f2) # copyfile(src, dst) # 拷贝文件 # src要存在 shutil.copyfile("歌词1","歌词3") # copymode(src, dst) # 仅拷贝权限 # 内容、组、用户均不变 # 去linux系统平台验证 # copystat(src, dst) # 拷贝部分状态信息 # 包括：mode bits, atime, mtime, flags等 #要求src, dst都存在 # 去linux系统平台验证权限变化 shutil.copystat("歌词1", r"E:\test\abc\abc.txt") # copy(src, dst) # 拷贝文件和权限 # copy2(src, dst) # 拷贝文件和状态信息 # ignore_patterns(*patterns)    ？？？？ # copytree(src, dst, symlinks=False, ignore=None) # 递归的去拷贝目录/文件 # 例如：copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*')) shutil.copytree("test","test_copy") # rmtree(path[, ignore_errors[, onerror]]) # 递归的去删除目录/文件 # 要求src要存在 shutil.rmtree("test_copy") # move(src, dst) # 递归的去移动文件/目录 # 要求src要存在 shutil.move("test2.zip","package_test")   #移动文件或目录到其他目录 shutil.move("testtest","testtest2")   #重命名文件/目录 shutil.move("make_archive_test2.zip","package_test\make_archive_test5.txt")   #移动并重命名 # make_archive(base_name, format,...) # 创建压缩包，并返回文件路径 # base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径， # 如：www                        =>保存至当前路径 # 如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/ # format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar” # root_dir： 要压缩的文件夹路径（默认当前目录） # owner： 用户，默认当前用户 # group： 组，默认当前组 # logger： 用于记录日志，通常是logging.Logger对象 # shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的 # 可以使用ZipFile 和 TarFile 两个模块将文档单独加入到已有的压缩文件中去 shutil.make_archive("make_archive_test2","zip","test")   #将当前目录下的文档压缩到当前目录 a = shutil.make_archive("./test/make_archive_test","zip",r"e:\test") print(a)   #返回压缩文档的路径