Lưu danh sách trong python dưa chua

So sánh với

# Simple example presenting how persistent ID can be used to pickle
# external objects by reference.

import pickle
import sqlite3
from collections import namedtuple

# Simple class representing a record in our database.
MemoRecord = namedtuple["MemoRecord", "key, task"]

class DBPickler[pickle.Pickler]:

    def persistent_id[self, obj]:
        # Instead of pickling MemoRecord as a regular class instance, we emit a
        # persistent ID.
        if isinstance[obj, MemoRecord]:
            # Here, our persistent ID is simply a tuple, containing a tag and a
            # key, which refers to a specific record in the database.
            return ["MemoRecord", obj.key]
        else:
            # If obj does not have a persistent ID, return None. This means obj
            # needs to be pickled as usual.
            return None


class DBUnpickler[pickle.Unpickler]:

    def __init__[self, file, connection]:
        super[].__init__[file]
        self.connection = connection

    def persistent_load[self, pid]:
        # This method is invoked whenever a persistent ID is encountered.
        # Here, pid is the tuple returned by DBPickler.
        cursor = self.connection.cursor[]
        type_tag, key_id = pid
        if type_tag == "MemoRecord":
            # Fetch the referenced record from the database and return it.
            cursor.execute["SELECT * FROM memos WHERE key=?", [str[key_id],]]
            key, task = cursor.fetchone[]
            return MemoRecord[key, task]
        else:
            # Always raises an error if you cannot return the correct object.
            # Otherwise, the unpickler will think None is the object referenced
            # by the persistent ID.
            raise pickle.UnpicklingError["unsupported persistent object"]


def main[]:
    import io
    import pprint

    # Initialize and populate our database.
    conn = sqlite3.connect[":memory:"]
    cursor = conn.cursor[]
    cursor.execute["CREATE TABLE memos[key INTEGER PRIMARY KEY, task TEXT]"]
    tasks = [
        'give food to fish',
        'prepare group meeting',
        'fight with a zebra',
        ]
    for task in tasks:
        cursor.execute["INSERT INTO memos VALUES[NULL, ?]", [task,]]

    # Fetch the records to be pickled.
    cursor.execute["SELECT * FROM memos"]
    memos = [MemoRecord[key, task] for key, task in cursor]
    # Save the records using our custom DBPickler.
    file = io.BytesIO[]
    DBPickler[file].dump[memos]

    print["Pickled records:"]
    pprint.pprint[memos]

    # Update a record, just for good measure.
    cursor.execute["UPDATE memos SET task='learn italian' WHERE key=1"]

    # Load the records from the pickle data stream.
    file.seek[0]
    memos = DBUnpickler[file, conn].load[]

    print["Unpickled records:"]
    pprint.pprint[memos]


if __name__ == '__main__':
    main[]

2

Python có một mô-đun tuần tự hóa nguyên thủy hơn được gọi là , nhưng nói chung phải luôn là cách ưu tiên để tuần tự hóa các đối tượng Python. tồn tại chủ yếu để hỗ trợ các tệp

# Simple example presenting how persistent ID can be used to pickle
# external objects by reference.

import pickle
import sqlite3
from collections import namedtuple

# Simple class representing a record in our database.
MemoRecord = namedtuple["MemoRecord", "key, task"]

class DBPickler[pickle.Pickler]:

    def persistent_id[self, obj]:
        # Instead of pickling MemoRecord as a regular class instance, we emit a
        # persistent ID.
        if isinstance[obj, MemoRecord]:
            # Here, our persistent ID is simply a tuple, containing a tag and a
            # key, which refers to a specific record in the database.
            return ["MemoRecord", obj.key]
        else:
            # If obj does not have a persistent ID, return None. This means obj
            # needs to be pickled as usual.
            return None


class DBUnpickler[pickle.Unpickler]:

    def __init__[self, file, connection]:
        super[].__init__[file]
        self.connection = connection

    def persistent_load[self, pid]:
        # This method is invoked whenever a persistent ID is encountered.
        # Here, pid is the tuple returned by DBPickler.
        cursor = self.connection.cursor[]
        type_tag, key_id = pid
        if type_tag == "MemoRecord":
            # Fetch the referenced record from the database and return it.
            cursor.execute["SELECT * FROM memos WHERE key=?", [str[key_id],]]
            key, task = cursor.fetchone[]
            return MemoRecord[key, task]
        else:
            # Always raises an error if you cannot return the correct object.
            # Otherwise, the unpickler will think None is the object referenced
            # by the persistent ID.
            raise pickle.UnpicklingError["unsupported persistent object"]


