1.听写

1.使用列表生成式生成列表
原列表: ["hello", "jack", True, 10, "look"] 提取字符串数据
	list2 = [item for item in list0 if isinstance(item, str)]
	print(list2)	
2.利用高阶函数 完成上述的筛选
	list(filter(lambda x: isinstance(x,str), list0))

2.今日概述

常用模块:

time

datetime

calendar

os ---> 操作计算机文件的

文件读写[普通文件的读写]

3.time

关于时间的模块

导入模块 import time

import time
# 获得当前时间 ---> 对应的时间元组
tuple_time = time.localtime()
print(tuple_time)

# 在时间元组中获得对应每一个想要获取的内容
#1.通过脚标
year = tuple_time[0]
print(year)

#2.通过字段名来获取
year = tuple_time.tm_year
print(year)

# 获得当前时间对应的描述 [时间戳] 距离1970年1月1日凌晨的秒数
current_second = time.time()
print(current_second)

'''
涉及到知识点 时间格式化
第一个参数放置的是时间格式化
第二个参数是要进行时间格式化的元组
'''
format_time = time.strftime("%Y/%m/%d %H:%M:%S %j %A", tuple_time)
print(format_time)

# 将对应指定的格式化后的时间转化为时间元组
format_time_1 = "2018-09-05 10:45:32"
tuple_time_1 = time.strptime(format_time_1, "%Y-%m-%d %H:%M:%S")
print(tuple_time_1)

# 获得自定义时间对应的秒数
cus_second = time.mktime(tuple_time_1)
print(cus_second)

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

'''
根据指定的格式化时间 获得其三天后对应的时间
2018-05-02 17:22:33 ---> 2018-05-05 17:22:33
'''
def get_delay_daytime(format_timestr, days):
    # 将格式化的时间转化为时间元组
    time_tuple = time.strptime(format_timestr, "%Y-%m-%d %H:%M:%S")
    # 将时间元组转化为时间戳
    time_seconds = time.mktime(time_tuple)
    # 在时间戳的基础上夹加上days对应的秒数
    end_seconds = time_seconds + days * 24 * 3600
    # 在最后时间戳的基础上转化为时间元组
    end_time_tuple = time.localtime(end_seconds)
    # 根据时间元组转化为最终的格式化时间
    end_format_time = time.strftime("%Y-%m-%d %H:%M:%S", end_time_tuple)
    return end_format_time
res = get_delay_daytime("2018-05-02 17:22:33", 3)
print(res)

4.datetime

import datetime
#1. 获取当前时间
current_time = datetime.datetime.now()
print(current_time)

#2. 获得当天的日期
current_day = datetime.date.today()
print(current_day)

#3. 根据获得的日期 获得星期数
week = current_day.weekday()
print(week)

# 自定义时间
# 时分秒 不传的话 默认是凌晨
cus_time = datetime.datetime(2018, 6, 27)
print(cus_time)

cus_time = datetime.datetime(2018, 6, 27, 10, 34, 51)
print(cus_time)

# 获得自定义时间 两天前对应的时间
get_time = cus_time + datetime.timedelta(days=3)
print(get_time)
print(type(cus_time))

# 时间格式化字符串类型
format_time = get_time.strftime("%Y/%m/%d %p %I:%M:%S")
print(format_time)

# 将格式化的时间转化为datetime的时间
time_date = datetime.datetime.strptime(format_time, "%Y/%m/%d %p %I:%M:%S")
print(time_date)

# 求两个时间的时间差
time1 = datetime.datetime(2018, 7, 12, 12, 22, 18)
time2 = datetime.datetime(2018, 8, 7, 10, 32, 19)
defferent_time = time2 - time1
print(defferent_time)

# 获得时间差中的天数
day = defferent_time.days
print(day)

# 获得时间差中的总秒数
seconds = defferent_time.total_seconds()
print(seconds)

5.calendar

import calendar
# 获得指定年的日历
year_calendar = calendar.calendar(2018)
print(year_calendar)

