0726_time模块，序列化模块

time 模块

import time
time.sleep([n])

time.time() #获取当前时间戳

在Python中，表示时间通常有3种方式：

• 时间戳（timetamp）：表示的是从1970.01.01 00：00：00 开始按秒计算的偏移量
• 格式化的时间字符串（format string）
• 结构化的时间（struct_time） — > 元组，9个元素， （年月日时分秒，一年的第几周，一年的第几天，夏令时）

python中时间日期格式化符号：
%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 当前时区的名称
%% %号本身

>>> dir(time)
['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'perf_counter', 'process_time', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 'timezone', 'tzname']

>>> time.strftime("%y-%m-%d %X")
'19-07-26 08:56:05'

>>> time.localtime()
'time.struct_time(tm_year=2019, tm_mon=7, tm_mday=26, tm_hour=8, tm_min=57, tm_sec=38, tm_wday=4, tm_yday=207, tm_isdst=0)'

>>> time.localtime()[2]  #索引
26

time模块的常用方法

方法	描述
time.localtime([sec])	将一个时间戳转化为一个当前时区的结构化(struct_time)的时间(若未提供参数,当前时间)
time.gmtime([sec])	和localtime类似,不同的是,其是将一个时间戳转化为UTC时区(0时区)的struct_time
time.time()	返回当前时间戳
time.mktime(t)	将time.struct_time转化为时间戳
time.sleep(sec)	线程推迟指定的时间运行,单位(s)
time.asctime([t[)	将表示时间的元组或struct_time表示为:“Sun July 26 09:06:35 2019”;如果未传参数,默认为time.localtime()
time.ctime([t])	把一个时间戳转化为time.asctime()的形式,如果未传参数,默认time.time()
time.strftime(format[, t])	把一个代表时间的元组/ struct_time(localtime()和gmtime())转化为格式化的字符串,未传参数,默认为time.localtime()
time.strptime()	将结构化字符串转化为struct_time形式

• 时间戳,计算机识别的
• 字符串时间,认可看
• 结构化时间,对时间操作

>>> now = time.time()
>>> time.gmtime(now)  #UTC时间,0时区
time.struct_time(tm_year=2019, tm_mon=7, tm_mday=26, tm_hour=1, tm_min=20, tm_sec=13, tm_wday=4, tm_yday=207, tm_isdst=0)

>>> time.localtime(now) # 当地时间,以北京时间为准
time.struct_time(tm_year=2019, tm_mon=7, tm_mday=26, tm_hour=9, tm_min=20, tm_sec=13, tm_wday=4, tm_yday=207, tm_isdst=0)

结构化时间和时间戳的转化

• time.mktime(结构化时间)

>>> tp_struct = time.localtime()
>>> time.mktime(tp_struct)
1564104154.0

结构化时间到字符串时间的转化

• time.strftime([format[, t]])

>>> tp_struct = time.localtime()
>>> time.strftime("%Y-%m-%d %X", tp_struct)
'2019-07-26 09:25:54'

字符串时间到结构化时间的转化

• time.strptime(时间字符串, 字符串对应格式)

>>> time.strptime("2019-7-16", "%Y-%m-%d")
time.struct_time(tm_year=2019, tm_mon=7, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=197, tm_isdst=-1)

结构化时间和字符串时间的转化(国际化时间字符串)

• time.asctime(结构化时间)

>>> tp_struct = time.localtime()
>>> time.asctime(tp_struct)
'Fri Jul 26 09:49:28 2019'

>>> time.asctime()
'Fri Jul 26 09:51:04 2019'

时间戳和字符串的转化(国际化)

>>> time.ctime(time.time())
'Fri Jul 26 09:52:25 2019'
>>> time.ctime()
'Fri Jul 26 09:52:32 2019'
>>> time.ctime(1500000000)
'Fri Jul 14 10:40:00 2017'

datetime模块

相比time来说,datetime模块接口更只管,更容易调用

方法(类)	描述
datetime.date	表示日期(类),常用属性year,month,day
datetime.time	表示时间(类),hour,minute,second,microsecond
datetime.datetime	表示日期
datetime.timedelta	表示时间间隔
datetime.tzinfo	与时区有关的信息

>>> datetime.datetime.now()
datetime.datetime(2019, 7, 26, 10, 2, 50, 987525)

>>> print(datetime.datetime.now())
2019-07-26 10:03:34.471459

>>> print(datetime.datetime.now().time())
10:05:44.599997
>>> print(datetime.datetime.now().date())
2019-07-26

sys模块

sys模块是与Python解释器交互的一个接口

处理命令行参数

在解释器启动后，argv列表包含了传递脚本的所有参数，列表的第一个元素是脚本自身的名称。

import sys                            #显示本地字节序的指示符
print(sys.byteorder)                  #显示Python解释器有关的版权信息
print(sys.copyright)                  #显示Python解释器在磁盘上的存储路径
print(sys.executable)                 #显示当前系统上保存文件所用的字符集
print(sys.getfilesystemencoding())    #显示Python解释器所在平台
print(sys.maxsize)                    #显示Python整数支持的最大值
print(sys.platform)                   #显示当前Python解释器的版本信息
print(sys.version)                    #返回当前Python解释器的主版本号

序列化模块

序列化

概念:将一个对象从内存中转换为可存储(字符串类型)或者可传输(bytes)类型的过程

Python中叫pickling

为什么要使用序列化?

• 持久化数据类型
• 跨平台交互使用
• 是程序更易维护

Json

json格式在各个语言中都可以通过序列化格式.在json中,所有的字符串必须为"".

Json类型	Python类型
{}	dict
[]	list
“string”	str
1234.56	int/float
true/false	True/False
null	None

Json优缺点

• 优点:所有的数据类型是各语言通用的
• 缺点:
  • Json只支持比较少的数据类型
  • 对数据类型的约束十分严格
    • 字典中的key必须是字符串
    • json只支持列表,字典,数值.字符串以及布尔值

查看json的方法和属性

四个功能

• dumps
• dump
• loads
• load

>>> import json
#序列化过程
>>> dic = {"name": "city college", "age": 20,"type": "univerrsity"}
>>> sr_dic = json.dumps(dic)

>>> type(sr_dic)
<class 'str'>

>>> print(sr_dic)
{"name": "city college", "age": 20, "type": "univerrsity"}

>>> dic
{'name': 'city college', 'age': 20, 'type': 'univerrsity'}

>>> sr_dic
'{"name": "city college", "age": 20, "type": "univerrsity"}'

#反序列化
>>> dic_2 = json.loads(sr_dic)
>>> type(dic_2)
<class 'dict'>
>>> dic_2
{'name': 'city college', 'age': 20, 'type': 'univerrsity'}

#如果是元组,序列化时强转为列表,若元组违字典的键,序列化时报错

如果把数据类型直接序列化写入文件,可以用dump和load方法

import json
dic = {"name": "city college", "age": 20, "type": "university", 2: 6}
with open('dump_json', 'w') as f:
    json.dump(dic, f) #dump方法可以接收一个文件句柄。直接将字典--->字符串，写入文件中

with open('dump_json') as f:
    ret = json.load(f)
    print(ret, type(ret))
#  name is : E:/PyCharm/Course/0726.py
#  {'name': 'city college', 'age': 20, 'type': 'university', '2': 6} <class 'dict'>

#如果要使用json dump多个数据到文件了里面，那么就要用到dumps
import json
dic = {"name": "city college", "age": 20, "type": "university", 2: 6}
dic2 = {"city": "HangZhou", "history": 5000}
with open('dump_json', 'w') as f:
    str_dic1 = json.dumps(dic)
    str_dic2 = json.dumps(dic2)
    f.write(str_dic1 + '\n')
    f.write(str_dic2 + '\n')

with open('dump_json') as f:
    for line in f:
        ret = json.loads(line)
        print(ret)
        
{'name': 'city college', 'age': 20, 'type': 'university', '2': 6}
{'city': 'HangZhou', 'history': 5000}

Pickle

只用于Python

内存中结构化的数据 <—> 格式pick <—> bytes <—> 保存在文件或基于网络传输

pickle 优缺点

• 优点
  • 支持Python中的几乎所有类型
  • pickle会把数据类型序列化为bytes类型
• 缺点
  • 只支持Python

模块提供四个功能

• 序列化
  • dumps
  • dump
• 反序列化
  • loads（）
  • load（）

import pickle

dic = {"name": "city college", "age": 20, "type": "university", 2: 6}
dic_b = pickle.dumps(dic)
print(type(dic_b))
print(dic_b)

dic_b = pickle.loads(dic_b)
print(type(dic_b))
print(dic_b)

<class 'bytes'>
b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x0c\x00\x00\x00city collegeq\x02X\x03\x00\x00\x00ageq\x03K\x14X\x04\x00\x00\x00typeq\x04X\n\x00\x00\x00universityq\x05K\x02K\x06u.'

<class 'dict'>
{'name': 'city college', 'age': 20, 'type': 'university', 2: 6}