Python序列化、date、random、os模块

知识点一&＃xff1a;序列化与反序列化&＃xff08;json和pickple&＃xff09;

01 什么是序列化/反序列化
    序列化就是将内存中的数据结构转换成一种中间格式存储到硬盘或者基于网络传输
    发序列化就是硬盘中或者网络中传来的一种数据格式转换成内存中数据结构

02 为什要有
    1、可以保存程序的运行状态
    2、数据的跨平台交互

03 怎么用
    json
        优点&＃xff1a;
            跨平台性强
        缺点&＃xff1a;
            只能支持/对应python部分的数据类型

    pickle
        优点&＃xff1a;
            可以支持/对应所有python的数据类型
        缺点&＃xff1a;
            只能被python识别&＃xff0c;不能跨平台
   
 json:
  序列化json.dump&＃xff08;&＃xff09;&＃xff1a;是将字典转换成字符串类型&＃xff0c;写入文件
  反序列化json.load&＃xff08;&＃xff09;&＃xff1a;是将文件中的字符串类型&＃xff0c;转换为字典类型读出
  
 pickle&＃xff1a;
  序列化pickle.dump&＃xff08;&＃xff09;&＃xff1a;是将字典转换成bytes类型&＃xff0c;写入文件
  序列化pickle.load&＃xff08;&＃xff09;&＃xff1a;是将从文件中将bytes类型&＃xff0c;转换为字典类型读出
 

实验&＃xff1a;
json序列化&＃xff1a;内存中的数据类型------>中间格式json
1.序列化得到json_str &＃xff08;dumps接收1个参数&＃xff09;
json_str&＃61;json.dumps(user_info)
2.把json_str写入文件
with open(&＃39;db.json&＃39;,&＃39;w&＃39;,encoding&＃61;&＃39;utf-8&＃39;) as f:
    f.write(json_str)
1.2合并(用dump&＃xff08;&＃xff09;接收2个参数)
with open(&＃39;da.json&＃39;,&＃39;w&＃39;,encoding&＃61;&＃39;utf-8&＃39;) as f:
    json.dump(user_info,f)  #文件的输出结果双引号 {"name": "yangzhizong", "age": 27}
   

总结&＃xff1a;json格式不能识别单引号&＃xff0c;全都是双引号
 转换后单引号默认都被转成了双引号

json的反序列化&＃xff1a;
import json
1.从文件中读取db.json
with open(&＃39;db.json&＃39;,&＃39;r&＃39;,encoding&＃61;&＃39;utf-8&＃39;) as f:
   user_info&＃61;f.read()      #str类型
2.将文件转换成内存中的数据类型
user_info&＃61;json.loads(user_info)      #反序列后变为dict字典类型

1和2可以合并
with open(&＃39;db.json&＃39;,&＃39;r&＃39;,encoding&＃61;&＃39;utf-8&＃39;) as f:
    db_json&＃61;json.load(f)
    print(db_json)  # 反序后变为dict类型 

pickle的序列化&＃xff1a;
import pickle
name&＃61;{&＃39;name&＃39;:&＃39;yangzhizong&＃39;,&＃39;age&＃39;:27}
1.序列化得到name
name&＃61;pickle.dumps(name)                  重点注意dumps&＃xff08;1个参数&＃xff09;               
print(name,type(name))   #name被转换成bytes类型 ,写入是应该用wb
2.把name写入文件
with open(&＃39;db.pickle&＃39;,&＃39;wb&＃39;,) as f:
    f.write(name)   #输出结果是二进制
1.2合并 (用dump&＃xff08;&＃xff09;接收2个参数)                    重点注意dump&＃xff08;2个参数&＃xff09;
with open(&＃39;db.pickle&＃39;,&＃39;wb&＃39;,) as f:
    pickle.dump(name,f)  

pickle的反序列化
import pickle
with open(&＃39;db.pickle&＃39;,&＃39;rb&＃39;) as f:
    info&＃61;pickle.load(f)
    print(info,type(info))   #输出结果为dict字典
  

 