def main[]:
    import io
    import pprint

    # Initialize and populate our database.
    conn = sqlite3.connect[":memory:"]
    cursor = conn.cursor[]
    cursor.execute["CREATE TABLE memos[key INTEGER PRIMARY KEY, task TEXT]"]
    tasks = [
        'give food to fish',
        'prepare group meeting',
        'fight with a zebra',
        ]
    for task in tasks:
        cursor.execute["INSERT INTO memos VALUES[NULL, ?]", [task,]]

    # Fetch the records to be pickled.
    cursor.execute["SELECT * FROM memos"]
    memos = [MemoRecord[key, task] for key, task in cursor]
    # Save the records using our custom DBPickler.
    file = io.BytesIO[]
    DBPickler[file].dump[memos]

    print["Pickled records:"]
    pprint.pprint[memos]

    # Update a record, just for good measure.
    cursor.execute["UPDATE memos SET task='learn italian' WHERE key=1"]

    # Load the records from the pickle data stream.
    file.seek[0]
    memos = DBUnpickler[file, conn].load[]

    print["Unpickled records:"]
    pprint.pprint[memos]


if __name__ == '__main__':
    main[]

Mô-đun khác với một số cách quan trọng

• Mô-đun theo dõi các đối tượng mà nó đã đánh số thứ tự, để sau này các tham chiếu đến cùng một đối tượng sẽ không được đánh số thứ tự nữa. không làm điều này

  Điều này có ý nghĩa đối với cả đối tượng đệ quy và chia sẻ đối tượng. Các đối tượng đệ quy là các đối tượng chứa các tham chiếu đến chính chúng. Những thứ này không được xử lý bởi nguyên soái và trên thực tế, việc cố gắng sắp xếp theo thứ tự các đối tượng đệ quy sẽ làm hỏng trình thông dịch Python của bạn. Chia sẻ đối tượng xảy ra khi có nhiều tham chiếu đến cùng một đối tượng ở các vị trí khác nhau trong hệ thống phân cấp đối tượng được tuần tự hóa. lưu trữ các đối tượng như vậy chỉ một lần và đảm bảo rằng tất cả các tham chiếu khác trỏ đến bản sao chính. Các đối tượng được chia sẻ vẫn được chia sẻ, điều này có thể rất quan trọng đối với các đối tượng có thể thay đổi

• không thể được sử dụng để tuần tự hóa các lớp do người dùng định nghĩa và các thể hiện của chúng. có thể lưu và khôi phục các thể hiện của lớp một cách minh bạch, tuy nhiên định nghĩa lớp phải có thể nhập được và nằm trong cùng một mô-đun như khi đối tượng được lưu trữ

• Định dạng tuần tự hóa không được đảm bảo để có thể di chuyển trên các phiên bản Python. Bởi vì công việc chính của nó trong cuộc sống là hỗ trợ các tệp

  # Simple example presenting how persistent ID can be used to pickle
  # external objects by reference.
  
  import pickle
  import sqlite3
  from collections import namedtuple
  
  # Simple class representing a record in our database.
  MemoRecord = namedtuple["MemoRecord", "key, task"]
  
  class DBPickler[pickle.Pickler]:
  
      def persistent_id[self, obj]:
          # Instead of pickling MemoRecord as a regular class instance, we emit a
          # persistent ID.
          if isinstance[obj, MemoRecord]:
              # Here, our persistent ID is simply a tuple, containing a tag and a
              # key, which refers to a specific record in the database.
              return ["MemoRecord", obj.key]
          else:
              # If obj does not have a persistent ID, return None. This means obj
              # needs to be pickled as usual.
              return None
  
  
  class DBUnpickler[pickle.Unpickler]:
  
      def __init__[self, file, connection]:
          super[].__init__[file]
          self.connection = connection
  
      def persistent_load[self, pid]:
          # This method is invoked whenever a persistent ID is encountered.
          # Here, pid is the tuple returned by DBPickler.
          cursor = self.connection.cursor[]
          type_tag, key_id = pid
          if type_tag == "MemoRecord":
              # Fetch the referenced record from the database and return it.
              cursor.execute["SELECT * FROM memos WHERE key=?", [str[key_id],]]
              key, task = cursor.fetchone[]
              return MemoRecord[key, task]
          else:
              # Always raises an error if you cannot return the correct object.
              # Otherwise, the unpickler will think None is the object referenced
              # by the persistent ID.
              raise pickle.UnpicklingError["unsupported persistent object"]
  
  
  def main[]:
      import io
      import pprint
  
      # Initialize and populate our database.
      conn = sqlite3.connect[":memory:"]
      cursor = conn.cursor[]
      cursor.execute["CREATE TABLE memos[key INTEGER PRIMARY KEY, task TEXT]"]
      tasks = [
          'give food to fish',
          'prepare group meeting',
          'fight with a zebra',
          ]
      for task in tasks:
          cursor.execute["INSERT INTO memos VALUES[NULL, ?]", [task,]]
  
      # Fetch the records to be pickled.
      cursor.execute["SELECT * FROM memos"]
      memos = [MemoRecord[key, task] for key, task in cursor]
      # Save the records using our custom DBPickler.
      file = io.BytesIO[]
      DBPickler[file].dump[memos]
  
      print["Pickled records:"]
      pprint.pprint[memos]
  
      # Update a record, just for good measure.
      cursor.execute["UPDATE memos SET task='learn italian' WHERE key=1"]
  
      # Load the records from the pickle data stream.
      file.seek[0]
      memos = DBUnpickler[file, conn].load[]
  
      print["Unpickled records:"]
      pprint.pprint[memos]
  
  
  if __name__ == '__main__':
      main[]
  

  6, nên những người triển khai Python có quyền thay đổi định dạng tuần tự hóa theo những cách không tương thích ngược nếu có nhu cầu. Định dạng tuần tự hóa được đảm bảo tương thích ngược trên các bản phát hành Python miễn là một giao thức pickle tương thích được chọn và mã pickling và unpickling xử lý các khác biệt về loại Python 2 đến Python 3 nếu dữ liệu của bạn vượt qua ranh giới ngôn ngữ thay đổi phá vỡ duy nhất đó

