Pandas & NumPy Academy · Lektion

Schemas validieren und Assertions

Schreiben Sie Assertion-Prüfungen für Spaltenbereiche, Nicht-Null-Bedingungen und eindeutige Schlüssel, die zu Beginn jeder Pipeline ausgeführt werden.

Lektion 4 von 413 Schritte

Schemas validieren und Assertions ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum Schemavalidierung wichtig ist

Eine Datenpipeline verarbeitet neue Daten automatisch, oft ohne menschliche Überprüfung. Wenn sich das Schema der Eingabedatei ändert – eine Spalte umbenannt wird, sich ein Datumsformat ändert oder eine neue Kategorie hinzukommt –, sollte die Pipeline mit einer deutlichen Fehlermeldung fehlschlagen, statt unbemerkt falsche Ergebnisse zu erzeugen. Schemavalidierung mit Assertions ist der Mechanismus, der Verträge zwischen Datenproduzenten und Datenkonsumenten durchsetzt und Probleme so früh wie möglich erkennt.

import pandas as pd
import numpy as np

df = pd.read_parquet('sales_treated.parquet')
print('Loaded:', df.shape)
print(df.dtypes)

Prüfung erforderlicher Spalten

Die grundlegendste Validierung besteht darin zu prüfen, ob alle erforderlichen Spalten vorhanden sind. Speichern Sie die erwartete Spaltenmenge in einer Konfiguration und stellen Sie per Assertion sicher, dass sie eine Teilmenge der tatsächlich vorhandenen Spalten ist. Diese Prüfung erkennt Umbenennungen und entfernte Spalten sofort beim Start der Pipeline, bevor nachgelagerter Code auf fehlende Spalten zugreift und tief in der Pipeline einen verwirrenden KeyError auslöst.

REQUIRED_COLUMNS = {'order_id', 'order_date', 'customer_id',
                    'product', 'category', 'quantity', 'unit_price', 'revenue'}

missing = REQUIRED_COLUMNS - set(df.columns)
assert not missing, f'Missing required columns: {missing}'
print('All required columns present.')

Assertions für Spaltendatentypen

Validieren Sie nach den erforderlichen Spalten deren Datentypen. Eine als object geladene Datumsspalte bedeutet, dass pd.to_datetime() nicht aufgerufen wurde. Eine als float statt als int64 gespeicherte ID-Spalte weist häufig auf NaN-Werte hin, die eine Speicherung als Ganzzahl verhindert haben. Schreiben Sie für die wichtigsten Spalten Typ-Assertions wie assert df['col'].dtype == expected_type.

assert pd.api.types.is_datetime64_any_dtype(df['order_date']), \
    'order_date must be datetime'
assert pd.api.types.is_numeric_dtype(df['revenue']), \
    'revenue must be numeric'
assert df['order_id'].dtype == object or pd.api.types.is_integer_dtype(df['order_id']), \
    'order_id must be string or int'
print('Dtype checks passed.')

Constraints für Nicht-Null-Werte

Schlüsselspalten wie order_id, order_date und revenue sollten niemals Nullwerte enthalten. Stellen Sie für jede dieser Spalten mit df['col'].notna().all() eine Assertion auf. Damit die Fehlermeldung unmittelbar verwertbar ist, sollten Sie die Anzahl der Nullwerte aufnehmen, sodass die für die Pipeline verantwortliche Person das Ausmaß des Problems kennt und nicht nur erfährt, dass eine Assertion fehlgeschlagen ist.

NOT_NULL_COLS = ['order_id', 'order_date', 'revenue', 'customer_id']

for col in NOT_NULL_COLS:
    null_count = df[col].isna().sum()
    assert null_count == 0, f'{col} has {null_count} null values'

print('Non-null checks passed.')

Bereichsprüfungen für numerische Spalten