知识点二&＃xff1a;模块
1&＃xff09;time和datetime
import time,datetime
 1.时间戳
 start&＃61; time.time()
 time.sleep(3)
 stop&＃61; time.time()
 print(stop - start)  #3.0001089572906494

 2.格式化的字符串形式
 显示格式&＃xff1a;
 2018:06:20 16:23:22
 2018:06:20 16:23:22 PM
 print(time.strftime(&＃39;%Y:%m:%d %X&＃39;))
 print(time.strftime(&＃39;%Y:%m:%d %H:%M:%S %p &＃39;)) #%p表示上午和下午

 
 
 3.结构化的时间/时间对象
 显示格式&＃xff1a;time.struct_time(tm_year&＃61;2018, tm_mon&＃61;6, ...)
 t1&＃61;time.localtime()
 print(t1)
 print(t1.tm_year)  #2018
 结果&＃xff1a;time.struct_time(tm_year&＃61;2018, tm_mon&＃61;6, tm_mday&＃61;20, tm_hour&＃61;16, tm_min&＃61;28, tm_sec&＃61;48, tm_wday&＃61;2, tm_yday&＃61;171, tm_isdst&＃61;0)
  
 t1&＃61;time.gmtime() &＃xff08;是世界标准时间格式&＃xff0c;会有时差的区别&＃xff09;
 print(t1)
 结果&＃xff1a;time.struct_time(tm_year&＃61;2018, tm_mon&＃61;6, tm_mday&＃61;20, tm_hour&＃61;8, tm_min&＃61;28, tm_sec&＃61;48, tm_wday&＃61;2, tm_yday&＃61;171, tm_isdst&＃61;0)
 
 

 4.转换形式
 结构化时间与时间戳&＃xff1a;
 显示格式&＃xff1a;
 time.struct_time(tm_year&＃61;1970, tm_mon&＃61;1, tm_mday&＃61;15, tm_hour&＃61;14, tm_min&＃61;56, tm_sec&＃61;7, tm_wday&＃61;3, tm_yday&＃61;15, tm_isdst&＃61;0)
 time.struct_time(tm_year&＃61;1970, tm_mon&＃61;1, tm_mday&＃61;15, tm_hour&＃61;6, tm_min&＃61;56, tm_sec&＃61;7, tm_wday&＃61;3, tm_yday&＃61;15, tm_isdst&＃61;0)
 print(time.localtime(1234567))
 print(time.gmtime(1234567))
 
 
 
 结构化时间与格式化字符串时间
 print(time.strftime(&＃39;%Y&＃39;,time.localtime()))
 print(time.strptime(&＃39;2011-03-07&＃39;,&＃39;%Y-%d-%m&＃39;))

# print(time.asctime())
 # print(time.ctime())
 # print(time.strftime(&＃39;%a %b %d %H:%M:%S %Y&＃39;))

 # print(time.asctime(time.localtime()))
 # print(time.ctime(123123123))

 # print(time.strftime(&＃39;%Y-%m-%d %X&＃39;))

 # 获取格式化字符串形式的时间麻烦
 # 时间戳与格式化时间之间的转换麻烦
 # 获取之前或者未来的时间麻烦
 
 
 
 import datetime

 # print(datetime.datetime.now())
 # print(datetime.datetime.fromtimestamp(1231233213))

 # print(datetime.datetime.now() &＃43; datetime.timedelta(days&＃61;3))
 # print(datetime.datetime.now() &＃43; datetime.timedelta(days&＃61;-3))

 s&＃61;datetime.datetime.now()
 print(s.replace(year&＃61;2020))

2&＃xff09;random随机取值
 import random
 print(random.random())  #(0,1) 默认是0-1之间的小数&＃xff0c;不包含0/1
 print(random.randint(1,3)) #随机1-3整数包含、3
 print(random.randrange(1,3)) #顾头不顾尾
 print(random.choice([1,&＃39;egon&＃39;,[1,2]])) #随机取一个值
 print(random.sample([1, &＃39;aa&＃39;, [4, 5]], 1)) # 最后一个数字代表随机取几个值的意思
 

random.shuffle():随机取值排序
import random
item&＃61;[&＃39;a&＃39;,&＃39;b&＃39;,&＃39;c&＃39;,&＃39;d&＃39;]
random.shuffle(item)
print(item)

 
3&＃xff09;os模块
 绝对路径:
 输出结果&＃xff1a;E:\PycharmProjects\untitled\day18\课堂练习.py
 path&＃61;os.path.abspath(__file__)
 print(path)

 将路径分成目录和文件名以元祖形式返回
 输出结果&＃xff1a;(&＃39;E:\\PycharmProjects\\untitled\\day18&＃39;, &＃39;课堂练习.py&＃39;)
 path&＃61;os.path.split(os.path.abspath(__file__))
 print(path)

 返回path的目录os.path.split(path)的第一个元素
 输出结果&＃xff1a;E:\PycharmProjects\untitled\day18
 print(os.path.dirname(os.path.abspath(__file__)))

 返回path最后的文件名。如何path以&＃xff0f;或\结尾&＃xff0c;那么就会返回空值。
 即os.path.split(path)的第二个元素
 print(os.path.basename(os.path.abspath(__file__)))

 判断目录是否存在&＃xff0c;返回值是True或者False
 os.path.exists(.day19)

 判断是否是绝对路径&＃xff08;以盘符开始的c\d\e..&＃xff09;&＃xff0c;或相对路径&＃xff08;不是以盘符开始的&＃xff09;
 print(os.path.isabs(r&＃39;c:\a\b&＃39;)) #True
 print(os.path.isabs(r&＃39;a\b&＃39;))  #False

 另外在linux里面是以左斜杠开始作为根目录的起始位置
 print(os.path.isabs(r&＃39;/a/b&＃39;)) #True
 print(os.path.isabs(r&＃39;a/b&＃39;))  #False

 将多个路径组合后返回&＃xff0c;取最后一个聚堆路径输出
 os.path.join(path1[, path2[, ...]])
 输出结果为&＃xff1a;d:\a
 path&＃61;os.path.join(r&＃39;c:\\a&＃39;,&＃39;b&＃39;,&＃39;d:\\a&＃39;) #第一个 \ 有转译的功能说明后面一个 \ 只是普通的字符
 print(path)

 获取文件的大小&＃xff1a;
 输出结果为&＃xff1a;5366
 path&＃61;os.path.getsize(r&＃39;E:\PycharmProjects\untitled\day18\课堂练习.py&＃39;)
 print(path)