# 获得指定某个月的日历格式
month_calendar = calendar.month(2018, 8)
print(month_calendar)

# 判断年的平润性
is_leap = calendar.isleap(1998)
print(is_leap)

# 获得列表 列表中存放的是日期对应的数据格式
res = calendar.monthcalendar(2018, 8)
print(res)

# 获得某天对应星期
res = calendar.weekday(2018, 8, 1)
print(res)	# [0, 6] 0表示星期一

6.os

import os
#1. 获得当前计算机操作系统的名字
sys_name = os.name
print(sys_name)
#nt ---> windows，posix ---> Mac/Linux

#2. 获得操作系统对应的信息 window系统不支持
sys_info = os.uname()
print(sys_info)
'''
"/Applications/Python 3.7/IDLE.app/Contents/MacOS/Python" /Users/chenxin/Desktop/Fighting。/D11/practice.py
posix.uname_result(sysname='Darwin', nodename='localhost', release='17.5.0', version='Darwin Kernel Version 17.5.0: Mon Mar  5 22:24:32 PST 2018; root:xnu-4570.51.1~1/RELEASE_X86_64', machine='x86_64')
'''
#3. 获得设置的环境变量
environ = os.environ
print(environ)

#4. 获得指定字段设置的环境变量的值
path_value = os.environ.get("path")
print(path_value)

r'''
路径的分类:
    绝对路径
        从盘符开始 到具体指定的某个文件的路径
        r"c:\users\11143\documents\课堂内容\BJ_Python1811\nay11\Day11\os_pack\os_demo.py"
    相对路径
        参照物的 ---> 当前文件所在目录
        .       ---> 当前文件所在目录
        ..      ---> 当前文件所在的上一级目录
        目录系统
            Day11
                os_pack [现在所在的目录]
                    os_demo.py
                    os_demo1.py 
                time_pack
                    time_demo.py
                    datetime_demo.py
                    calendar_demo.py
                listen.py
                ..\time_pack\time_demo.py
            ..\listen.py
            os_demo1.py
'''
# 获得当前文件所在的目录
dir_path = os.curdir
print(dir_path)		# . 当前路径 相对路径中

# 当前文件所在的绝对目录 C:\Users\11143\Documents\讲课内容\BJ_Python1811\day11\Day11\os_pack
absolute_path = os.getcwd()
print(absolute_path)

# 格式化 多行注释也可以单做字符串显示
res = '''
要保持数据的原有书写格式
例如:
换行也要显示出来出来
'''
print("要保持数据的原有书写格式\n例如:\n换行也要显示出来出来")
print(res)


# 获得指定目录下所有直接子文件或则子目录的名字
# 相对路径 使用项目中某些文件最好使用相对路径
# path = r".."
# 绝对路径
path = r"C:\Users\11143\Documents\讲课内容\BJ_Python1811\day11\Day11"
file_list = os.listdir(path)
print(file_list)

'''
1. 创建目录
    mkdir ---> make directory
'''
# 参数放置的是路径 如果只写了一个名字 利用相对路路径
# os.mkdir("test_dir") 如果已经存在 就不能再使用该方法创建了
# 如果使用绝对路径 只能创建最后一级目录
# os.mkdir(r"C:\Users\11143\Documents\讲课内容\BJ_Python1811\day11\Day11\os_pack\test_abs")
path = r"test_dirs_1\test_dirs_subdir"
# 创建多级目录
# os.makedirs(path)

# 删除目录：只能删除最后一级目录 而且该目录必须是一个空目录
# os.rmdir(path)

# 打开文件 生成一个与文件关联的操作手柄
'''
如果打开模式是r读的形式 该文件必须存在
模式 mode:
    r  --- 只读
    w  --- 只写
    		如果文件不存在 会创建文件
    		如果文件存在 会先清除掉文件中的内容 再写入
    a  --- 只写
        	如果文件不存在 会创建文件
        	如果文件存在 会在原有内容的基础上 进行追加
    b  --- 以字节的形式进行操作
    rb --- 以内容的字节数据的格式 读取文件中的内容
    wb / ab --- 以内容的字节数据的格式 向文件中写入内容
    			"你好".encode("gbk")
    +  --- 可以操作读写
        r+
        w+
        rb+
        wb+
        a+
        ab+
'''
handle = open(r"..\listen1.py", "w")
print(handle)