Numerische Spalten haben häufig gültige Geschäftsbereiche. Der Umsatz muss nichtnegativ sein. Die Menge muss eine positive Ganzzahl sein. Der Stückpreis muss größer als null sein. Stellen Sie diese Constraints explizit per Assertion sicher – eine durchgelassene Zeile mit negativem Umsatz würde die Summen in jeder nachgelagerten Aggregation ohne Fehlermeldung zu niedrig ausfallen lassen. Bereichsprüfungen erkennen Eingabefehler und Fehler in vorgelagerten Systemen frühzeitig.

assert (df['revenue'] >= 0).all(), 'Negative revenue found'
assert (df['quantity'] > 0).all() or df['is_return'].any(), \
    'Non-positive quantity without return flag'
assert (df['unit_price'] > 0).all(), 'Zero or negative unit price found'

print('Range checks passed.')

Assertions für eindeutige Schlüssel

Nach der Duplikatbereinigung sollte order_id eindeutig sein. Prüfen Sie mit assert df['order_id'].is_unique, dass diese Invariante bei jeder Ausführung der Pipeline erhalten bleibt. Verstöße gegen die Eindeutigkeit nach der Duplikatbereinigung weisen auf einen Fehler in der Bereinigungslogik oder auf eine neu eingeführte Datenquelle hin, die vor dem Zusammenführen mit dem Hauptdatensatz nicht bereinigt wurde.

assert df['order_id'].is_unique, \
    f'order_id not unique: {df.duplicated(subset=["order_id"]).sum()} duplicates'

print('Uniqueness check passed.')

Assertions für kategoriale Werte

Für Spalten mit einer begrenzten Menge gültiger Werte – etwa region oder category – sollten Sie per Assertion sicherstellen, dass jeder Wert in der erlaubten Menge enthalten ist. Dadurch werden unerwartete Werte erkannt, die nach einer Systemmigration oder einer Änderung der Dateneingabe im vorgelagerten System auftreten. Definieren Sie die gültigen Mengen in der Pipeline-Konfiguration, damit sie bei einer Erweiterung des Geschäfts auf neue Regionen leicht aktualisiert werden können.

VALID_REGIONS = {'North', 'South', 'East', 'West', 'Central'}
VALID_CATEGORIES = {'electronics', 'apparel', 'home', 'sports', 'beauty', 'other'}

assert df['region'].isin(VALID_REGIONS).all(), \
    f'Invalid regions: {df[~df["region"].isin(VALID_REGIONS)]["region"].unique()}'
assert df['category'].isin(VALID_CATEGORIES).all(), \
    'Invalid categories found'

print('Categorical checks passed.')

Assertions für Datumsbereiche

Validieren Sie, dass alle Datumsangaben innerhalb des für den Datensatz erwarteten Zeitraums liegen. Eine Bestellung in der Zukunft ist unmöglich; eine Bestellung vor der Gründung des Unternehmens weist auf einen beschädigten Datensatz hin. Definieren Sie MIN_DATE und MAX_DATE in der Konfiguration und stellen Sie per Assertion sicher, dass die Spalte innerhalb dieser Grenzen liegt. Dadurch werden auch Unix-Epoch-Nullwerte (1970-01-01) erkannt, die durch fehlerhafte Zeitstempelkonvertierungen entstehen.

MIN_DATE = pd.Timestamp('2020-01-01')
MAX_DATE = pd.Timestamp('today')

assert (df['order_date'] >= MIN_DATE).all(), 'Date before minimum found'
assert (df['order_date'] <= MAX_DATE).all(), 'Future date found'

print(f'Date range: {df["order_date"].min()} to {df["order_date"].max()}')

Schutzprüfung für die Zeilenanzahl

Eine plötzliche Änderung der Zeilenanzahl gegenüber dem vorherigen Pipelinelauf ist ein starkes Signal für ein Problem in einem vorgelagerten System. Speichern Sie die Zeilenanzahl des vorherigen Laufs in einer Konfigurationsdatei und stellen Sie per Assertion sicher, dass die neue Anzahl innerhalb eines Toleranzbereichs liegt – beispielsweise innerhalb von ±20 % der historischen Anzahl. Ein Datensatz, der zwischen zwei Läufen 50 % seiner Zeilen verliert, weist mit hoher Wahrscheinlichkeit auf einen fehlerhaften Datenexport hin.

