Python-Pickle-Modul

In der Python-Entwicklung müssen wir häufig Laufzeitobjekte speichern oder den vorherigen Zustand nach einem Neustart des Programms wiederherstellen, zum Beispiel:

  • Berechnungsergebnisse auf der Festplatte zwischenspeichern, um wiederholte Berechnungen zu vermeiden
  • Benutzerkonfiguration und Zwischenzustand des Programms speichern
  • Komplexe Objekte zwischen verschiedenen Python-Prozessen austauschen

pickleDas Modul ist das, was Python bietet, um diese Probleme zu lösenOffizielle integrierte Lösung。

PythonspickleDas Modul ist ein Standardbibliotheksmodul zum Serialisieren und Deserialisieren von Python-Objekten.

Bevor Sie Pickle verwenden, müssen Sie zwei Kernkonzepte verstehen:

  • Serialisierung (Pickling): Python-Objekte in Byte-Sequenzen umwandeln
  • Deserialisierung (Unpickling): Byte-Sequenzen zurück in Python-Objekte umwandeln

pickleDas Modul kann fast alle Python-Objekte (wie Listen, Wörterbücher, Klasseninstanzen usw.) in Dateien speichern oder über das Netzwerk übertragen und sie bei Bedarf erneut laden.

Warum das Pickle-Modul verwenden?

  1. Datenpersistenz: Python-Objekte in Dateien speichern, sodass auf die Daten auch nach dem Schließen des Programms noch zugegriffen werden kann.
  2. Datenübertragung: Python-Objekte über das Netzwerk übertragen, zum Beispiel Daten in verteilten Systemen übergeben.
  3. Schnelles Speichern und Laden：pickleDas Modul kann komplexe Datenstrukturen effizient verarbeiten und eignet sich für Szenarien, die schnelles Speichern und Laden erfordern.

Typische Anwendungsfälle von Pickle

pickleEs eignet sich sehr gut für die folgenden Szenarien:

  1. Lokale Datenpersistenz
  2. Speichern und Wiederherstellen des Programmausführungszustands
  3. Zwischenspeicherung von Zwischenberechnungsergebnissen
  4. Python-Interprozesskommunikation (IPC)
  5. Speichern von Modellen für maschinelles Lernen und Merkmalsdaten

Ungeeignete Szenarien:

  • Sprachübergreifender Datenaustausch
  • Datenübertragung zwischen Frontend- und Backend-Schnittstellen
  • Deserialisierung nicht vertrauenswürdiger Datenquellen

Welche Objekte unterstützt Pickle?

1. Unterstützte Objekttypen

Type Unterstützt?
int / float / bool / str Unterstützt
list / tuple / dict / set Unterstützt
Keine Unterstützt
Instanzen benutzerdefinierter Klassen Unterstützt
Verschachtelte Strukturen Unterstützt

Nicht unterstützte oder nicht empfohlene Objekte

  • Offene Dateiobjekte
  • socket, Datenbankverbindungen
  • Betriebssystemressourcen
  • Objekte, die vom Zustand der Laufzeitumgebung abhängen

Modul importieren

Die Verwendung des Pickle-Moduls ist sehr einfach, importieren Sie es einfach:

import pickle

Grundlegende Verwendung des Pickle-Moduls

1. Objekte serialisieren

Verwenden Siepickle.dump()Methode kann Python-Objekte serialisieren und sie in einer Datei speichern.

Beispiel

import pickle

# Erstelle ein Python-Objekt
data = {
    'name': 'Alice',
    'age': 25,
    'hobbies': ['reading', 'traveling']
}

# Serialisiere das Objekt und speichere es in einer Datei
with open('data.pkl', 'wb') as Datei:
    pickle.dump(data, file)
  • 'wb'Gibt an, dass die Datei im binären Schreibmodus geöffnet wird.
  • pickle.dump()wirddataDas Objekt wird serialisiert und in die Datei geschrieben.

2. Objekte deserialisieren

Verwenden Siepickle.load()Methode kann Python-Objekte aus einer Datei laden und deserialisieren.

Beispiel

import pickle

# Objekte aus einer Datei laden und deserialisieren
with open('data.pkl', 'rb') as Datei:
    loaded_data = pickle.load(file)

print(loaded_data)
  • 'rb'Gibt an, dass die Datei im binären Lesemodus geöffnet wird.
  • pickle.load()Lies den Byte-Stream aus der Datei und deserialisiere ihn in ein Python-Objekt.

3. In einen Byte-String serialisieren

Wenn du nicht in einer Datei speichern möchtest, kannst du pickle.dumps() verwenden, um das Objekt in einen Byte-String zu serialisieren:

