Zoeken…


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

Parameter Details
voorwerp Het object dat moet worden opgeslagen
het dossier Het open bestand dat het object zal bevatten
protocol Het protocol dat wordt gebruikt voor het beitsen van het object (optionele parameter)
buffer Een bytesobject dat een geserialiseerd object bevat

Opmerkingen

Pickleable soorten

De volgende objecten kunnen worden gepickt.

  • None , True en False
  • nummers (van alle soorten)
  • tekenreeksen (van alle soorten)
  • tuple s, list s, set s en dict s die alleen pickbare objecten bevatten
  • functies gedefinieerd op het hoogste niveau van een module
  • ingebouwde functies
  • klassen die op het hoogste niveau van een module zijn gedefinieerd
    • voorbeelden van dergelijke klassen waarvan __dict__ of het resultaat van het aanroepen van __getstate__() is (zie de officiële documenten voor meer informatie).

Gebaseerd op de officiële Python-documentatie .

pickle en veiligheid

De augurkmodule is niet beveiligd . Het mag niet worden gebruikt bij het ontvangen van de geserialiseerde gegevens van een niet-vertrouwde partij, zoals via internet.

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.



Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow