Cách dùng trăn muối

Tuần tự hóa trong Python

Quá trình tuần tự hóa là một cách để chuyển đổi cấu trúc dữ liệu thành dạng tuyến tính có thể được lưu trữ hoặc truyền qua mạng

Trong Python, tuần tự hóa cho phép bạn lấy một cấu trúc đối tượng phức tạp và chuyển đổi nó thành một luồng byte có thể được lưu vào đĩa hoặc gửi qua mạng. Bạn cũng có thể thấy quá trình này được gọi là sắp xếp. Quá trình đảo ngược, lấy một luồng byte và chuyển đổi nó trở lại thành cấu trúc dữ liệu, được gọi là giải tuần tự hóa hoặc sắp xếp lại

Tuần tự hóa có thể được sử dụng trong nhiều tình huống khác nhau. Một trong những cách sử dụng phổ biến nhất là lưu trạng thái của mạng thần kinh sau giai đoạn đào tạo để bạn có thể sử dụng nó sau này mà không phải thực hiện lại quá trình đào tạo

Python cung cấp ba mô-đun khác nhau trong thư viện chuẩn cho phép bạn tuần tự hóa và giải tuần tự hóa các đối tượng

1. Mô-đun

   # pickling_error.py
   import pickle
   
   square = lambda x : x * x
   my_pickle = pickle.dumps[square]
   

   0
2. Mô-đun

   # pickling_error.py
   import pickle
   
   square = lambda x : x * x
   my_pickle = pickle.dumps[square]
   

   1
3. Mô-đun

   $ python pickling.py
   This is my pickled object:
   b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'
   
   This is a_dict of the unpickled object:
   {'first': 'a', 'second': 2, 'third': [1, 2, 3]}
   

   7

Ngoài ra, Python hỗ trợ XML, mà bạn cũng có thể sử dụng để tuần tự hóa các đối tượng

Mô-đun

# pickling_error.py
import pickle

square = lambda x : x * x
my_pickle = pickle.dumps[square]

# pickling_error.py
import pickle

square = lambda x : x * x
my_pickle = pickle.dumps[square]

# pickling_error.py
import pickle

square = lambda x : x * x
my_pickle = pickle.dumps[square]

Mô-đun

# pickling_error.py
import pickle

square = lambda x : x * x
my_pickle = pickle.dumps[square]

Có một số lý do để chọn định dạng JSON. Nó có thể đọc được bằng con người và không phụ thuộc vào ngôn ngữ, đồng thời nhẹ hơn XML. Với mô-đun

# pickling_error.py
import pickle

square = lambda x : x * x
my_pickle = pickle.dumps[square]

• # pickling_error.py
  import pickle
  
  square = lambda x : x * x
  my_pickle = pickle.dumps[square]
  

  8

• # pickling_error.py
  import pickle
  
  square = lambda x : x * x
  my_pickle = pickle.dumps[square]
  

  9

• $ python pickling_error.py
  Traceback [most recent call last]:
    File "pickling_error.py", line 6, in 
      my_pickle = pickle.dumps[square]
  _pickle.PicklingError: Can't pickle : attribute lookup  on __main__ failed
  

  2

• $ python pickling_error.py
  Traceback [most recent call last]:
    File "pickling_error.py", line 6, in 
      my_pickle = pickle.dumps[square]
  _pickle.PicklingError: Can't pickle : attribute lookup  on __main__ failed
  

  3

• $ python pickling_error.py
  Traceback [most recent call last]:
    File "pickling_error.py", line 6, in 
      my_pickle = pickle.dumps[square]
  _pickle.PicklingError: Can't pickle : attribute lookup  on __main__ failed
  

  4

• $ python pickling_error.py
  Traceback [most recent call last]:
    File "pickling_error.py", line 6, in 
      my_pickle = pickle.dumps[square]
  _pickle.PicklingError: Can't pickle : attribute lookup  on __main__ failed
  

  5

Mô-đun Python

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

# pickling_error.py
import pickle

square = lambda x : x * x
my_pickle = pickle.dumps[square]

Ghi chú. Từ giờ trở đi, bạn sẽ thấy các thuật ngữ pickling và unpickling được sử dụng để chỉ việc tuần tự hóa và giải tuần tự hóa với mô-đun

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Vì vậy, bạn có một số cách khác nhau để tuần tự hóa và giải tuần tự hóa các đối tượng trong Python. Nhưng cái nào bạn nên sử dụng? . Tất cả phụ thuộc vào trường hợp sử dụng của bạn