Beispiel

import pickle

data = [1, 2, 3, 4, 5]

# In einen Byte-String serialisieren
byte_data = pickle.dumps(data)
print(byte_data)
# Ausgabe ähnlich wie: b'\x80\x04\x95\x0f\x00\x00\x00...'

4. Aus Byte-String deserialisieren

Verwenden Sie pickle.loads(), um Objekte aus einem Byte-String zu deserialisieren:

Beispiel

import pickle

byte_data = b'\x80\x04\x95\x0f\x00\x00\x00\x00\x00\x00\x00]\x94(K\x01K\x02K\x03K\x04K\x05e.'

# Aus Byte-String deserialisieren
original_data = pickle.loads(byte_data)
print(original_data)
# Ausgabe: [1, 2, 3, 4, 5]

5. Typen von Objekten, die serialisiert werden können

Pickle kann die meisten Python-Objekte serialisieren, einschließlich:

  • Grundlegende Datentypen: Ganzzahlen, Gleitkommazahlen, Zeichenketten, Boolesche Werte, None
  • Sammlungstypen: Listen, Tupel, Wörterbücher, Mengen
  • Instanzen benutzerdefinierter Klassen
  • Funktionen und Klassen (mit bestimmten Einschränkungen)

Beispiel

import pickle

# Verschiedene Datentypen serialisieren
numbers = [1, 2, 3]
text = "Hello, Pickle"
dictionary = {'key': 'value'}
tuple_data = (1, 2, 3)
set_data = {1, 2, 3}

# Alle Daten in eine Liste packen
all_data = [numbers, text, dictionary, tuple_data, set_data]

# Serialisieren
with open('mixed_data.pkl', 'wb') as f:
    pickle.dump(all_data, f)

# Deserialisieren
with open('mixed_data.pkl', 'rb') as f:
    loaded_data = pickle.load(f)
    print(loaded_data)

6. Benutzerdefinierte Klassen serialisieren

Pickle kann gut mit Instanzen benutzerdefinierter Klassen umgehen:

Beispiel

import pickle

class Student:
    def __init__(self, name, age, grade):
        self.name = name
        self.age = age
        self.grade = grade
   
    def __repr__(self):
        return f"Student(name={self.name}, age={self.age}, grade={self.grade})"

# Instanz erstellen
student = Student("Li Si", 20, "Junior")

# Serialisieren
with open('student.pkl', 'wb') as f:
    pickle.dump(student, f)

# Deserialisieren
with open('student.pkl', 'rb') as f:
    loaded_student = pickle.load(f)
    print(loaded_student)
    # Ausgabe: Student(name=Li Si, age=20, grade=Junior)

7. Mehrere Objekte serialisieren

Sie können pickle.dump() mehrmals aufrufen, um mehrere Objekte zu speichern:

Beispiel

import pickle

data1 = {'item': 'apple', 'count': 5}
data2 = ['banana', 'orange', 'grape']
data3 = 42

# Mehrere Objekte speichern
with open('multiple.pkl', 'wb') as f:
    pickle.dump(data1, f)
    pickle.dump(data2, f)
    pickle.dump(data3, f)

# Mehrere Objekte lesen (Reihenfolge muss konsistent sein)
with open('multiple.pkl', 'rb') as f:
    loaded_data1 = pickle.load(f)
    loaded_data2 = pickle.load(f)
    loaded_data3 = pickle.load(f)
   
print(loaded_data1)
print(loaded_data2)
print(loaded_data3)

8. Praktische Anwendungsbeispiele

Beispiel 1: Konfiguration eines Machine-Learning-Modells speichern und laden

Beispiel

import pickle

# Konfiguration eines Machine-Learning-Modells simulieren
model_config = {
    'model_type': 'RandomForest',
    'n_estimators': 100,
    'max_depth': 10,
    'trained_date': '2024-01-13',
    'accuracy': 0.95
}

# Konfiguration speichern
with open('model_config.pkl', 'wb') as f:
    pickle.dump(model_config, f)

# Konfiguration laden
with open('model_config.pkl', 'rb') as f:
    config = pickle.load(f)
    print(f"Modelltyp: {config['model_type']}")
    print(f"Genauigkeit: {config['accuracy']}")

Beispiel 2: Berechnungsergebnisse zwischenspeichern

Beispiel

import pickle
import os

def expensive_computation(n):
    """Simuliere eine zeitaufwändige Berechnung"""
    result = sum(i ** 2 for i in range(n))
    return result