So sánh với

# Simple example presenting how persistent ID can be used to pickle
# external objects by reference.

import pickle
import sqlite3
from collections import namedtuple

# Simple class representing a record in our database.
MemoRecord = namedtuple["MemoRecord", "key, task"]

class DBPickler[pickle.Pickler]:

    def persistent_id[self, obj]:
        # Instead of pickling MemoRecord as a regular class instance, we emit a
        # persistent ID.
        if isinstance[obj, MemoRecord]:
            # Here, our persistent ID is simply a tuple, containing a tag and a
            # key, which refers to a specific record in the database.
            return ["MemoRecord", obj.key]
        else:
            # If obj does not have a persistent ID, return None. This means obj
            # needs to be pickled as usual.
            return None


class DBUnpickler[pickle.Unpickler]:

    def __init__[self, file, connection]:
        super[].__init__[file]
        self.connection = connection

    def persistent_load[self, pid]:
        # This method is invoked whenever a persistent ID is encountered.
        # Here, pid is the tuple returned by DBPickler.
        cursor = self.connection.cursor[]
        type_tag, key_id = pid
        if type_tag == "MemoRecord":
            # Fetch the referenced record from the database and return it.
            cursor.execute["SELECT * FROM memos WHERE key=?", [str[key_id],]]
            key, task = cursor.fetchone[]
            return MemoRecord[key, task]
        else:
            # Always raises an error if you cannot return the correct object.
            # Otherwise, the unpickler will think None is the object referenced
            # by the persistent ID.
            raise pickle.UnpicklingError["unsupported persistent object"]


def main[]:
    import io
    import pprint

    # Initialize and populate our database.
    conn = sqlite3.connect[":memory:"]
    cursor = conn.cursor[]
    cursor.execute["CREATE TABLE memos[key INTEGER PRIMARY KEY, task TEXT]"]
    tasks = [
        'give food to fish',
        'prepare group meeting',
        'fight with a zebra',
        ]
    for task in tasks:
        cursor.execute["INSERT INTO memos VALUES[NULL, ?]", [task,]]

    # Fetch the records to be pickled.
    cursor.execute["SELECT * FROM memos"]
    memos = [MemoRecord[key, task] for key, task in cursor]
    # Save the records using our custom DBPickler.
    file = io.BytesIO[]
    DBPickler[file].dump[memos]

    print["Pickled records:"]
    pprint.pprint[memos]

    # Update a record, just for good measure.
    cursor.execute["UPDATE memos SET task='learn italian' WHERE key=1"]

    # Load the records from the pickle data stream.
    file.seek[0]
    memos = DBUnpickler[file, conn].load[]

    print["Unpickled records:"]
    pprint.pprint[memos]


if __name__ == '__main__':
    main[]

1

Có sự khác biệt cơ bản giữa các giao thức pickle và JSON [Ký hiệu đối tượng JavaScript]

• JSON là định dạng tuần tự hóa văn bản [nó xuất ra văn bản unicode, mặc dù sau đó hầu hết thời gian nó được mã hóa thành

  f = io.BytesIO[]
  p = pickle.Pickler[f]
  p.dispatch_table = copyreg.dispatch_table.copy[]
  p.dispatch_table[SomeClass] = reduce_SomeClass
  

  8], trong khi pickle là định dạng tuần tự hóa nhị phân;

• JSON có thể đọc được bằng con người, trong khi dưa chua thì không;

• JSON có thể tương tác và được sử dụng rộng rãi bên ngoài hệ sinh thái Python, trong khi dưa chua là dành riêng cho Python;

• Theo mặc định, JSON chỉ có thể đại diện cho một tập hợp con của các loại tích hợp Python và không có lớp tùy chỉnh nào;

• Không giống như dưa chua, bản thân việc giải tuần tự hóa JSON không đáng tin cậy không tạo ra lỗ hổng thực thi mã tùy ý

Xem thêm

mô-đun. một mô-đun thư viện tiêu chuẩn cho phép tuần tự hóa và giải tuần tự hóa JSON