Dưới đây là ba hướng dẫn chung để quyết định nên sử dụng phương pháp nào

1. Không sử dụng mô-đun

   # pickling_error.py
   import pickle
   
   square = lambda x : x * x
   my_pickle = pickle.dumps[square]
   

   0. Nó được sử dụng chủ yếu bởi trình thông dịch và tài liệu chính thức cảnh báo rằng những người bảo trì Python có thể sửa đổi định dạng theo những cách không tương thích ngược

2. Mô-đun

   # pickling_error.py
   import pickle
   
   square = lambda x : x * x
   my_pickle = pickle.dumps[square]
   

   1 và XML là những lựa chọn tốt nếu bạn cần khả năng tương tác với các ngôn ngữ khác nhau hoặc định dạng mà con người có thể đọc được

3. Mô-đun Python

   $ python pickling.py
   This is my pickled object:
   b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'
   
   This is a_dict of the unpickled object:
   {'first': 'a', 'second': 2, 'third': [1, 2, 3]}
   

   7 là lựa chọn tốt hơn cho tất cả các trường hợp sử dụng còn lại. Nếu bạn không cần định dạng mà con người có thể đọc được hoặc định dạng có thể tương tác tiêu chuẩn hoặc nếu bạn cần sắp xếp theo thứ tự các đối tượng tùy chỉnh, thì hãy sử dụng

   $ python pickling.py
   This is my pickled object:
   b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'
   
   This is a_dict of the unpickled object:
   {'first': 'a', 'second': 2, 'third': [1, 2, 3]}
   

   7

Bên trong Mô-đun

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

7 của Python

Mô-đun Python

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

1. # pickling_dill.py
   import dill
   
   square = lambda x: x * x
   my_pickle = dill.dumps[square]
   print[my_pickle]
   

   5

2. # pickling_dill.py
   import dill
   
   square = lambda x: x * x
   my_pickle = dill.dumps[square]
   print[my_pickle]
   

   6

3. # pickling_dill.py
   import dill
   
   square = lambda x: x * x
   my_pickle = dill.dumps[square]
   print[my_pickle]
   

   7

4. # pickling_dill.py
   import dill
   
   square = lambda x: x * x
   my_pickle = dill.dumps[square]
   print[my_pickle]
   

   8

Hai phương pháp đầu tiên được sử dụng trong quá trình tẩy và hai phương pháp còn lại được sử dụng trong quá trình tẩy. Sự khác biệt duy nhất giữa

# pickling_dill.py
import dill

square = lambda x: x * x
my_pickle = dill.dumps[square]
print[my_pickle]

$ python pickling_dill.py
b'\x80\x03cdill._dill\n_create_function\nq\x00[cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04[K\x01K\x00K\x01K\x02KCC\x08|\x00|\x00\x14\x00S\x00q\x05N\x85q\x06]X\x01\x00\x00\x00xq\x07\x85q\x08X\x10\x00\x00\x00pickling_dill.pyq\tX\t\x00\x00\x00squareq\nK\x04C\x00q\x0b]]tq\x0cRq\rc__builtin__\n__main__\nh\nNN}q\x0eNtq\x0fRq\x10.'

Để phân biệt giữa

$ python pickling_dill.py
b'\x80\x03cdill._dill\n_create_function\nq\x00[cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04[K\x01K\x00K\x01K\x02KCC\x08|\x00|\x00\x14\x00S\x00q\x05N\x85q\x06]X\x01\x00\x00\x00xq\x07\x85q\x08X\x10\x00\x00\x00pickling_dill.pyq\tX\t\x00\x00\x00squareq\nK\x04C\x00q\x0b]]tq\x0cRq\rc__builtin__\n__main__\nh\nNN}q\x0eNtq\x0fRq\x10.'

# pickling_dill.py
import dill

square = lambda x: x * x
my_pickle = dill.dumps[square]
print[my_pickle]

$ python pickling_dill.py
b'\x80\x03cdill._dill\n_create_function\nq\x00[cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04[K\x01K\x00K\x01K\x02KCC\x08|\x00|\x00\x14\x00S\x00q\x05N\x85q\x06]X\x01\x00\x00\x00xq\x07\x85q\x08X\x10\x00\x00\x00pickling_dill.pyq\tX\t\x00\x00\x00squareq\nK\x04C\x00q\x0b]]tq\x0cRq\rc__builtin__\n__main__\nh\nNN}q\x0eNtq\x0fRq\x10.'

$ python pickling_dill.py
b'\x80\x03cdill._dill\n_create_function\nq\x00[cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04[K\x01K\x00K\x01K\x02KCC\x08|\x00|\x00\x14\x00S\x00q\x05N\x85q\x06]X\x01\x00\x00\x00xq\x07\x85q\x08X\x10\x00\x00\x00pickling_dill.pyq\tX\t\x00\x00\x00squareq\nK\x04C\x00q\x0b]]tq\x0cRq\rc__builtin__\n__main__\nh\nNN}q\x0eNtq\x0fRq\x10.'

Xem xét ví dụ sau. Giả sử bạn có một lớp được xác định tùy chỉnh có tên là

$ python pickling_dill.py
b'\x80\x03cdill._dill\n_create_function\nq\x00[cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04[K\x01K\x00K\x01K\x02KCC\x08|\x00|\x00\x14\x00S\x00q\x05N\x85q\x06]X\x01\x00\x00\x00xq\x07\x85q\x08X\x10\x00\x00\x00pickling_dill.pyq\tX\t\x00\x00\x00squareq\nK\x04C\x00q\x0b]]tq\x0cRq\rc__builtin__\n__main__\nh\nNN}q\x0eNtq\x0fRq\x10.'

• $ python pickling_dill.py
  b'\x80\x03cdill._dill\n_create_function\nq\x00[cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04[K\x01K\x00K\x01K\x02KCC\x08|\x00|\x00\x14\x00S\x00q\x05N\x85q\x06]X\x01\x00\x00\x00xq\x07\x85q\x08X\x10\x00\x00\x00pickling_dill.pyq\tX\t\x00\x00\x00squareq\nK\x04C\x00q\x0b]]tq\x0cRq\rc__builtin__\n__main__\nh\nNN}q\x0eNtq\x0fRq\x10.'
  

  8

• $ python pickling_dill.py
  b'\x80\x03cdill._dill\n_create_function\nq\x00[cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04[K\x01K\x00K\x01K\x02KCC\x08|\x00|\x00\x14\x00S\x00q\x05N\x85q\x06]X\x01\x00\x00\x00xq\x07\x85q\x08X\x10\x00\x00\x00pickling_dill.pyq\tX\t\x00\x00\x00squareq\nK\x04C\x00q\x0b]]tq\x0cRq\rc__builtin__\n__main__\nh\nNN}q\x0eNtq\x0fRq\x10.'
  

  9

• >>> square = lambda x : x * x
  >>> a = square[35]
  >>> import math
  >>> b = math.sqrt[484]
  >>> import dill
  >>> dill.dump_session['test.pkl']
  >>> exit[]
  

  0

• >>> square = lambda x : x * x
  >>> a = square[35]
  >>> import math
  >>> b = math.sqrt[484]
  >>> import dill
  >>> dill.dump_session['test.pkl']
  >>> exit[]
  

  1

• >>> square = lambda x : x * x
  >>> a = square[35]
  >>> import math
  >>> b = math.sqrt[484]
  >>> import dill
  >>> dill.dump_session['test.pkl']
  >>> exit[]
  

  2

Ví dụ dưới đây cho thấy cách bạn có thể khởi tạo lớp và chọn cá thể để nhận một chuỗi đơn giản. Sau khi chọn lớp, bạn có thể thay đổi giá trị của các thuộc tính của nó mà không ảnh hưởng đến chuỗi đã chọn. Sau đó, bạn có thể giải nén chuỗi đã chọn trong một biến khác, khôi phục một bản sao chính xác của lớp đã chọn trước đó

# pickling.py
import pickle

class example_class:
    a_number = 35
    a_string = "hey"
    a_list = [1, 2, 3]
    a_dict = {"first": "a", "second": 2, "third": [1, 2, 3]}
    a_tuple = [22, 23]

my_object = example_class[]

my_pickled_object = pickle.dumps[my_object]  # Pickling the object
print[f"This is my pickled object:\n{my_pickled_object}\n"]

my_object.a_dict = None