# 移除文件
os.remove(r"..\listen1.py")

# 获得文件的信息
info = os.stat(r"..\listen.py")
print(info)

# 重命名
os.rename("test_abs", "test")
os.rename(r"..\listen.py", r"..\lis.py")
'''
在os.path下 有对应的一些操作
'''
#1. 获得指定目录所在的绝对路径
abs_path = os.path.abspath(r"..")
print(abs_path)

#2.路径拼接
join_path = os.path.join(abs_path, r"os_pack\os_demo.py")
print(join_path)

#3.获得指定路径对应的扩展名
# 在扩展名处进行切割 得到是一个元组 第一个值文件的路径到文件名 第二个值就是文件的后缀名
extend_name = os.path.splitext(join_path)
print(extend_name[1])

#4.获得文件的名字 / 获得最后一级的名字
base_name = os.path.basename(join_path)
print(base_name)

#5.获得除了最后一级之外的名字
dir_name = os.path.dirname(join_path)
print(dir_name)

#6.获得指定文件所占大小
file_size = os.path.getsize(join_path)
print(file_size)

#关于判断的
#1. 判断指定路径是否是绝对路径
res = os.path.isabs(join_path)
print(res)

#2. 判断指定路径是否是文件夹
res = os.path.isdir(join_path)
print(res)

#3. 判断指定路径是否是文件
res = os.path.isfile(join_path)
print(res)

#4. 判断指定路径是否在计算机中存在
path = r"..\lis1.py"
res = os.path.exists(path)
print(res)

7.深度遍历和广度遍历

深度遍历:

从最外层 ---> 向内

借助栈遍历

栈的特点:  先进后出

	利用列表模拟栈

import os
def get_all_file(dir_path):
    # 声明一个空栈
    stack = []
    # 向栈中添加第一个需要遍历的目录
    stack.append(dir_path)
    # 遍历执行的条件：栈中有内容
    while len(stack) != 0:
        # 取出栈中的内容进行遍历
        path = stack.pop()
        # 获得该路径下所有子文件
        file_list = os.listdir(path)
        # 遍历
        for filename in file_list:
            join_path = os.path.join(path, filename)
            if os.path.isfile(join_path):
                print(join_path)
            elif os.path.isdir(join_path):
                stack.append(join_path)

get_all_file(r"..\test")
r'''
..\test
    遍历
        [subtest, subtest1]    
subtest1 ---> 栈中剩余[subtest]
        遍历subtest1
        [subtest, sub_subtest_A, sub_subtest_B]
sub_subtest_B --->栈中剩余[subtest, sub_subtest_A]
        遍历
sub_subtest_A --->栈中剩余[subtest]
        遍历
subtest ---> 栈中剩余[]
    遍历
        [sub_subtest_1, sub_subtest_2]
sub_subtest_2 ---> 栈中剩余[sub_subtest_1]
    遍历
sub_subtest_1栈中剩余[]
    遍历 
'''

广度遍历:

每一层先将同级的遍历完成

借助队列遍历

	队列: 先进先出

def get_all_file(dir_path):
    import os
    from collections import deque
    # 创建空队列
    queue = deque()
    # 向队列中介入第一节目录
    queue.append(dir_path)
    # 只要队列长度不为0 就一直遍历
    while len(queue) != 0:
        # 取出队列中的数据
        path = queue.popleft()
        file_list = os.listdir(path)
        for filename in file_list:
            join_path = os.path.join(path, filename)
            if os.path.isfile(join_path):
                print(join_path)
            elif os.path.isdir(join_path):
                queue.append(join_path)
get_all_file(r"..\test")