json 与 pickle 模块 - 图1

json 模块

json简介

  1. 1、json格式是什么
  2. # 把python中的字典，列表..数据类型转成json格式字符串
  4. # 下面格式是标准的json格式字符串
  5. {"name":"xio","age":18,"handsome":true,"xx":null}
  7. 2、json格式有什么用？
  8. # 存取数据（格式标准），一个程序写入，另一个程序读取（这两个程序可以是不同的语言）
  9. # 后端给前端的数据是json格式字符串
  11. 3、python中如何使用json
  12. #序列化：把某个语言的变量转成json格式字符串
  13. #反序列化：把json格式字符串转成某个语言的变量
  15. # 补充：java中，出于性能的考虑，有很多包来完成序列化和反序列化：谷歌的gson  阿里开源fastjson

dumps

  1. import json  # 导入json模块，内置模块
  3. # 序列化
  4. # 定义一个字典
  5. dic = {'name': 'xio', 'age': 18, 'handsome': True, 'xxx': None}
  6. # 把字典转成json格式字符串
  7. dic_str=json.dumps(dic)
  8. print(dic_str)  # {"name": "xio", "age": 18, "handsome": true, "xxx": null}
  9. print(type(dic_str))  # <class 'str'>

loads

  1. import json
  4. # 反序列化
  5. s='''
  6. {"name": "xio", "age": 18, "handsome": true, "xxx": null}
  7. '''
  8. # 把json格式字符串反序列化成字典
  9. s_dic=json.loads(s)
  10. print(s_dic)  # {'name': 'xio', 'age': 18, 'handsome': True, 'xxx': None}
  11. print(type(s_dic))  # <class 'dict'>
  1. # json模块可以序列化：字典，列表，布尔
  2. # 稍微复杂点的字典+列表格式+布尔格式
  4. dic = {'movieIds': [111, 222, 333, 444],
  5.        'stids': [{'movieId': 11, 'stid': 1}, {'movieId': 22, 'stid': 2}, {'movieId': 33, 'stid': 3}]}
  7. res = json.dumps(dic)
  8. print(res)
  9. # {"movieIds": [111, 222, 333, 444], "stids": [{"movieId": 11, "stid": 1}, {"movieId": 22, "stid": 2}, {"movieId": 33, "stid": 3}]}

dump、load 文件应用

  1. import json
  3. # 序列化和反序列化放到文件中
  5. # 土办法
  6. dic = {'name': 'xio', 'age': 18, 'handsome': True, 'xxx': None}
  7. dic_str = json.dumps(dic)
  8. print(dic_str)
  9. with open('a.json', 'wt', encoding='utf-8') as f:
  10.     f.write(dic_str)
  12. # 序列化的简化写法
  13. dic = {'name': 'xio', 'age': 18, 'handsome': True, 'xxx': None}
  14. with open('a.json', 'wt', encoding='utf-8') as f:
  15.     json.dump(dic, f)
  17. # 反序列化的简化写法
  18. with open('a.json', 'rt', encoding='utf-8') as f:
  19.     dic = json.load(f)
  20. print(dic)
  21. print(type(dic))

补充：ensure_ascii=False

  1. import json
  3. dic = {'name': '小蜗', 'age': 18, 'handsome': True, 'xxx': None}
  4. print(json.dumps(dic,ensure_ascii=False))
  5. # {"name": "小蜗", "age": 18, "handsome": true, "xxx": null}
  6. print(json.dumps(dic))
  7. # {"name": "\u5c0f\u8717", "age": 18, "handsome": true, "xxx": null}

pickle 模块

pickle 序列化与反序列化

  1. import pickle   # 内置模块
  3. # pickle序列化
  4. dic={'name':'xio','age':18}
  5. res=pickle.dumps(dic)
  6. print(res)
  7. #b'\x80\x04\x95\x1a\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x04name\x94\x8c\x03xio\x94\x8c\x03age\x94K\x12u.'
  9. # pickle的反序列化
  10. b = b'\x80\x04\x95\x1a\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x04name\x94\x8c\x03xio\x94\x8c\x03age\x94K\x12u.'
  11. res = pickle.loads(b)
  12. print(res)  # {'name': 'xio', 'age': 18}
  13. print(type(res))  # <class 'dict'>

文件+序列化和反序列化

  1. import pickle
  3. # 文件+序列化和反序列化
  5. dic = {'name': 'xio', 'age': 18}
  6. with open('a.pkl', 'wb') as f:
  7.     pickle.dump(dic, f)
  10. with open('a.pkl', 'rb') as f:
  11.     res = pickle.load(f)
  12.     print(res)

比较pickle和json

  1. '''
  2. json：通用格式，任何语言都有，都可以解析，但是数据类型有限
  3. pickle：只是python使用，转成b格式，其它语言识别不了，任意的数据类型都可以
  5. '''
  6. import json
  7. import pickle
  9. dic = {'a': input}
  10. res = json.dumps(dic)  # 报错
  11. res1 = pickle.dumps(dic)
  12. # b'\x80\x04\x95\x1d\x00\x00\x00\x00\x00\x00\x00}\x94\x8c\x01a\x94\x8c\x08builtins\x94\x8c\x05input\x94\x93\x94s.'
  13. print(res)
  15. dic_2 = pickle.loads(res1)
  16. dic_2['a']()  # 相当于调用了input功能

猴子补丁

  1. # 一.什么是猴子补丁?
  2.       属性在运行时的动态替换，叫做猴子补丁（Monkey Patch）。
  3.       猴子补丁的核心就是用自己的代码替换所用模块的源代码，详细地如下
  4. 　　1，这个词原来为Guerrilla Patch，杂牌军、游击队，说明这部分不是原装的，在英文里guerilla发音和gorllia(猩猩)相似，再后来就写了monkey(猴子)。
  5. 　　2，还有一种解释是说由于这种方式将原来的代码弄乱了(messing with it)，在英文里叫monkeying about(顽皮的)，所以叫做Monkey Patch。
  8. # 二. 猴子补丁的功能(一切皆对象)
  9. 　　1.拥有在模块运行时替换的功能, 例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了)
  10. class Monkey:
  11.     def hello(self):
  12.         print('hello')
  14.     def world(self):
  15.         print('world')
  18. def other_func():
  19.     print("from other_func")
  23. monkey = Monkey()
  24. monkey.hello = monkey.world
  25. monkey.hello()
  26. monkey.world = other_func
  27. monkey.world()
  29. # 三.monkey patch的应用场景
  30. 如果我们的程序中已经基于json模块编写了大量代码了，发现有一个模块ujson比它性能更高，
  31. 但用法一样，我们肯定不会想所有的代码都换成ujson.dumps或者ujson.loads,那我们可能
  32. 会想到这么做
  33. import ujson as json，但是这么做的需要每个文件都重新导入一下，维护成本依然很高
  34. 此时我们就可以用到猴子补丁了
  35. 只需要在入口处加上
  36. , 只需要在入口加上:
  38. import json
  39. import ujson
  41. def monkey_patch_json():
  42.     json.__name__ = 'ujson'
  43.     json.dumps = ujson.dumps
  44.     json.loads = ujson.loads
  46. monkey_patch_json() # 之所以在入口处加，是因为模块在导入一次后，后续的导入便直接引用第一次的成果
  48. #其实这种场景也比较多, 比如我们引用团队通用库里的一个模块, 又想丰富模块的功能, 除了继承之外也可以考虑用Monkey
  49. Patch.采用猴子补丁之后，如果发现ujson不符合预期，那也可以快速撤掉补丁。个人感觉Monkey
  50. Patch带了便利的同时也有搞乱源代码的风险!