my_unpickled_object = pickle.loads[my_pickled_object]  # Unpickling the object
print[
    f"This is a_dict of the unpickled object:\n{my_unpickled_object.a_dict}\n"]

Trong ví dụ trên, bạn tạo một số đối tượng khác nhau và sắp xếp chúng theo thứ tự với

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Quá trình tẩy kết thúc chính xác, lưu trữ toàn bộ phiên bản của bạn trong chuỗi này.

>>> square = lambda x : x * x
>>> a = square[35]
>>> import math
>>> b = math.sqrt[484]
>>> import dill
>>> dill.dump_session['test.pkl']
>>> exit[]

>>> square = lambda x : x * x
>>> a = square[35]
>>> import math
>>> b = math.sqrt[484]
>>> import dill
>>> dill.dump_session['test.pkl']
>>> exit[]

$ python pickling_error.py
Traceback [most recent call last]:
  File "pickling_error.py", line 6, in 
    my_pickle = pickle.dumps[square]
_pickle.PicklingError: Can't pickle : attribute lookup  on __main__ failed

Cuối cùng, bạn giải nén chuỗi thành một thể hiện hoàn toàn mới. Những gì bạn nhận được là một bản sao sâu của cấu trúc đối tượng ban đầu của bạn từ thời điểm quá trình tẩy bắt đầu

Định dạng giao thức của mô-đun Python

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

7

Như đã đề cập ở trên, mô-đun

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Điều này có nghĩa là nếu bạn đã chọn một đối tượng bằng một phiên bản Python cụ thể, thì bạn không thể giải nén nó bằng phiên bản cũ hơn. Khả năng tương thích tùy thuộc vào phiên bản giao thức mà bạn đã sử dụng cho quy trình tẩy

Hiện tại có sáu giao thức khác nhau mà mô-đun Python

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

1. Giao thức phiên bản 0 là phiên bản đầu tiên. Không giống như các giao thức sau này, con người có thể đọc được
2. Giao thức phiên bản 1 là định dạng nhị phân đầu tiên
3. Giao thức phiên bản 2 đã được giới thiệu trong Python 2. 3
4. Giao thức phiên bản 3 đã được thêm vào Python 3. 0. Nó không thể được giải nén bởi Python 2. x
5. Giao thức phiên bản 4 đã được thêm vào Python 3. 4. Nó có tính năng hỗ trợ cho nhiều loại kích thước và loại đối tượng hơn và là giao thức mặc định bắt đầu với Python 3. 8
6. Giao thức phiên bản 5 đã được thêm vào Python 3. 8. Nó có tính năng hỗ trợ dữ liệu ngoài băng tần và cải thiện tốc độ cho dữ liệu trong băng tần

Ghi chú. Các phiên bản mới hơn của giao thức cung cấp nhiều tính năng và cải tiến hơn nhưng chỉ giới hạn ở các phiên bản cao hơn của trình thông dịch. Hãy chắc chắn xem xét điều này khi chọn giao thức nào sẽ sử dụng

Để xác định giao thức cao nhất mà thông dịch viên của bạn hỗ trợ, bạn có thể kiểm tra giá trị của thuộc tính

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

Để chọn một giao thức cụ thể, bạn cần chỉ định phiên bản giao thức khi bạn gọi

$ python pickling_dill.py
b'\x80\x03cdill._dill\n_create_function\nq\x00[cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04[K\x01K\x00K\x01K\x02KCC\x08|\x00|\x00\x14\x00S\x00q\x05N\x85q\x06]X\x01\x00\x00\x00xq\x07\x85q\x08X\x10\x00\x00\x00pickling_dill.pyq\tX\t\x00\x00\x00squareq\nK\x04C\x00q\x0b]]tq\x0cRq\rc__builtin__\n__main__\nh\nNN}q\x0eNtq\x0fRq\x10.'

$ python pickling_dill.py
b'\x80\x03cdill._dill\n_create_function\nq\x00[cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04[K\x01K\x00K\x01K\x02KCC\x08|\x00|\x00\x14\x00S\x00q\x05N\x85q\x06]X\x01\x00\x00\x00xq\x07\x85q\x08X\x10\x00\x00\x00pickling_dill.pyq\tX\t\x00\x00\x00squareq\nK\x04C\x00q\x0b]]tq\x0cRq\rc__builtin__\n__main__\nh\nNN}q\x0eNtq\x0fRq\x10.'

