python学习Day27--time模块、sys模块、os模块和序列化模块

【知识点】

1、时间模块：

（1）时间戳时间，格林威治时间，float数据类型

　　英国伦敦的时间：1970.1.1     0：0：0

　　北京时间：1970.1.1     8：0：0

（2）结构化时间，时间对象

　　时间对象  能够通过.属性名来获取对象中的值

（3）格式化时间，字符串时间，str数据类型

　　可以根据你需要的格式来显示时间

 import time

 # 1.时间戳时间 格林威治时间，float数据类型（给机器用的）
 print(time.time())

 # 2.格式化时间
 print(time.strftime('%Y-%m-%d'))  # Y——2020，y——20（2020年）
 print(time.strftime('%Y-%m-%d %H:%M:%S %A'))  # 2020-02-20 20:05:51 Thursday
 print(time.strftime('%c')) # Thu Feb 20 20:06:57 2020

 # 3.结构化时间
 time_obj=time.localtime()
 print(time_obj)
 print(time_obj.tm_year)  # 2020（年）
 print(time_obj.tm_mday)  # 20（日）

（4）几种时间格式之间的转换

 # 几种时间格式之间的转换
 import time

 print(time.localtime(15000000000))
 # time.struct_time(tm_year=2445, tm_mon=5, tm_mday=1, tm_hour=10, tm_min=40, \
 # tm_sec=0, tm_wday=0, tm_yday=121, tm_isdst=0)

 # Timestamp ——> Struct_time ——> Format string
 time_obj=time.localtime(15000000000)
 format_time=time.strftime('%Y-%m-%d %H:%M:%S %A',time_obj)
 print(format_time)  # 2445-05-01 10:40:00 Monday

 # Format string ——> Struct_time ——> Timestamp
 s='2008-8-8'
 struct_time=time.strptime(s,'%Y-%m-%d')
 print(struct_time)  # 结构化时间
 print(time.mktime(struct_time))  # 1218124800.0

练习题：计算本月一号的时间戳时间

 import time

 ret=time.strftime('%Y-%m-1')
 struct_time=time.strptime(ret,'%Y-%m-%d')
 print(time.mktime(struct_time))  # 1580486400.0

2、sys模块

（1）sys.path

（2）sys.modules

（3）sys.exit()——结束处理

（4）sys.argv

 import sys

 # 程序启动时，在后面输入用户名，密码，通过sys.argv索取
 name=sys.argv[1]
 pwd=sys.argv[2]

 if name == 'alex' and pwd == '':
     print('执行代码了')
 else:
     exit()

3、os模块

（1）创建文件夹：os.mkdir('文件名')    os.mkdirs(‘文件名1/文件名2/文件名3’,exist_ok=True)  有这个文件名就跳过，没有就创建，不报错。

（2）删除文件夹

　　os.rmdir(‘文件名1/文件名2/文件名3’)  不能删除一个非空文件夹

　　os.removedirs(‘文件名1/文件名2/文件名3’)   递归向上删除文件夹，只要删除当前目录之后，发现上一级目录也为空，就把上一级目录也删掉，如果发现上一级目录有其他文件夹，就停止。

（3）os.listdir()  查看某个路径下的文件夹，返回一个列表

（4）os.sep  当前你所在的操作系统的目录分隔符

（5）os.linesep  输出当前平台使用的行终止符，win下为"\r\n",linux系统下为"\n"

（6）os.pathsep  输出用于分割文件路径的字符串，win下为"；",linux系统下为"："　　　

（7）os.name  输出字符串指示当前使用平台，win—>：‘nt’,Linux—>'posix'

（8）os.system("bash command")  运行shell命令，直接显示

（9）os.popen("bash command") .read()  运行shell命令，获取执行结果（查看当前路径  查看某些信息）

（10）os.path.abspath(path)  返回path规范化的绝对路径，os.path.split(path)  将path分割成目录和文件名二元组返回。

（11）os.path.dirname(path)  返回path目录，第一个元素。  os.path.basename(path)  返回path的文件名。

（12）os.path.exists(path)  如果path存在返回True，否则返回False

（13）os.path.isfile(path)  如果path是一个存在的文件，返回True，否则返回False

（14）os.path.isdir(path)  如果path是一个存在的目录，返回True，否则返回False

（15）os.path.join(path,srt1,str2)  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

 import os

 ret=os.path.join('D:\wendang\PyCharmCode\MyPycharm\day27 sys os模块','aaa','bbb')
 print(os.path.abspath(ret))
 # D:\wendang\PyCharmCode\MyPycharm\day27 sys os模块\aaa\bbb

（16）os.path.getsize(path)  返回path的大小

4、序列化模块

为什么要序列化？

A、要把内容写入文件  序列化

B、网络传输数据     序列化

（1）json模块：

　　能处理数据类型：有限，限制比较多——数字，字典，字符串，列表

　　能使用的语言：所有语言

　　方法：dump\load （序列化与反序列化）  dumps/loads（直接接触内存）

 import json

 dic={'sss':'aaa','ccc':'qqq'}
 str_dic=json.dumps(dic)

 # print(dic)
 # print(str_dic,type(str_dic))

 with open('json_dump3','w') as f:
     json.dump(dic,f)      # 写入

 with open('json_dump3') as f2:
     print(json.load(f2))  # 读取

 ret=json.loads(str_dic)
 print(ret,type(ret))

