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")