# pickling_dill.py
import dill

square = lambda x: x * x
my_pickle = dill.dumps[square]
print[my_pickle]

$ python pickling_dill.py
b'\x80\x03cdill._dill\n_create_function\nq\x00[cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04[K\x01K\x00K\x01K\x02KCC\x08|\x00|\x00\x14\x00S\x00q\x05N\x85q\x06]X\x01\x00\x00\x00xq\x07\x85q\x08X\x10\x00\x00\x00pickling_dill.pyq\tX\t\x00\x00\x00squareq\nK\x04C\x00q\x0b]]tq\x0cRq\rc__builtin__\n__main__\nh\nNN}q\x0eNtq\x0fRq\x10.'

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

Các loại Picklable và Unpicklable

Bạn đã biết rằng mô-đun

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

# pickling_error.py
import pickle

square = lambda x : x * x
my_pickle = pickle.dumps[square]

Nếu bạn thấy mình phải đối mặt với một đối tượng không thể chọn được, thì có một số điều bạn có thể làm. Tùy chọn đầu tiên là sử dụng thư viện của bên thứ ba, chẳng hạn như

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

Mô-đun

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Để kiểm tra mô-đun này, bạn có thể thử chọn hàm

>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ]]]
>>> import dill
>>> dill.load_session['test.pkl']
>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ], ['dill', ], ['square', ], ['a', 1225], ['math', ], ['b', 22.0]]]
>>> a
1225
>>> b
22.0
>>> square

# pickling_error.py
import pickle

square = lambda x : x * x
my_pickle = pickle.dumps[square]

Nếu bạn cố chạy chương trình này, thì bạn sẽ gặp một ngoại lệ vì mô-đun

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ]]]
>>> import dill
>>> dill.load_session['test.pkl']
>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ], ['dill', ], ['square', ], ['a', 1225], ['math', ], ['b', 22.0]]]
>>> a
1225
>>> b
22.0
>>> square

$ python pickling_error.py
Traceback [most recent call last]:
  File "pickling_error.py", line 6, in 
    my_pickle = pickle.dumps[square]
_pickle.PicklingError: Can't pickle : attribute lookup  on __main__ failed

Bây giờ hãy thử thay thế mô-đun Python

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

# pickling_dill.py
import dill

square = lambda x: x * x
my_pickle = dill.dumps[square]
print[my_pickle]

Nếu bạn chạy mã này, thì bạn sẽ thấy mô-đun

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ]]]
>>> import dill
>>> dill.load_session['test.pkl']
>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ], ['dill', ], ['square', ], ['a', 1225], ['math', ], ['b', 22.0]]]
>>> a
1225
>>> b
22.0
>>> square

$ python pickling_dill.py
b'\x80\x03cdill._dill\n_create_function\nq\x00[cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04[K\x01K\x00K\x01K\x02KCC\x08|\x00|\x00\x14\x00S\x00q\x05N\x85q\x06]X\x01\x00\x00\x00xq\x07\x85q\x08X\x10\x00\x00\x00pickling_dill.pyq\tX\t\x00\x00\x00squareq\nK\x04C\x00q\x0b]]tq\x0cRq\rc__builtin__\n__main__\nh\nNN}q\x0eNtq\x0fRq\x10.'

Một tính năng thú vị khác của

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

>>>

>>> square = lambda x : x * x
>>> a = square[35]
>>> import math
>>> b = math.sqrt[484]
>>> import dill
>>> dill.dump_session['test.pkl']
>>> exit[]

Trong ví dụ này, bạn khởi động trình thông dịch, nhập mô-đun và xác định hàm

>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ]]]
>>> import dill
>>> dill.load_session['test.pkl']
>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ], ['dill', ], ['square', ], ['a', 1225], ['math', ], ['b', 22.0]]]
>>> a
1225
>>> b
22.0
>>> square

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

# custom_pickling.py

import pickle

class foobar:
    def __init__[self]:
        self.a = 35
        self.b = "test"
        self.c = lambda x: x * x

    def __getstate__[self]:
        attributes = self.__dict__.copy[]
        del attributes['c']
        return attributes

my_foobar_instance = foobar[]
my_pickle_string = pickle.dumps[my_foobar_instance]
my_new_instance = pickle.loads[my_pickle_string]

print[my_new_instance.__dict__]

