編寫自定義類實現json和pickle文件的多行寫入，多行讀取

• json與pickle

  • 序列化（serialization）：將內存中的結構化數據轉換成字節串。
  • 反序列化（deserialization）：從文件中或網絡中獲取的數據轉換成內存中原來的數據類型
  • 具體方法：dump、dumps、load、loads
    • dump與load是對文件進行操做（序列化與反序列化）
    • dumps與loads時對內存中的數據進行操做（序列化與反序列化）

• pickle 寫入多個對象，讀取多個對象

  pickle支持屢次dump，但對於讀取文件，咱們再不清楚內容（load多少次）時，使用try except EOFError
  
  class A:
      def __init__(self):
          self.li = []
  class B:
      def __init__(self):
          self.li = []
  a = A()
  a.li.append(1)
  b = B()
  b.li.append(2)
  
  import pickle
  class My_pickle():
      def __init__(self,path):
          self.path = path
      def dump(self,*args):
          with open(self.path,mode='wb') as f:
              for i in args:
                  pickle.dump(i,f)
      def load(self):
          with open(self.path,mode='rb') as f:
              while 1:
                  try:
                      yield pickle.load(f)
                  except EOFError:
                      break
  
  p1 = My_pickle('test.pikle')
  p1.dump(a,b)
  for i in p1.load():
      print(i)

• json寫入多行

  方式一： 
  將待寫入的多種數據（列表，元組，字典）放到一個列表中寫入，讀取時，將列表反序列化到內存，在逐個返回。
  缺點：一次性取出全部，內存佔用大。
  import json
  class My_json():
      def __init__(self,file):
          self.file = file
      def dump(self,*args):
          with open(self.file,mode='w',encoding='utf-8') as f:
              li = []
              for i in args:
                  li.append(i)
              json.dump(li,f)
  
      def load(self):
          with open(self.file,mode='r',encoding='utf-8') as f:
              ret = json.load(f)
              for j in ret:
                  yield j
  j = My_json('test.json')
  j.dump([1,2,3,4,],'ssss')
  for i in j.load():
      print(i)

  方式二:   推薦
      將待寫入的多種數據（列表，元組，字典）寫入一種數據的同時寫入一個\n，這樣讀取文件的時候，使用for遍歷文件句柄，對於獲得的字符串使用json.loads()方法進行反序列化。
  import json
  class My_json():
      def __init__(self,file):
          self.file = file
      def dump(self,*args):
          with open(self.file,mode='w',encoding='utf-8') as f:
              for i in args:
                  json.dump(i,f)
                  f.write('\n')
      def load(self):
          with open(self.file,encoding='utf-8') as f:
              for line in f:
                  ret = json.loads(line)
                  print(ret)
  j = My_json('test.json')
  j.dump([1,2,3,4,],'ssss')
  j.load()

  方式三:   
     	在方式二的基礎上進行的小改，除了先dump(i)在write('\n'),咱們還能夠先用 dumps(i)序列化數據，而後再write(序列化數據 + '\n')
  import json
  class My_json():
      def __init__(self,file):
          self.file = file
      def dump(self,*args):
          with open(self.file,mode='w',encoding='utf-8') as f:
              for i in args:                
                  f.write(json.dumps(i) + '\n')
      def load(self):
          with open(self.file,encoding='utf-8') as f:
              for line in f:
                  ret = json.loads(line)
                  print(ret)
  j = My_json('test.json')
  j.dump([1,2,3,4,],'ssss')
  j.load()

• pickle和json在對多行寫入，寫出的區別：

  • pickle 支持屢次dump，因此對應着就能夠屢次load來取這個數據，但當咱們不知道文件中有多少個或者不知道該load幾回的時候，咱們能夠使用try except EOFError 來讓它中止。
  • json 不支持屢次dump，因此在dump一次後，在寫入一個換行。 這樣在讀文件的時候，咱們循環遍歷文件句柄，讀一行，用loads （注意這裏的loads是由於，已經對內存的字符串進行處理/而不是文件）