python高级 之(四) --- 模块方法

模块

　　时间模块：time/datatime/calendar。

　　系统操作文件模块：os

time模块

• 介绍

 import time

 # 获取当前时间, 结果是存在时间元组中的。星期一是从0开始的
 # 结果：time.struct_time(tm_year=2019, tm_mon=8, tm_mday=22, tm_hour=18, tm_min=21, tm_sec=46, tm_wday=3, tm_yday=234, tm_isdst=0)
 c_time = time.localtime()
 print(c_time)

 # 获取时间元组中指定的时间。比如 年
 year = c_time[0]
 print(year)
 # 获取时间元组中指定的时间。比如 年。根据时间元组中指定的时间字段获取
 year = c_time.tm_year
 print(year)

 # 获取时间戳。指定时间对应的秒数。当前时间对应的时间戳
 now = time.time()
 print(now)

 # 时间格式化。占位格式：
 """
 格式化时间的占位符:
     %Y ---- 年
     %m --- 月
     %d ---- 日
     %H ---- 24小时制
     %I ----- 12小时制
     %p ---- 标记上下午
     %M --- 分
     %S ---- 秒
     %w --- 星期
     %j ----- 一年中的第几天
     %z ---- 时区
 """
 # 将时间元组格式转为指定时间格式
 str_time = time.strftime("%Y-%m-%d %H:%M:%S",c_time)
 print(str_time)

 # 将指定的时间格式转化为时间元组
 time_string = time.strptime(str_time,"%Y-%m-%d %H:%M:%S")
 print(time_string)

 # 获得自定义时间的时间戳
 c_time = time.mktime(time_string)
 print(c_time)

 # 将时间戳转换为时间元组
 time_str = time.localtime(c_time)
 print(time_str)

• 练习

 """
 题干：
     指定时间："2018-10-22 12：15：12"
     在这个时间基础上，获取三天后的时间 "2018-10-25 12：15：12"

 解决：
     1。指定时间 --- 时间元组
     2。时间元组 --- 时间戳
     3。时间戳 + 3天的秒数
     4。新时间戳 --- 时间元组
     5。新时间元组 --- 格式化时间
 """
 import time
 def get_time(src_time):
     time_tuple = time.strptime(src_time,"%Y-%m-%d %H:%M:%S")    # 指定时间 变 时间元组
     c_time = time.mktime(time_tuple)                            # 时间元组 变 时间戳
     new_time = c_time + 3 * 24 * 60 * 60                        # 时间戳 + 3 天
     new_time_tuple = time.localtime(new_time)                   # 时间戳 变 时间元组
     time_str = time.strftime("%Y-%m-%d %H:%M:%S",new_time_tuple)# 时间元组 变 格式时间
     return time_str

 if __name__ == '__main__':
     res = get_time("2018-10-22 13:15:12")
     print(res)

datetime模块

• 介绍

 import datetime

 # 获取当前时间。 结果：2019-08-22 19:19:21.842469
 c_time = datetime.datetime.now()
 print(c_time)

 # 获取日期。结果：2019-08-22
 d_time = datetime.date.today()
 print(d_time)

 # 获取当前时间对应的星期。 结果：3。表示星期四
 w_time = c_time.weekday()
 print(w_time)

 # 获取年、月、日。 结果：2019
 y_time = c_time.year
 print(y_time)

 # 自定义时间。 结果：2018-03-23 00:00:00。时分秒没传默认是零，年月日必须传值
 p_time = datetime.datetime(year=2018,month=3,day=23)
 print(p_time) # 类型：datetime.datetime

 # 获取指定时间的几天后的时间。结果：2018-03-26 00:00:00
 d_time = p_time + datetime.timedelta(days=3)
 print(d_time)  # 类型：datetime.datetime

 # 格式化时间：年/月/日 时 分 秒。结果：字符串类型，2018/03/23 00 00 00
 f_time = p_time.strftime("%Y-%m-%d %H:%M:%S")
 print(f_time) # 类型：str

 # 反格式化时间
 r_time = datetime.datetime.strptime(f_time,"%Y-%m-%d %H:%M:%S")
 print(r_time)  # 类型：datetime.datetime
 print(type(r_time))

 # 使用运算符 "—"。 计算两个时间的时间差. 结果：355 days, 0:00:00
 fr_time = datetime.datetime(2017,12,31)
 se_time = datetime.datetime(2018,12,21)
 diff = se_time - fr_time
 print(diff)

 # 获取相差天数。 结果：355
 days = diff.days
 print(days)

 # 获取时间差差异的秒数。 结果：30672000.0
 tol = diff.total_seconds()
 print(tol)

 # 获取后面时分秒结合起来的秒数，不包括前面的天数。 结果：0
 res = diff.seconds
 print(res)

calendar模块

• 方法

 import calendar # 1900年起始

 # 获取指定年的日历
 y_calendar = calendar.calendar(2018)
 print(y_calendar)

 # 获取指定年 指定月的日历
 m_calendar = calendar.month(2017,12)
 print(m_calendar)

 # 判断该年是否是闰年。 结果：True
 is_leap = calendar.isleap(2000)
 print(is_leap)

 # 获取指定月对应中 把星期作为分割点，一个星期为一个小列表存放在一个大列表中。前面没有数据的话，用零占位。
 # 结果:[[0, 0, 0, 0, 0, 1, 2], [3, 4, 5, 6, 7, 8, 9], [10, 11, 12, 13, 14, 15, 16], [17, 18, 19, 20, 21, 22, 23], [24, 25, 26, 27, 28, 29, 30], [31, 0, 0, 0, 0, 0, 0]]
 res = calendar.monthcalendar(2018,12)
 print(res)

 # 获得某天对应的星期。 结果：3 表示 星期4
 week = calendar.weekday(2018,1,4)
 print(week)

os模块

• 方法

 import os

 """
 相对路径：当前文件所在的目录为参照，
          如果指定文件的路径与参照文件在同一个目录下，获取其相对路径时，直接写文件名即可。
          如果指定文件路径与参照路径不在同一个目录下，起始查找位置是当前文件
 绝对路径：从具体的盘符开始，到指定的文件的路径。 .. 表示上一级；. 表示当前级
 """
 # 获取当前文件所在的相对目录。dir，文件夹目录的意思
 c_path = os.curdir
 print(c_path) # 结果：.

 # 获取当前文件的绝对路基。结果：/Users/guoyapeng/pyword/python_start/day12_模块
 a_path = os.getcwd()
 print(a_path)

 # 获取系统环境变量。结果：environ({'PATH': '/Users/guoyapeng/anaconda3/bin:、、、、、
 envir = os.environ
 print(envir)

 # 获取指定环境变量下某个变量的值。结果：/Users/guoyapeng/anaconda3/bin/conda
 path_value = os.environ.get("CONDA_EXE")
 print(path_value)

• 目录操作

 # 目录操作

 # 相对路径创建目录。 如果参数只有一个文件夹名的话，默认与当前文件夹平级。如果目录已经存在，就会报错。
 os.mkdir("new_dir")

 # 相对路径,在当前级别的上一级创建
 os.mkdir(r"../test1")

 # 绝对路径创建，只能创建最后一级，前面没有相应的目录的话会报错
 os.mkdir(r"/Users/guoyapeng/pyword/python_start/text")

 # 绝对路径创建，只能创建最后一级，前面没有响应的目录的话会会被创建出来
 os.mkdir(r"/Users/guoyapeng/pyword/python_start/text/text/text/text")

 # 删除目录。 删除目录时只能删除空目录，目录中有内容不可删除
 os.rmdir(r"/Users/guoyapeng/pyword/python_start/text/text/text/text")

 # 获得目录下的直接子文件、子目录，结果是列表类型的,列表中存放的是子文件的名字
 sub_list = os.listdir(r"..")
 print(sub_list)

• 文件操作

 # 文件操作
 # 打开或者创建文件
 """
 open()方法：会返回一个操作文件的手柄，通过手柄操作文件指针进行文件读写
     第一个参数：要进行操作文件的路径，在程序中的文件做好使用相对路径
     第二个参数：操作文件的模式，读、写。。。
         r --- 表示的是只读。如果文件路径不存在，会报错
         w --- 表示的是只写。如果文件不存在，会创建文件；文件存在，会将文件中的内容清空
         a --- 表示的是只写。如果文件不存在，会创建文件；文件存在，将新写入的内容拼接在原有内容的后面
         r/w/a --- 表示操作的是字符数据
         r+/w+/a+ --- 可读可写
         rb --- b 表示二进制，加b表示操作的是字节数据
         rb+/wb+/ab+ --- 以二进制形式可读可写
     第三个参数：encoding，设置打开文件的编码方式
 """

 # 返回一个操作文件的手柄，通过手柄操作文件指针进行文件读写
 handle = open(r"./other.py","w",encoding="utf-8")

 # 删除文件
 os.remove(r"./other.py")

 # 获取文件信息描述
 info = os.stat(r"./other.py")
 print(info)

 # 重命名
 os.rename(r"./other.py", r"./test.py")

 # os 模块下有一个path，其下有一些操作文件的内容

 # 获取指定文件的绝对路径 absolute。结果：/Users/guoyapeng/pyword/python_start
 abs_path = os.path.abspath("..")
 print(abs_path)

 # 对路径进行拼接。想获取'day12_模块'的路径。join，第一个参数是：父级目录；第二个参数：要拼接的目录
 path = r"."
 sub_list = os.listdir(path) # 显示所有的子文件、子目录
 res_path = os.path.join(path,sub_list[2])
 print(res_path)  # 相对路径结果：./time_text.py

 # 获得指定路径的扩展名。结果是一个元组
 """
 如果路径对应的是一个文件：
     第一部分：是文件的路径
     第二部分：文件的扩展名
 如果路径对应的是一个文件夹：
     第一部分：是文件夹的路径
     第二部分：是空字符串
 """
 ex_name = os.path.splitext(res_path)
 print(ex_name) # 结果-目录：'../day12_模块', ''); 结果-文件： ('./time_text', '.py')

 # 获取最后一级目录的名字
 base_name = os.path.basename(res_path)
 print(base_name) # 结果：time_text.py

 # 获取除了最后一级的路径
 dir_name = os.path.dirname(res_path)
 print(dir_name) # 结果：.

 # 获取指定文件的大小，单位是 字节
 len = os.path.getsize(base_name)
 print(len) # 结果：947

 # 判断路径指向的文件是否存在
 res = os.path.exists(path)
 print(res) # 结果：True

 # 判断路径指向的文件是否存在
 res = os.path.isfile(base_name)
 print(res) # 结果：True

 # 判断路径指向的是否是一个文件夹
 res = os.path.isdir(base_name)
 print(res) # 结果 False

 # 判断路径是否使用的是绝对路径
 res = os.path.isabs(dir_name)
 print(res)  # 结果：False

获取指定目录下的所有文件

• 普通获取

 import os
 """
 获取指定目录下的所有文件
     包含 子文件、次级子文件、次次级子文件 都得获取到
 注意：
     现在的方法中只能获取直接子文件

 """

 path = r".."
 # 获取直接子文件
 sub_list = os.listdir(path)
 print(sub_list)
 # 遍历列表
 for file_name in sub_list:
     # 需要判断file_name指定的是否是一个文件
     # 注意：如果设置路径的时候，只写的是路径的文件名字，表示这个文件与当前文件是平级的
     # 需要进行路径拼接。根据上一级目录 和 自己的名字拼接出全路径
     all_path = os.path.join(path,file_name)
     if os.path.isfile(all_path):
         print("---",all_path)
     elif os.path.isdir(all_path):
         # 获取子文件夹下的所有子目录
         sub_sub_list = os.listdir(all_path)
         # 遍历
         for sub_file_name in sub_sub_list:
             join_path = os.path.join(all_path,sub_file_name)
             if os.path.isfile(join_path):
                 print(join_path)

• 递归获取

 """
 上面的代码重复：查找目录下子文件这个功能代码是重复的。可以把查找子文件的代码封装成一个函数
 """
 """
 递归的出口： 不用再调用自己了。最后一级目录下全部是文件，或者是空目录
 """
 def get_all_file(path):
     # 获得路径下的所有直接子文件
     sub_list = os.listdir(path)
     # 遍历
     for file_name in sub_list:
         # 路径拼接
         join_path = os.path.join(path,file_name)
         # 判断这个目录指向的是否是一个文件
         if os.path.isfile(join_path):
             print(join_path)
         else:
             get_all_file(join_path)

 get_all_file(r"..")

 """改进： 全面化"""
 def get_all_file(path):
     # 判断path指定的路径是否存在
     if os.path.exists(path):
         # 获得路径下的所有直接子文件
         sub_list = os.listdir(path)
         # 遍历
         for file_name  in sub_list:
             # 路径拼接
             join_path = os.path.join(path,file_name)
             # 判断这个路径指向的是否是一个文件
             if os.path.isfile(join_path):
                 print(join_path)
             else:
                 get_all_file(join_path)
     else:
         print("路径不存在，请检查路径")

 get_all_file(r"..")

删除指定目录下的所有文件

