MarshMallow: Die süßeste Python-Bibliothek zur Datenserialisierung und -validierung

Bild vom Autor | Leonardo AI & Canva

Datenserialisierung ist ein grundlegendes Programmierkonzept mit großem Nutzen in alltäglichen Programmen. Es bezieht sich auf die Konvertierung komplexer Datenobjekte in ein Zwischenformat, das gespeichert und problemlos wieder in seine ursprüngliche Type zurückkonvertiert werden kann. Die gängigen Python-Bibliotheken zur Datenserialisierung wie JSON und Pickle sind jedoch in ihrer Funktionalität sehr eingeschränkt. Bei strukturierten Programmen und objektorientierter Programmierung benötigen wir stärkere Unterstützung für den Umgang mit Datenklassen.

Marshmallow ist eine der bekanntesten Datenverarbeitungsbibliotheken, die von Python-Entwicklern häufig zur Entwicklung robuster Softwareanwendungen verwendet wird. Es unterstützt die Datenserialisierung und bietet eine starke abstrakte Lösung für die Datenvalidierung in einem objektorientierten Paradigma.

In diesem Artikel verwenden wir ein laufendes Beispiel, das unten aufgeführt ist, um zu verstehen, wie Marshmallow in bestehenden Projekten verwendet wird. Der Code zeigt drei Klassen, die ein einfaches E-Commerce-Modell darstellen: Product, BuyerUnd Order. Jede Klasse definiert ihre Parameter minimal. Wir werden sehen, wie man eine Instanz eines Objekts speichert und ihre Korrektheit sicherstellt, wenn wir versuchen, es in unserem Code erneut zu laden.

from typing import Listing

class Product:
    def __init__(self, _id: int, identify: str, worth: float):
    	self._id = _id
    	self.identify = identify
    	self.worth = worth

class Buyer:
    def __init__(self, _id: int, identify: str):
    	self._id = _id
    	self.identify = identify

class Order:
    def __init__(self, _id: int, buyer: Buyer, merchandise: Listing(Product)):
    	self._id = _id
    	self.buyer = buyer
    	self.merchandise = merchandise

Erste Schritte mit Marshmallow

Set up

Marshmallow ist als Python-Bibliothek bei PyPI verfügbar und kann einfach mit pip installiert werden. Um die Marshmallow-Abhängigkeit zu installieren oder zu aktualisieren, führen Sie den folgenden Befehl aus:

pip set up -U marshmallow

Dadurch wird die aktuelle stabile Model von Marshmallow in der aktiven Umgebung installiert. Wenn Sie die Entwicklungsversion der Bibliothek mit allen neuesten Funktionen wünschen, können Sie diese mit dem folgenden Befehl installieren:

pip set up -U git+https://github.com/marshmallow-code/marshmallow.git@dev

Erstellen von Schemas

Beginnen wir mit der Erweiterung des Product Klasse. Wir müssen eine neue Klasse erstellen, die ein Schema darstellt, eine Instanz der Product Klasse folgen muss. Stellen Sie sich ein Schema wie eine Blaupause vor, die die Variablen in der Product Klasse und der Datentyp, zu dem sie gehören.

Lassen Sie uns den folgenden Basiscode aufschlüsseln und verstehen:

from marshmallow import Schema, fields

class ProductSchema(Schema):
    _id = fields.Int(required=True)
    identify = fields.Str(required=True)
    worth = fields.Float(required=True)

Wir erstellen eine neue Klasse, die erbt von der Schema Klasse in Marshmallow. Dann deklarieren wir die gleichen Variablennamen wie unsere Product Klasse und definieren Sie ihre Feldtypen. Die Klasse „Felder“ in Marshmallow unterstützt verschiedene Datentypen. Hier verwenden wir die primitiven Typen Int, String und Float.

Serialisierung

Nachdem wir nun ein Schema für unser Objekt definiert haben, können wir nun eine Python-Klasseninstanz zur Serialisierung in eine JSON-Zeichenfolge oder ein Python-Wörterbuch konvertieren. Hier ist die grundlegende Implementierung:

product = Product(_id=4, identify="Take a look at Product", worth=10.6)
schema = ProductSchema()
    
# For Python Dictionary object
end result = schema.dump(product)

# kind(dict) -> {'_id': 4, 'identify': 'Take a look at Product', 'worth': 10.6}

# For JSON-serializable string
end result = schema.dumps(product)

# kind(str) -> {"_id": 4, "identify": "Take a look at Product", "worth": 10.6}

Wir erschaffen ein Objekt unserer ProductSchemadas ein Produktobjekt in ein serialisierbares Format wie JSON oder ein Wörterbuch konvertiert.

Beachten Sie den Unterschied zwischen dump Und dumps Funktionsergebnisse. Eines gibt ein Python-Wörterbuchobjekt zurück, das mit Pickle gespeichert werden kann, und das andere gibt ein Zeichenfolgenobjekt zurück, das dem JSON-Format folgt.

Deserialisierung

Um den Serialisierungsprozess umzukehren, verwenden wir die Deserialisierung. Ein Objekt wird gespeichert, damit es später geladen und abgerufen werden kann, und Marshmallow hilft dabei.

Ein Python-Wörterbuch kann mit der Ladefunktion validiert werden, die die Variablen und ihre zugehörigen Datentypen überprüft. Die folgende Funktion zeigt, wie es funktioniert:

product_data = {
    "_id": 4,
    "identify": "Take a look at Product",
    "worth": 50.4,
}
end result = schema.load(product_data)
print(end result)  	

# kind(dict) -> {'_id': 4, 'identify': 'Take a look at Product', 'worth': 50.4}

faulty_data = {
    "_id": 5,
    "identify": "Take a look at Product",
    "worth": "ABCD" # Flawed enter datatype
}
end result = schema.load(faulty_data) 

# Raises validation error

Das Schema überprüft, ob das Wörterbuch die richtigen Parameter und Datentypen enthält. Wenn die Überprüfung fehlschlägt, wird ein ValidationError ist angehoben, so ist es wichtig, die load perform in einem Attempt-Besides-Block. Wenn es erfolgreich ist, ist das Ergebnisobjekt immer noch ein Wörterbuch, wenn das ursprüngliche Argument auch ein Wörterbuch ist. Nicht so hilfreich, oder? Was wir im Allgemeinen wollen, ist, das Wörterbuch zu validieren und es wieder in das ursprüngliche Objekt zu konvertieren, aus dem es serialisiert wurde.

Um dies zu erreichen, verwenden wir die post_load Dekorateur bereitgestellt von Marshmallow:

from marshmallow import Schema, fields, post_load

class ProductSchema(Schema):
    _id = fields.Int(required=True)
    identify = fields.Str(required=True)
    worth = fields.Float(required=True)

@post_load
def create_product(self, knowledge, **kwargs):
    return Product(**knowledge)

Wir erstellen eine Funktion in der Schemaklasse mit dem post_load Dekorator. Diese Funktion nimmt das validierte Wörterbuch und konvertiert es zurück in ein Produktobjekt. Einschließlich **kwargs ist wichtig, da Marshmallow zusätzliche notwendige Argumente über den Dekorator übergeben kann.

Diese Änderung der Ladefunktion stellt sicher, dass das Python-Wörterbuch nach der Validierung an den post_load Funktion, die eine Product Objekt aus dem Wörterbuch. Dadurch ist es möglich, ein Objekt mit Marshmallow zu deserialisieren.

Validierung

Oft benötigen wir zusätzliche Validierungen, die speziell auf unseren Anwendungsfall zugeschnitten sind. Obwohl die Datentypvalidierung wichtig ist, deckt sie nicht alle Validierungen ab, die wir möglicherweise benötigen. Selbst in diesem einfachen Beispiel ist eine zusätzliche Validierung für unseren Product Objekt. Wir müssen sicherstellen, dass der Preis nicht unter 0 liegt. Wir können auch weitere Regeln definieren, beispielsweise sicherstellen, dass unser Produktname zwischen 3 und 128 Zeichen lang ist. Diese Regeln helfen sicherzustellen, dass unsere Codebasis einem definierten Datenbankschema entspricht.

Sehen wir uns nun an, wie wir diese Validierung mit Marshmallow implementieren können:

from marshmallow import Schema, fields, validates, ValidationError, post_load

class ProductSchema(Schema):
    _id = fields.Int(required=True)
    identify = fields.Str(required=True)
    worth = fields.Float(required=True)

@post_load
def create_product(self, knowledge, **kwargs):
    return Product(**knowledge)


@validates('worth')
def validate_price(self, worth):
    if worth <= 0:
        elevate ValidationError('Value should be larger than zero.')

@validates('identify')
def validate_name(self, worth):
    if len(worth) < 3 or len(worth) > 128:
        elevate ValidationError('Identify of Product should be between 3 and 128 letters.')

Wir modifizieren die ProductSchema Klasse, um zwei neue Funktionen hinzuzufügen. Eine validiert den Preisparameter und die andere validiert den Namensparameter. Wir verwenden den Validates-Funktionsdekorator und kommentieren den Namen der Variable, die die Funktion validieren soll. Die Implementierung dieser Funktionen ist unkompliziert: Wenn der Wert falsch ist, lösen wir eine ValidationError.

Verschachtelte Schemas

Nun mit den grundlegenden Product Klassenvalidierung: Wir haben alle grundlegenden Funktionen der Marshmallow-Bibliothek abgedeckt. Lassen Sie uns nun die Komplexität erhöhen und sehen, wie die anderen beiden Klassen validiert werden.

Der Buyer Klasse ist ziemlich unkompliziert, da sie die grundlegenden Attribute und primitiven Datentypen enthält.

class CustomerSchema(Schema):
    _id = fields.Int(required=True)
    identify = fields.Int(required=True)

Die Definition des Schemas für die Order Klasse zwingt uns, ein neues und erforderliches Konzept von verschachtelten Schemas zu lernen. Eine Bestellung wird einem bestimmten Kunden zugeordnet und der Kunde kann eine beliebige Anzahl von Produkten bestellen. Dies wird in der Klassendefinition definiert, und wenn wir die Order Schema müssen wir auch validieren die Product Und Buyer an ihn übergebene Objekte.

Anstatt alles neu zu definieren im OrderSchemavermeiden wir Wiederholungen und verwenden verschachtelte Schemata. Das Bestellschema ist wie folgt definiert:

class OrderSchema(Schema):
    _id = fields.Int(require=True)
    buyer = fields.Nested(CustomerSchema, required=True)
    merchandise = fields.Listing(fields.Nested(ProductSchema), required=True)

Innerhalb der Order Schema, wir schließen die ProductSchema Und CustomerSchema Definitionen. Dadurch wird sichergestellt, dass die definierten Validierungen für diese Schemata automatisch angewendet werden, gemäß den DRY (Wiederholen Sie sich nicht) Prinzip in der Programmierung, welches die Wiederverwendung von bestehendem Code ermöglicht.

Einpacken

In diesem Artikel haben wir den Schnellstart und den Anwendungsfall der Marshmallow-Bibliothek behandelt, einer der beliebtesten Serialisierungs- und Datenvalidierungsbibliotheken in Python. Obwohl sie Pydantic ähnelt, bevorzugen viele Entwickler Marshmallow aufgrund ihrer Schemadefinitionsmethode, die Validierungsbibliotheken in anderen Sprachen wie JavaScript ähnelt.

Marshmallow lässt sich problemlos in Python-Backend-Frameworks wie FastAPI und Flask integrieren und ist daher eine beliebte Wahl für Internet-Frameworks und Datenvalidierungsaufgaben sowie für ORMs wie SQLAlchemy.

Kanwal Mehreen Kanwal ist Ingenieurin für maschinelles Lernen und technische Autorin mit einer tiefen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Era Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Range in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist eine leidenschaftliche Verfechterin des Wandels und hat FEMCodes gegründet, um Frauen in MINT-Fächern zu stärken.