day17--模块之time、calendar、datetime、sys、os、os.path、json、pickle、random

一、时间模块（time，calendar，datetime）

　　

1. 在Python中，通常有这几种方式来表示时间：

1. 1. 　　时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
   2. 　　格式化的时间字符串(Format String)
   3. 　　结构化的时间(struct_time):struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

time模块，主要知道如下几个功能：

1. 1. 时间戳(timestamp)：time.time(）

   2. 延迟线程的运行：time.sleep(secs)

   3. (指定时间戳下的)当前时区时间：time.localtime([secs])

   4. (指定时间戳下的)格林威治时间：time.gmtime([secs])

   5. (指定时间元组下的)格式化时间：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模块，主要掌握如下功能：

1. 判断闰年：calendar.isleap(year)

2. 查看某年某月日历：calendar.month(year, mouth)

3. 查看某年某月起始星期与当月天数：calendar.monthrange(year, mouth)

4. 查看某年某月某日是星期几：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模块：

1. 当前时间：datetime.datetime.now()
2. 昨天：datetime.datetime.now() + datetime.timedelta(days=-1)
3. 修改时间：datatime_obj.replace([...])
4. 格式化时间戳：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))