json pickle shelve hashlib collections time

Posted 2021-01-01 ming-yuan

import json
# Json模块提供了四个功能：dumps、dump、loads、load

dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:‘v3‘}
str_dic = json.dumps(dic)        # 序列化：将一个字典转换成一个字符串
# print(type(str_dic),str_dic)    # <class ‘str‘> {"k3": "v3", "k1": "v1", "k2": "v2"}
# 注意，json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)        # 反序列化：将一个字符串格式的字典转换成一个字典
# 注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
# print(type(dic2),dic2)          # <class ‘dict‘> {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘}


list_dic = [1,[‘a‘,‘b‘,‘c‘],3,{‘k1‘:‘v1‘,‘k2‘:‘v2‘}]
str_dic = json.dumps(list_dic)        # 也可以处理嵌套的数据类型
# print(type(str_dic),str_dic)        # <class ‘str‘> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]

list_dic2 = json.loads(str_dic)
# print(type(list_dic2),list_dic2)    #<class ‘list‘> [1, [‘a‘, ‘b‘, ‘c‘], 3, {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}]


with open(‘json_file‘,‘w‘,encoding=‘utf-8‘) as f:
    dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:‘v3‘}
    json.dump(dic,f,ensure_ascii=False)
    # dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
    
with open(‘json_file‘,encoding=‘utf-8‘) as f:
    dic2 = json.load(f)        # load不能load多次
    # load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
    
# ensure_ascii: 当它为True的时候，所有非ASCII码字符显示为uXXXX序列，只需在dump时将ensure_ascii设置为
#    False即可，此时存入json的中文即可正常显示。
# sort_keys：将数据根据keys的值进行排序。 

# 多次dump一次load json的时候，json文件里面有多个对象，是无法解析的。要不你就自己把这些对象分开，然后再
# json.loads() 要不就存在不同的json文件里面。
# 示例
# with open(‘data.json‘, ‘w‘) as f:
#     f.write(json.dumps(d1) + ‘
‘ + json.dumps(d2)) # 用换行分开
# 读取时自己分开
# with open(‘data.json‘, ‘r‘) as f:
#    print(json.loads(f.readline()))



import pickle

# json，用于字符串 和 python数据类型间进行转换，json是一种所有的语言都可以识别的数据结构。
# pickle，用于python特有的类型 和 python的数据类型间进行转换,如果你序列化的内容是列表或者
# 字典，我们非常推荐你使用json模块
# pickle模块提供了四个功能：# dumps、loads对内存中的数据进行序列化和反序列化    # dump写入文件，load从文件读取

dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:‘v3‘}
str_dic = pickle.dumps(dic)        # print(str_dic)    #一串二进制内容
dic2 = pickle.loads(str_dic)    # print(dic2)        #字典

# import time    # struct_time  = time.localtime(1000000000)    # print(struct_time)
with open(‘pickle_file‘,‘wb‘) as f:
    pickle.dump(struct_time,f)
with open(‘pickle_file‘,‘rb‘) as f:
    struct_time2 = pickle.load(f)            # print(struct_time2.tm_year)
# 多次dump进一个文件，可使用对应load次数获取数据
    
    
import shelve
# 操作和字典类似
# shelve也是python提供给我们的序列化工具，比pickle用起来更简单一些。
# shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似。

f = shelve.open(‘shelve_file‘)
f[‘key‘] = {‘int‘:10, ‘float‘:9.5, ‘string‘:‘Sample data‘}  #直接对文件句柄操作，就可以存入数据
existing = f1[‘key‘]  #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
f.close()

f = shelve.open(‘shelve_file‘, flag=‘r‘)
# 这个模块有个限制，它不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只
# 进行读操作，我们可以让shelve通过只读方式打开DB

f2 = shelve.open(‘shelve_file‘, writeback=True)
# 由于shelve在默认情况下是不会记录待持久化对象的任何修改的，所以我们在shelve.open()时候需要修改默
# 认参数，否则对象的修改不会保存。
# writeback方式有优点也有缺点。优点是减少了我们出错的概率，并且让对象的持久化对用户更加的透明了；
# 但这种方式并不是所有的情况下都需要，首先，使用writeback以后，shelf在open()的时候会增加额外的内
# 存消耗，并且当DB在close()的时候会将缓存中的每一个对象都写入到DB，这也会带来额外的等待时间。因为
# shelve没有办法知道缓存中哪些对象修改了，哪些对象没有修改，因此所有的对象都会被写入。



import hashlib

md5 = hashlib.md5()
md5.update(‘how to use md5 in python hashlib?‘.encode(‘utf-8‘))        #TypeError: Unicode-objects must be encoded before hashing
# print md5.hexdigest()                                    # d26a53750bc40b38b65a520292f69306
# 如果数据量很大，可以分块多次调用update()，最后计算的结果是一样的：
# md5.update(‘how to use md5‘.encode(‘utf-8‘))
# md5.update(‘ in python hashlib?‘.encode(‘utf-8‘))        # d26a53750bc40b38b65a520292f69306
# MD5是最常见的摘要算法，速度很快，生成结果是固定的128 bit字节，通常用一个32位的16进制字符串表示。
# 另一种常见的摘要算法是SHA1，调用SHA1和调用MD5完全类似：
# sha1 = hashlib.sha1()
# sha1.update(‘how to use sha1 in ‘)
# sha1.update(‘python hashlib?‘)
# print sha1.hexdigest()