EXPECTED_MIN_ROWS = 5000
EXPECTED_MAX_ROWS = 200000

assert EXPECTED_MIN_ROWS <= len(df) <= EXPECTED_MAX_ROWS, \
    f'Row count {len(df)} outside expected range [{EXPECTED_MIN_ROWS}, {EXPECTED_MAX_ROWS}]'

print(f'Row count check passed: {len(df)} rows')

Prüfungen in einer Validate-Funktion bündeln

Bündeln Sie alle Assertions in einer einzigen Funktion validate(df), die am Anfang jeder Pipeline-Phase aufgerufen werden kann. Jede Prüfung löst bei einem Fehler einen AssertionError mit einer aussagekräftigen Meldung aus. Dieses Muster macht die Pipeline selbstdokumentierend: Die Validierungsfunktion ist der maschinenlesbare Schemavertrag für den DataFrame in dieser Phase.

def validate_sales_df(df):
    assert not (REQUIRED_COLUMNS - set(df.columns)), 'Missing columns'
    assert df['order_id'].is_unique, 'Duplicate order IDs'
    assert (df['revenue'] >= 0).all(), 'Negative revenue'
    assert df['region'].isin(VALID_REGIONS).all(), 'Invalid region'
    print(f'Validation passed: {len(df)} rows, {len(df.columns)} columns')

validate_sales_df(df)

Fehler bei der Validierung kontrolliert protokollieren

In Produktionspipelines ist ein harter Absturz durch assert während der Entwicklung akzeptabel, in einem geplanten Job jedoch unerwünscht. Ersetzen Sie einfache Assertions durch try/except AssertionError-Blöcke, die die Fehlermeldung protokollieren und optional vor dem Beenden einen Alarm senden. So kann das Überwachungssystem den Grund des Fehlers erfassen, statt nur einen Traceback einer unbehandelten Ausnahme zu erhalten.

import logging

logging.basicConfig(level=logging.INFO)

def validate_with_logging(df):
    checks = [
        (lambda d: d['order_id'].is_unique, 'Duplicate order IDs'),
        (lambda d: (d['revenue'] >= 0).all(), 'Negative revenue found'),
    ]
    for check_fn, msg in checks:
        try:
            assert check_fn(df), msg
        except AssertionError as e:
            logging.error(f'VALIDATION FAILED: {e}')
            raise

validate_with_logging(df)
print('All checks passed.')

Kurzüberprüfung

Testen Sie Ihr Verständnis der Konzepte zur Datenanalyse aus dieser Lektion.

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: erforderliche Spalten, Datentypen, Constraints für Nicht-Null-Werte und die Gültigkeit von Wertebereichen per Assertion zu prüfen, eindeutige Schlüssel, kategoriale Werte und Datumsbereiche zu überprüfen sowie alle Prüfungen mit Protokollierung in einer wiederverwendbaren Funktion validate() zu bündeln. Als Nächstes beschäftigen wir uns mit benutzerdefinierten Aggregationen mithilfe von apply() auf Spalten und Zeilen.

Kostenlos starten

Lerne Python mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
30
Lektionen
120

Häufig gestellte Fragen

Ist die Lektion „Schemas validieren und Assertions“ kostenlos?

Ja — der vollständige Text von „Schemas validieren und Assertions“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Schemas validieren und Assertions“?

Schreiben Sie Assertion-Prüfungen für Spaltenbereiche, Nicht-Null-Bedingungen und eindeutige Schlüssel, die zu Beginn jeder Pipeline ausgeführt werden. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?

Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Schemas validieren und Assertions“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?

Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Duplikate erkennen und entfernen
  2. Ausreißer erkennen und behandeln
  3. Inkonsistente Kategorien standardisieren
  4. Schemas validieren und Assertions
← Zurück zu Pandas & NumPy Academy