def compute_with_cache(n, cache_file='cache.pkl'):
    # Prüfen, ob der Cache existiert
    if os.path.exists(cache_file):
        with open(cache_file, 'rb') as f:
            cache = pickle.load(f)
            if n in cache:
                print("Ergebnis aus dem Cache gelesen")
                return cache[n]
    else:
        cache = {}
   
    # Führe die Berechnung durch
    print("Berechnung wird durchgeführt...")
    result = expensive_computation(n)
   
    # Im Cache speichern
    cache[n] = result
    with open(cache_file, 'wb') as f:
        pickle.dump(cache, f)
   
    return result

# Verwendungsbeispiel
print(compute_with_cache(1000000))  # Beim ersten Mal wird berechnet
print(compute_with_cache(1000000))  # Beim zweiten Mal aus dem Cache gelesen

Hinweise zum Pickle-Modul

  1. Sicherheit：pickleDas Modul führt bei der Deserialisierung beliebigen Code aus, daher laden Sie keinepickleDaten aus nicht vertrauenswürdigen Quellen, um bösartige Angriffe zu vermeiden.
  2. Kompatibilität：pickleDer erzeugte Byte-Stream ist Python-spezifisch, und es kann Kompatibilitätsprobleme zwischen verschiedenen Versionen von Python geben.
  3. Leistung: Für große Datensätze,pickleSerialisierung und Deserialisierung können relativ langsam sein; Sie sollten die Verwendung effizienterer Serialisierungswerkzeuge in Betracht ziehen, wie z. B.jsonodermsgpack。

Erweiterte Verwendung: Serialisierung benutzerdefinierter Objekte

pickleDas Modul unterstützt die Serialisierung benutzerdefinierter Klassen. Standardmäßig,pickleEs speichert die Attribute und den Klassennamen des Objekts. Wenn Sie komplexere Serialisierungslogik benötigen, können Sie Folgendes implementieren__getstate__()und__setstate__()Methoden.

Beispiel

import pickle

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __getstate__(self):
        # Benutzerdefinierte Serialisierungslogik
        return {'name': self.name, 'age': self.age}

    def __setstate__(self, state):
        # Benutzerdefinierte Deserialisierungslogik
        self.name = state['name']
        self.age = state['age']

# Objekt erstellen und serialisieren
person = Person('Bob', 30)
with open('person.pkl', 'wb') as Datei:
    pickle.dump(person, file)

# Objekt deserialisieren
with open('person.pkl', 'rb') as Datei:
    loaded_person = pickle.load(file)

print(loaded_person.name, loaded_person.age)

Gängige Methoden des pickle-Moduls

MethodeBeschreibungBeispiel
pickle.dump(obj, file)Objekt serialisieren und in eine Datei schreibenpickle.dump(data, open('data.pkl', 'wb'))
pickle.load(file)Aus einer Datei lesen und Objekt deserialisierendata = pickle.load(open('data.pkl', 'rb'))
pickle.dumps(obj)Objekt in einen Byte-String serialisierenbytes_data = pickle.dumps([1, 2, 3])
pickle.loads(bytes)Objekt aus einem Byte-String deserialisierenlst = pickle.loads(bytes_data)
pickle.HIGHEST_PROTOCOLHöchste verfügbare Protokollversion (Attribut)pickle.dump(..., protocol=pickle.HIGHEST_PROTOCOL)
pickle.DEFAULT_PROTOCOLStandard-Protokollversion (Attribut, üblicherweise 4)pickle.dumps(obj, protocol=pickle.DEFAULT_PROTOCOL)

1. Objekt in Datei serialisieren

Beispiel

import pickle
data = {'name': 'Alice', 'age': 25}
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)

2. Aus Datei deserialisieren

Beispiel

with open('data.pkl', 'rb') as f:
    loaded_data = pickle.load(f)
print(loaded_data)  # Ausgabe: {'name': 'Alice', 'age': 25}

3. In Byte-String serialisieren (Netzwerkübertragung/Cache)

Beispiel

bytes_data = pickle.dumps([1, 2, 3], protocol=4)
restored_list = pickle.loads(bytes_data)

Protokollversionen des pickle-Moduls

ProtokollversionBeschreibung
0Für Menschen lesbares ASCII-Format (kompatibel mit älteren Versionen)
1Binärformat (kompatibel mit älteren Versionen)
2Python 2.3+ optimierte Unterstützung für Klassenobjekte
3Python 3.0+ Standardprotokoll (nicht unterstützt in Python 2)
4Python 3.4+ unterstützt größere Objekte und mehr Datentypen
5Python 3.8+ unterstützt Speicheroptimierung und Datenfreigabe
Weitere Erweiterungen