Nếu mọi thứ đều ổn, thì bạn sẽ nhận được tệp

# custom_pickling.py

import pickle

class foobar:
    def __init__[self]:
        self.a = 35
        self.b = "test"
        self.c = lambda x: x * x

    def __getstate__[self]:
        attributes = self.__dict__.copy[]
        del attributes['c']
        return attributes

my_foobar_instance = foobar[]
my_pickle_string = pickle.dumps[my_foobar_instance]
my_new_instance = pickle.loads[my_pickle_string]

print[my_new_instance.__dict__]

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

Bây giờ bạn có thể bắt đầu phiên bản mới của trình thông dịch và tải tệp

# custom_pickling.py

import pickle

class foobar:
    def __init__[self]:
        self.a = 35
        self.b = "test"
        self.c = lambda x: x * x

    def __getstate__[self]:
        attributes = self.__dict__.copy[]
        del attributes['c']
        return attributes

my_foobar_instance = foobar[]
my_pickle_string = pickle.dumps[my_foobar_instance]
my_new_instance = pickle.loads[my_pickle_string]

print[my_new_instance.__dict__]

>>>

>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ]]]
>>> import dill
>>> dill.load_session['test.pkl']
>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ], ['dill', ], ['square', ], ['a', 1225], ['math', ], ['b', 22.0]]]
>>> a
1225
>>> b
22.0
>>> square

Câu lệnh

# custom_pickling.py

import pickle

class foobar:
    def __init__[self]:
        self.a = 35
        self.b = "test"
        self.c = lambda x: x * x

    def __getstate__[self]:
        attributes = self.__dict__.copy[]
        del attributes['c']
        return attributes

my_foobar_instance = foobar[]
my_pickle_string = pickle.dumps[my_foobar_instance]
my_new_instance = pickle.loads[my_pickle_string]

print[my_new_instance.__dict__]

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

# custom_pickling.py

import pickle

class foobar:
    def __init__[self]:
        self.a = 35
        self.b = "test"
        self.c = lambda x: x * x

    def __getstate__[self]:
        attributes = self.__dict__.copy[]
        del attributes['c']
        return attributes

my_foobar_instance = foobar[]
my_pickle_string = pickle.dumps[my_foobar_instance]
my_new_instance = pickle.loads[my_pickle_string]

print[my_new_instance.__dict__]

Ghi chú. Trước khi bạn sử dụng

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Mặc dù

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ ls test.pkl
4 -rw-r--r--@ 1 dave  staff  439 Feb  3 10:52 test.pkl

Vì vậy, làm thế nào bạn có thể giải quyết vấn đề này?

Giải pháp trong trường hợp này là loại trừ đối tượng khỏi quá trình tuần tự hóa và khởi tạo lại kết nối sau khi đối tượng được giải tuần tự hóa

Bạn có thể sử dụng

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Trong ví dụ sau, bạn sẽ thấy cách bạn có thể định nghĩa một lớp có nhiều thuộc tính và loại trừ một thuộc tính khỏi quá trình tuần tự hóa với

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

# custom_pickling.py

import pickle

class foobar:
    def __init__[self]:
        self.a = 35
        self.b = "test"
        self.c = lambda x: x * x

    def __getstate__[self]:
        attributes = self.__dict__.copy[]
        del attributes['c']
        return attributes

my_foobar_instance = foobar[]
my_pickle_string = pickle.dumps[my_foobar_instance]
my_new_instance = pickle.loads[my_pickle_string]

print[my_new_instance.__dict__]

Trong ví dụ này, bạn tạo một đối tượng có ba thuộc tính. Vì một thuộc tính là

>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ]]]
>>> import dill
>>> dill.load_session['test.pkl']
>>> globals[].items[]
dict_items[[['__name__', '__main__'], ['__doc__', None], ['__package__', None], ['__loader__', ], ['__spec__', None], ['__annotations__', {}], ['__builtins__', ], ['dill', ], ['square', ], ['a', 1225], ['math', ], ['b', 22.0]]]
>>> a
1225
>>> b
22.0
>>> square

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Để giải quyết vấn đề này, bạn chỉ định những gì cần ngâm với

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Nếu bạn chạy ví dụ này và sau đó giải tuần tự hóa đối tượng, thì bạn sẽ thấy rằng phiên bản mới không chứa thuộc tính

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Nhưng điều gì sẽ xảy ra nếu bạn muốn thực hiện một số thao tác khởi tạo bổ sung trong khi giải nén, chẳng hạn bằng cách thêm đối tượng

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Bằng cách chuyển đối tượng bị loại trừ

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Nén các đối tượng ngâm

Mặc dù định dạng dữ liệu

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Để nén chuỗi đã ngâm với

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Trong ví dụ sau, bạn sẽ lấy một chuỗi, chọn lọc và sau đó nén nó bằng thư viện

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

>>>

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Khi sử dụng tính năng nén, hãy nhớ rằng các tệp nhỏ hơn phải trả giá bằng quy trình chậm hơn

Mối quan tâm về bảo mật với Mô-đun

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

7 của Python

Bây giờ bạn đã biết cách sử dụng mô-đun

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Tuy nhiên, còn một điều nữa bạn cần biết về mô-đun

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Vì vậy, bạn có thể làm gì để giảm rủi ro này?

Đáng buồn thay, không nhiều. Nguyên tắc chung là không bao giờ giải nén dữ liệu đến từ nguồn không đáng tin cậy hoặc được truyền qua mạng không an toàn. Để ngăn chặn các cuộc tấn công trung gian, bạn nên sử dụng các thư viện như

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Ví dụ sau đây minh họa cách giải nén một dưa chua giả mạo có thể khiến hệ thống của bạn bị kẻ tấn công tấn công, thậm chí cung cấp cho chúng một trình bao từ xa đang hoạt động

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Trong ví dụ này, quy trình giải nén thực thi

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Đây là cách bạn có thể kiểm tra tập lệnh này một cách an toàn trên máy Mac hoặc hộp Linux của mình. Đầu tiên, mở terminal và sử dụng lệnh

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Đây sẽ là thiết bị đầu cuối của kẻ tấn công. Nếu mọi thứ hoạt động, thì lệnh dường như bị treo

Tiếp theo, mở một thiết bị đầu cuối khác trên cùng một máy tính [hoặc trên bất kỳ máy tính nào khác trong mạng] và thực thi mã Python ở trên để gỡ mã độc. Đảm bảo thay đổi địa chỉ IP trong mã thành địa chỉ IP của thiết bị đầu cuối tấn công của bạn. Trong ví dụ của tôi, địa chỉ IP của kẻ tấn công là

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Bằng cách thực thi mã này, nạn nhân sẽ để lộ trình bao cho kẻ tấn công

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Nếu mọi thứ hoạt động, Bash shell sẽ xuất hiện trên bảng điều khiển tấn công. Bảng điều khiển này hiện có thể hoạt động trực tiếp trên hệ thống bị tấn công

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Vì vậy, hãy để tôi nhắc lại điểm quan trọng này một lần nữa. Không sử dụng mô-đun

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Phần kết luận

Bây giờ bạn đã biết cách sử dụng mô-đun

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Trong hướng dẫn này, bạn đã học

• Ý nghĩa của việc tuần tự hóa và giải tuần tự hóa một đối tượng
• Những mô-đun nào bạn có thể sử dụng để tuần tự hóa các đối tượng trong Python
• Những loại đối tượng nào có thể được tuần tự hóa với mô-đun Python

  $ python pickling.py
  This is my pickled object:
  b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'
  
  This is a_dict of the unpickled object:
  {'first': 'a', 'second': 2, 'third': [1, 2, 3]}
  

  7
• Cách sử dụng mô-đun Python

  $ python pickling.py
  This is my pickled object:
  b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'
  
  This is a_dict of the unpickled object:
  {'first': 'a', 'second': 2, 'third': [1, 2, 3]}
  

  7 để tuần tự hóa hệ thống phân cấp đối tượng
• Rủi ro của việc gỡ lỗi từ một nguồn không đáng tin cậy là gì

Với kiến ​​thức này, bạn được trang bị tốt để duy trì các đối tượng của mình bằng cách sử dụng mô-đun Python

$ python pickling.py
This is my pickled object:
b'\x80\x03c__main__\nexample_class\nq\x00]\x81q\x01.'

This is a_dict of the unpickled object:
{'first': 'a', 'second': 2, 'third': [1, 2, 3]}

Nếu bạn có bất kỳ câu hỏi nào, hãy để lại bình luận bên dưới hoặc liên hệ với tôi trên Twitter