一、时间模块（time，calendar，datetime）
- 在Python中，通常有这几种方式来表示时间：
- 时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
- 格式化的时间字符串(Format String)
- 结构化的时间(struct_time):struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)
time模块，主要知道如下几个功能：
- 时间戳(timestamp)：time.time(）
延迟线程的运行：time.sleep(secs)
(指定时间戳下的)当前时区时间：time.localtime([secs])
(指定时间戳下的)格林威治时间：time.gmtime([secs])
(指定时间元组下的)格式化时间：time.strftime(fmt[,tupletime])
import time
print(time.time())
print('暂停开始')
sec = 1
time.sleep(sec) # 延迟线程的运行。（例如延迟邮件发送）
print('暂停结束')
print(time.time())
# 重点：
# 时间戳 --》 可以作为数据的唯一标识 --->时间戳是相对于1970-1-1 0:0:0时间差值
print(time.time())
# 当前时区时间（元组形式存在） 东八区（上海时区）
print(
time.localtime()) # time.struct_time(tm_year=2019, tm_mon=4, tm_mday=10, tm_hour=10, tm_min=6, tm_sec=3, tm_wday=2, tm_yday=100, tm_isdst=0)
# 访问年
print(time.localtime().tm_year)
print(time.localtime()[0])
# 格林威治时间
print(time.gmtime())
# 可以将时间戳转化为时区的time
print(time.localtime(
56565653)) # time.struct_time(tm_year=1971, tm_mon=10, tm_mday=18, tm_hour=0, tm_min=40, tm_sec=53, tm_wday=0, tm_yday=291, tm_isdst=0)
print(time.localtime(
5656565344).tm_year) # time.struct_time(tm_year=1971, tm_mon=10, tm_mday=18, tm_hour=0, tm_min=40, tm_sec=53, tm_wday=0, tm_yday=291, tm_isdst=0)
# 格式化时间 # 该方法内有确保数据的安全性，只是将时间转化为格式化的字符串
print(time.strftime('%Y-%m-%d')) # 2019-04-10
print(time.strftime('%y-%m-%d')) # 19-04-10
print(time.strftime('%y-%m-%d %j days')) # 19-04-10
print(time.strftime('%y-%m-%d %X %W %A %B %z')) # 19-04-10 %X 本地相应的时间表示15:18:45 %z（+0800）
print(time.strftime('%y-%m-%d %x %w %a %b')) # 19-04-10 %x 本地相应的日期表示04/10/19
print('_____________________________________________________')
"""
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
"""
calendar模块，主要掌握如下功能：
判断闰年：calendar.isleap(year)
查看某年某月日历：calendar.month(year, mouth)
查看某年某月起始星期与当月天数：calendar.monthrange(year, mouth)
查看某年某月某日是星期几：calendar.weekday(year, month, day)
# 需求：输入一个年份，判断其是否是闰年
# 1能被400整除的是闰年 year%400 = 0
# 能被4整除不能被100整除 year % 4 == 0 and year % 100 ！= 0
year = int(input('year:'))
b1 = year % 400 == 0
b2 = year % 4 == 0 and year % 100 != 0
if b1 or b2:
print('yes')
else:
print('no') import calendar print(calendar.isleap(year=2104)) # True
print(calendar.month(2019, 4)) # 查看2019年4月日历
print(calendar.monthrange(2019, 4)) # (0,30) 0 表示星期一，30 表示这个月30天
datetime模块：
- 当前时间：datetime.datetime.now()
- 昨天：datetime.datetime.now() + datetime.timedelta(days=-1)
- 修改时间：datatime_obj.replace([...])
- 格式化时间戳：datetime.date.fromtimestamp(timestamp)
mport datetime tm = datetime.datetime.now()
print(tm, type(tm)) # 2019-04-10 10:42:22.633853 <class 'datetime.datetime'>
day = datetime.timedelta(days=1)
print(day, type(day)) # 1 day, 0:00:00 <class 'datetime.timedelta'>
print(tm - day) # 2019-04-09 10:42:22.633853 # tm 是对象，所以还可以接着调用方法
print(tm.replace(year = 2200)) # 2200-04-10 10:42:22.633853
二、系统模块（sys（系统）、os（操作系统）、os.path（操作系统路径操作））
"""
sys：系统模块
命令行参数List，第一个元素是程序本身路径：sys.argv
退出程序，正常退出时exit(0)：sys.exit(n)
获取Python解释程序的版本信息：sys.version
最大int值：sys.maxsize | sys.maxint
环境变量：sys.path
操作系统平台名称：sys.platform
"""
import sys
print(sys.argv) # 作为脚本的时候传入外界参数
print(sys.path)
# print(sys.exit(0)) # 手动退出程序
print(sys.version)
print(sys.maxsize) #
print(sys.platform) import os
"""
os：操作系统模块
生成单级目录：os.mkdir('dirname')
生成多层目录：os.makedirs('dirname1/.../dirnamen2')
重命名：os.rename("oldname","newname")
工作目录：os.getcwd() # 获取当前执行文件的工作目录
删除单层空目录：os.rmdir('dirname')
移除多层空目录：os.removedirs('dirname1/.../dirnamen')
列举目录下所有资源：os.listdir('dirname')
路径分隔符：os.sep
行终止符：os.linesep
文件分隔符：os.pathsep
操作系统名：os.name
操作系统环境变量：os.environ
执行shell脚本：os.system()
""" # os.mkdir('aaa') # 不存在创建，存在抛异常
# os.rename('aaa','bbb')
# os.rmdir(r'E:\qzk总结及作业\day17\代码\bbb') # 删除一个空的文件夹
# os.remove(r"E:\qzk总结及作业\day17\代码\part0\0复习.py")
# os.makedirs('a/b/c')
res = os.listdir(r'C:')
print(res) # 以列表形式打印出指定路径中的所有文件夹 '''
os.path：系统路径操作模块
执行文件的当前路径：__file__
返回path规范化的绝对路径：os.path.abspath(path)
将path分割成目录和文件名二元组返回：os.path.split(path)
上一级目录：os.path.dirname(path)
最后一级名称：os.path.basename(path)
指定路径是否存在：os.path.exists(path)
是否是绝对路径：os.path.isabs(path)
是否是文件：os.path.isfile(path)
是否是路径：os.path.isdir(path)
路径拼接：os.path.join(path1[, path2[, ...]])
最后存取时间：os.path.getatime(path)
最后修改时间：os.path.getmtime(path)
目标大小：os.path.getsize(path)
'''
# 先将项目的根目录设置为常量，后来项目中的额所有目录与文件都应该参照此目录
import os.path as os_path
BASE_PATH = os_path.dirname(os_path.dirname(__file__))
print(BASE_PATH)
sys.path.append(BASE_PATH)
# 重点：将项目目录添加至环境变量 # getmtime()做辅助下载上传进度查看的 '''
normcase函数（格式化分隔符）
在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。
>>> os.path.normcase('c:/windows\\system32\\')
'c:\\windows\\system32\\' normpath函数(格式化路径)
规范化路径，如..和/
>>> os.path.normpath('c://windows\\System32\\../Temp/')
'c:\\windows\\Temp' >>> a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'
>>> print(os.path.normpath(a))
/Users/jieli/test1
三、序列化模块（json、pickle）
"""
# -*- coding: utf-8 -*-
# json: {} 与 [] 嵌套的数据
# 注：json中的字符串必须全部用""来标识
序列化：对象 => 字符串
序列化成字符串：json.dumps(json_obj)
序列化字符串到文件中：json.dump(json_obj, write_file) # 注：字符形式操作
反序列化成对象：json.loads(json_str)
从文件读流中反序列化成对象：json.load(read_file)
""" import json # 将json类型的对象与json类型的字符串相互转换
# {} 与[]嵌套形成的数据（python中建议数据的开始从{}开始） dic = {'a': 1,
'b': [1, 2, 3]
}
# 序列化： 将python的字典转化为字符串传递给其他语言
json_str = json.dumps(dic)
print(json_str, type(json_str)) # {"a": 1, "b": [1, 2, 3]} <class 'str'>
with open('', 'w', encoding='utf-8') as w:
json.dump(dic, w) # 两个过程：1先将dic对象转换成字符串，2再将其存在数据流文件中 # 返序列化
new_dic = json.loads(json_str) # json类型的字符串，字典中的key必须是""包裹,json类型的字符串不认''
print(new_dic, type(new_dic)) # {'a': 1, 'b': [1, 2, 3]} <class 'dict'> with open('', 'r', encoding='utf-8') as r:
res = json.load(r)
print(res, type(res)) # {'a': 1, 'b': [1, 2, 3]} <class 'dict'>
'''
序列化：对象 => 字符串
序列化成字符串：pickle.dumps(obj)
序列化字符串到文件中：pickle.dump(obj, write_bytes_file) # 注：字节形式操作
反序列化成对象：pickle.loads(bytes_str)
从文件读流中反序列化成对象：pickle.load(read_bytes_file)
'''
import pickle # 可以将任意类型对象字符串进行转换
# 序列化
dic = {'a': 1,
'b': [1, 2, 3]
} res = pickle.dumps(dic)
print(res)
with open('', 'wb') as w:
pickle.dump(dic, w) # 返序列化
print(pickle.loads(res))
with open('', 'rb') as r:
print(pickle.load(r))