Python Language
Serienummer van pickle-gegevens

Syntaxis

• pickle.dump (object, bestand, protocol) # Een object serialiseren

• pickle.load (file) # Een object de-serialiseren

• pickle.dumps (object, protocol) # Een object serialiseren naar bytes

• pickle.loads (buffer) # Om een object van bytes te de-serienen

parameters

Opmerkingen

Pickle gebruiken om een object te serialiseren en te deserialiseren

De pickle implementeert een algoritme voor het omzetten van een willekeurig Python-object in een reeks bytes. Dit proces wordt ook het serialiseren van het object genoemd. De bytestroom die het object representeert, kan vervolgens worden verzonden of opgeslagen en later worden gereconstrueerd om een nieuw object met dezelfde kenmerken te maken.

Voor de eenvoudigste code gebruiken we de functies dump() en load() .

Om het object te serialiseren

import pickle

# An arbitrary collection of objects supported by pickle.
data = {
    'a': [1, 2.0, 3, 4+6j],
    'b': ("character string", b"byte string"),
    'c': {None, True, False}
}

with open('data.pickle', 'wb') as f:
    # Pickle the 'data' dictionary using the highest protocol available.
    pickle.dump(data, f, pickle.HIGHEST_PROTOCOL)

Het object deserialiseren

import pickle

with open('data.pickle', 'rb') as f:
    # The protocol version used is detected automatically, so we do not
    # have to specify it.
    data = pickle.load(f)

Pickle- en byte-objecten gebruiken

Het is ook mogelijk om in byte-objecten een serienummer te maken en te deserialiseren met behulp van de functie dumps en loads , die equivalent zijn aan dump en load .

serialized_data = pickle.dumps(data, pickle.HIGHEST_PROTOCOL)
# type(serialized_data) is bytes

deserialized_data = pickle.loads(serialized_data)
# deserialized_data == data

Aangemaakte gegevens aanpassen

Sommige gegevens kunnen niet worden ingelegd. Andere gegevens mogen om andere redenen niet worden ingelegd.

Wat er wordt ingelegd, kan worden gedefinieerd in de methode __getstate__ . Deze methode moet iets retourneren dat kiesbaar is.

Aan de andere kant staat __setstate__ : het ontvangt wat __getstate__ gemaakt en moet het object initialiseren.

class A(object):
    def __init__(self, important_data):
        self.important_data = important_data
        
        # Add data which cannot be pickled:
        self.func = lambda: 7
        
        # Add data which should never be pickled, because it expires quickly:
        self.is_up_to_date = False
    
    def __getstate__(self):
        return [self.important_data] # only this is needed
    
    def __setstate__(self, state):
        self.important_data = state[0]
        
        self.func = lambda: 7  # just some hard-coded unpicklable function
        
        self.is_up_to_date = False  # even if it was before pickling

Dit kan nu worden gedaan:

>>> a1 = A('very important')
>>>
>>> s = pickle.dumps(a1)  # calls a1.__getstate__()
>>>
>>> a2 = pickle.loads(s)  # calls a1.__setstate__(['very important'])
>>> a2
<__main__.A object at 0x0000000002742470>
>>> a2.important_data
'very important'
>>> a2.func()
7

De implementatie geeft een lijst met één waarde: [self.important_data] . Dat was slechts een voorbeeld, __getstate__ had alles kunnen teruggeven dat kiesbaar is, zolang __setstate__ weet hoe het de tegenpartij moet doen. Een goed alternatief is een woordenboek met alle waarden: {'important_data': self.important_data} .

Constructor wordt niet genoemd! Merk op dat in het vorige voorbeeld exemplaar a2 werd gemaakt in pickle.loads zonder ooit A.__init__ , dus A.__setstate__ moest alles initialiseren dat __init__ zou hebben geïnitialiseerd als het werd aangeroepen.