• 普通删除

 # 假设目录下都是文件
 path = r"./a"
 # 获取子文件
 sub_list = os.listdir(path)
 print(sub_list) # 结果：['2.txt', '1.txt']
 for file_name in sub_list:
     # 拼接路径
     join_path = os.path.join(path,file_name)
     if os.path.isfile(join_path):
         # 移除文件
         os.remove(join_path)
 # 当遍历执行完毕，目录中的内容就被清空
 # 移除之后查看path指定的路径是否还有子文件
 print(os.listdir(path)) # 结果：[]
 os.rmdir(path)

 # 一个目录下既有文件，又有文件夹
 # a/1.txt；a/b/2.txt
 path = r"./a"
 # 获取它下面的子文件和子目录
 sub_list = os.listdir(path)
 print(sub_list) # 结果：['1.txt', 'b']
 # 遍历
 for file_name in sub_list:
     # 路径拼接
     join_path = os.path.join(path,file_name)
     if os.path.isfile(join_path):
         # 移除文件
         os.remove(join_path)
     elif os.path.isdir(join_path):
         # 获取b文件夹下的子文件和子目录
         b_sub_list = os.listdir(join_path)
         # 遍历
         for b_file_name in b_sub_list:
             # 拼接
             b_join_path = os.path.join(join_path,b_file_name)
             if os.path.isfile(b_join_path):
                 os.remove(b_join_path)

         # 出了遍历，删除b目录
         os.rmdir(join_path)
 # a中空了
 os.rmdir(path)

• 递归删除

 """
 上述代码可以看出：遍历文件夹删除文件夹中的文件的功能是重复的。可以把这个功能封装成函数
 """

 def delete_dir(path)
     if os.path.exists(path):
         # 获得指定路径下的子文件和子目录
         sub_list = os.listdir(path)
         # 遍历
         for file_name in sub_list:
             # 拼接出file_name对应的真实路径
             join_path = os.path.join(path,file_name)
             # 判断这个路径指向的是否是一个文件
             if os.path.isfile(join_path):
                 #移除文件
                 os.remove(join_path)
             # 判断是否是目录，若是，递归遍历该目录
             elif os.path.isdir(join_path):
                 delete_dir(join_path)
         # 当遍历走完，该目录就是一个空目录
         os.rmdir(path)
     else:
         print("路径不存在，请从新设置")

深度遍历广度遍历

 # 深度遍历
 """
 需要借助 栈 的数据结构来完成。将要进行遍历的目录压栈。
 栈的特点：先进后出。借助借助列表模拟栈
 """

 # 广度遍历
 """
 需要借助 队列 数据结构来完成。
 队列特点：先进先出。collections模块下的dequeue队列类
 """

 """
 题干: 获取a下的所有文件
     a
         1.txt
         2.txt
         b
             3.txt
             c
                 4.txt
         b1
             5.txt
             d
                 6.txt
                 e
                     7.txt
 """

• 深度遍历

 import os
 # 深度遍历。列表模拟，先进后出

 def show_all_file(path):
     if os.path.exists(path):
         # 声明一个栈
         stack = []
         # 将即将遍历的主路径存放于栈中
         stack.append(path)
         # 遍历栈，---当栈中没有数据的时候，结束遍历
         while len(stack) != 0:
             # 取出栈中数据进行遍历
             data_path = stack.pop()
             # 获取该目录下的子文件和子目录
             sub_list = os.listdir(data_path)
             for file_name in sub_list:
                 # 拼接真实的路径
                 join_path = os.path.join(data_path,file_name)
                 # 进行判断是否是文件
                 if os.path.isfile(join_path):
                     print(join_path)
                 elif os.path.isdir(join_path):
                     # 若是目录，将其压入栈中
                     stack.append(join_path)
     else:
         print("路径不存在")

 show_all_file(r"./a")

• 广度遍历

 import os
 from collections import deque
 # 广度遍历。队列模拟，先进先出

 def show_all_file(path):
     if os.path.exists(path):
         queue = deque() # 声明一空队列
         # 将即将遍历的路径存放于队列中
         queue.append(path)
         # 当队列中空了，没有数据了，停止遍历
         while len(queue) != 0:
             # 取出即将遍历的目录
             data_path = queue.popleft()
             # 获取目录下的子文件和子目录
             sub_list = os.listdir(data_path)
             # 遍历
             for file_name in sub_list:
                 # 拼接
                 join_path = os.path.join(data_path,file_name)
                 # 进行判断
                 if os.path.isfile(join_path):
                     print(join_path)
                 elif os.path.isdir(join_path):
                     # 若是目录，压入到队列中
                     queue.append(join_path)
     else:
         print("路径不存在")

 show_all_file(r"./a")