　　① json格式限制1：json格式的key必须是字符串数据类型，如果是数字为key，那么dump之后会强行转成字符串数据类型。

 import json

 # json格式的限制1,json格式的key必须是字符串数据类型
 dic={1:2,3:4}
 str_dic=json.dumps(dic)
 print(str_dic)  # {"1": 2, "3": 4}
 new_dic=json.loads(str_dic)
 print(new_dic)  # {'1': 2, '3': 4}

　　json支持元组做value，对元组做value的字典会把元组强制转换成列表（json不支持元组做key）

 import json

 dic={'abc':(1,2,3)}
 str_dic=json.dumps(dic)
 print(str_dic)  # {"abc": [1, 2, 3]}
 new_dic=json.loads(str_dic)
 print(new_dic)  # {'abc': [1, 2, 3]}

　　②json格式限制2：json格式中的字符串只能是" "（双引号）

　　③dump限制的问题：

　　　　# 能不能多次dump数据到文件里？  可以多次dump但是不能load出来

　　　　# 想要dump多个数据进入文件，用dumps

 # 想dump多个数据进入文件，用dumps
 import json

 dic={'abc':(1,2,3)}
 lst=['aaa',123,'bbb',23.453]

 with open('json_dump3','w') as f:
     str_dic=json.dumps(dic)
     str_lst=json.dumps(lst)
     f.write(str_dic+'\n')
     f.write(str_lst+'\n')

 with open('json_dump3','r') as f1:
     for line in f1:
         ret=json.loads(line)
         print(ret)  #{'abc': [1, 2, 3]}  ['aaa', 123, 'bbb', 23.453]

　　　　# 中文格式问题（ensure_ascii=False）

 import json

 dic={'abc':(1,2,3),'country':'中国'}
 ret=json.dumps(dic)

 print(ret)  # {"abc": [1, 2, 3], "country": "\u4e2d\u56fd"}

 new_dic=json.loads(ret)
 print(new_dic) # {'abc': [1, 2, 3], 'country': '中国'}

 ret=json.dumps(dic,ensure_ascii=False)
 print(ret)  # {"abc": [1, 2, 3], "country": "中国"}

　　④ json的其他参数：是为了用户看的方便，但是会相对浪费存储空间

 # json其他参数
 import json

 data={'username':['李华','二愣子'],'sex':'male','age':16}
 # indent为缩进  separators分隔符
 json_dic2=json.dumps(data,sort_keys=True,indent=4,separators=(',',':'),ensure_ascii=False)
 print(json_dic2)
 # {
 #     "age":16,
 #     "sex":"male",
 #     "username":[
 #         "李华",
 #         "二愣子"
 #     ]
 # }

（2）pickle模块

　　① pickle支持的dumps和loads

 import pickle

 dic={1:{12,3,5},('a','b'):4}

 pic_dic=pickle.dumps(dic)
 print(pic_dic)   # bytes类型

 new_dic=pickle.loads(pic_dic)
 print(new_dic) # {1: {3, 12, 5}, ('a', 'b'): 4}原封不动

　　② pickle支持几乎所有对象的

 # pickle支持几乎所有对象的
 import pickle

 class Student:
     def __init__(self,name,age):
         self.name=name
         self.age=age

 alex=Student('alex',32)
 # print(pickle.dumps(alex))  # bytes类型
 ret=pickle.dumps(alex)
 小华=pickle.loads(ret)
 print(小华.name)  # alex

　　③ 对于对象的序列化需要这个对象对应的类在内存中

【注意】dump用的f文件句柄需要以“wb”的形式打开，load所用的f是“r'b”形式打开

　　④ 文件中dump多个值，怎么取出来？

 # 文件中dump多个值，怎么取出来？
 import pickle

 # 写入
 # with open('pickle_dump','wb') as f:
 #     pickle.dump({'k1': 'v1'}, f)
 #     pickle.dump({'k2': 'v2'}, f)
 #     pickle.dump({'k3': 'v3'}, f)
 #     pickle.dump({'k4': 'v4'}, f)
 #     pickle.dump({'k5': 'v5'}, f)
 #     pickle.dump({'k6': 'v6'}, f)

 # 读出
 with open('pickle_dump','rb') as f:
     while True:
         try:
             print(pickle.load(f))  # 依次打印出
         except EOFError:
             break

（3）shelve模块（不建议使用）

　　只有一个open功能

 import shelve

 # 写入
 # f=shelve.open('shelve_demo')
 # f['key']={'k1':(1,2,3),'k2':'v2'}
 # f.close()

 # 读出
 f=shelve.open('shelve_demo')
 content=f['key']
 f.close()
 print(content) # {'k1': (1, 2, 3), 'k2': 'v2'}

　　shelve的适用场景：

　　　　如果你写定一个文件，改动比较少，读文件的操作比较多，而且你大部分的读取都基于某个key获得某个value

---

时间：2020-02-21       19:35:09