hashlib.md5("salt".encode("utf8"))            # 经过Salt处理的MD5口令    俗称“加盐”
# 摘要算法在很多地方都有广泛的应用。要注意摘要算法不是加密算法，不能用于加密（因为无法通过摘要
# 反推明文），只能用于防篡改，但是它的单向计算特性决定了可以在不存储明文口令的情况下验证用户口令。



import collections

# 在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：
# Counter、deque、defaultdict、namedtuple和OrderedDict等。

from collections import namedtuple
# Point = namedtuple(‘Point‘, [‘x‘, ‘y‘])    # 一个点的二维坐标就可以表示成：
# p = Point(1, 2)    # p2 = Point(3, 2)
# print(P ,P.x ,P.y)                        # Point(x=1, y=2) 1 2
# 类似的，如果要用坐标和半径表示一个圆，也可以用namedtuple定义：# namedtuple(‘名称‘, [属性list]) 
# Circle = namedtuple(‘Circle‘, [‘x‘, ‘y‘, ‘r‘])

#队列
# # import queue        # FIFO
# # q = queue.Queue()
# # q.put([1,2,3])        # 一次一个
# # print(q.get())       # 没有的话会阻塞
# # print(q.qsize())    # 有多少 

from collections import deque
# q = deque([‘a‘, ‘b‘, ‘c‘])
# q.append(‘x‘)
# q.appendleft(‘y‘)
# print(q)        # deque([‘y‘, ‘a‘, ‘b‘, ‘c‘, ‘x‘])
# deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，
# 这样就可以非常高效地往头部添加或删除元素。
# 使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，
# 数据量大的时候，插入和删除效率很低。
# deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈

from collections import OrderedDict
# 使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。
# 如果要保持Key的顺序，可以用OrderedDict：
# d = dict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
# od = OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
# print(od)        # OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])    # OrderedDict的Key是有序的

# 注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：
# od = OrderedDict()
# od[‘z‘] = 1    # od[‘y‘] = 2    # od[‘x‘] = 3
# od.keys()     # [‘z‘, ‘y‘, ‘x‘]    # 按照插入的Key的顺序返回

from collections import defaultdict
# 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，
# 将小于 66 的值保存至第二个key的值中。即： {‘k1‘: 大于66 , ‘k2‘: 小于66}
# values = [11, 22, 33,44,55,66,77,88,99,90]
# my_dict = defaultdict(list)        # defaultdict(lambda:5)
# for value in  values:
#     if value>66:my_dict[‘k1‘].append(value)
#     else:my_dict[‘k2‘].append(value)

# 大概就是设置一个字典的默认value类型，然后直接用key对value这个值或这个类型所拥有的方法属性进行操作
# dd = defaultdict(lambda: ‘N/A‘)
# dd[‘key2‘]         # key2不存在，返回默认值‘N/A‘

from collections import Counter
# Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，
# 其中元素作为key，其计数作为value。
# c = Counter(‘abcdeabcdabcaba‘)
# print c        # Counter({‘a‘: 5, ‘b‘: 4, ‘c‘: 3, ‘d‘: 2, ‘e‘: 1})




import time

# 常用方法
# 1.time.sleep(2)    # 单位为秒。
# 2.time.time()        # 获取当前时间戳

# 在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串
# 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 当前时区的名称                    %% %号本身

# 元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）
索引（Index）    属性（Attribute）值（Values）
0     tm_year        （年）             比如2011 
1     tm_mon        （月）             1 - 12 
2     tm_mday        （日）             1 - 31 
3     tm_hour        （时）             0 - 23 
4     tm_min        （分）             0 - 59 
5     tm_sec        （秒）             0 - 60 
6     tm_wday        （weekday）        0 - 6（0表示周一） 
7     tm_yday    （一年中的第几天）    1 - 366 
8     tm_isdst（是否是夏令时）    默认为0

# time.strftime("%Y-%m-%d %X")    # 时间字符串    # ‘2017-07-24 13:54:37‘
# 时间元组:localtime将一个时间戳转换为当前时区的struct_time
# time.localtime()
# time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,tm_hour=13, tm_min=59, tm_sec=37,tm_wday=0,
#  tm_yday=205, tm_isdst=0)


# 时间戳
# time.time()        # 1500875844.800804

# -->结构化时间
# time.gmtime()                # 如果不传参数，直接返回当前时间的struct_time
# time.localtime()
# time.gmtime(时间戳)        # UTC时间，与英国伦敦当地时间一致
# time.localtime(时间戳)     # 当地时间,在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间
#
# time.gmtime(time.time())
# time.localtime(1500000000)
#
# time.strptime("2017-03-16","%Y-%m-%d")    # time.strptime(时间字符串,字符串对应格式)
# print(ret)    # time.struct_time(tm_year=2018, tm_mon=8, tm_mday=11, tm_hour=14, tm_min=11,tm_sec=52, tm_wday=5, tm_yday=223, tm_isdst=0)


# -->时间戳　
# time.mktime(结构化时间)
# time.mktime(time.localtime(1500000000)


# -->字符串时间
# time.strftime("格式定义","结构化时间")      # 结构化时间参数若不传，则显示当前时间
# time.strftime("%Y-%m-%d",time.localtime(1500000000))
# 
# time.asctime(结构化时间)                     # 如果不传参数，直接返回当前时间的格式化串
# time.asctime(time.localtime(1500000000))    # --> %a %b %d %H:%M:%S %Y串    # ‘Fri Jul 14 10:40:00 2017‘
#
# time.ctime(时间戳)                        # 如果不传参数，直接返回当前时间的格式化串
# time.ctime(1500000000)                    # --> %a %b %d %H:%M:%S %Y串    # ‘Mon Jul 24 15:19:07 2017‘