# Einführung

Es wird geschätzt, dass die Datenbereinigung und -aufbereitung bis zu 80 % des täglichen Arbeitsablaufs eines Datenwissenschaftlers ausmacht. Weil Pandas ist die Standardbibliothek zur Datenbearbeitung in Python. Die Effizienz Ihrer Vorgänge bestimmt direkt, wie schnell Sie von rohen, schmutzigen Datensätzen zu modellbereiten Funktionen wechseln können. Und es gibt gute Gründe, Ihre Reinigungs- und Vorbereitungszeit zu verlängern: Dies bedeutet direkt, dass mehr Zeit für die Modellierung, Analyse und Vermittlung von Erkenntnissen zur Verfügung steht.

Allerdings schreiben viele Entwickler Pandas-Code, der Customary-Python-Schleifenstrukturen nachahmt oder crucial, zustandsverändernde Aktualisierungen verwendet. Diese Ansätze weisen mehrere Probleme auf: Sie können zu Verwirrung führen SettingWithCopyWarningblähen die RAM-Auslastung durch redundante Kopien auf und verlangsamen die Ausführungsgeschwindigkeit durch die Vermeidung von Vektorisierung.

Um Datenpipelines in Produktionsqualität zu schreiben, müssen Sie von der grundlegenden Syntax zu idiomatischen Pandas-Entwurfsmustern übergehen. In diesem Artikel gehen wir drei wesentliche Pandas-Methods durch, um Ihre Daten effizient zu bereinigen und aufzubereiten:

1. deklarative Methodenverkettung
2. Speicher- und Geschwindigkeitsoptimierung über Kategorialfunktionen und vektorisierte String-Accessoren
3. Gruppenbewusste Imputation unter Verwendung .rework()

# 1. Deklarative Methodenverkettung mit .assign(), .question()Und .pipe()

Beim Vorbereiten von Daten ist es üblich, eine Reihe von Änderungen vorzunehmen: Zeichenfolgenwerte bereinigen, neue mathematische Spalten erstellen, Ausreißer filtern, Felder umbenennen usw.

Bei einem naiven Ansatz werden diese Vorgänge nacheinander geschrieben, wobei der DataFrame direkt verändert oder wiederholt derselben Variablen neu zugewiesen wird. Dies erschwert nicht nur das Lesen und Debuggen von Code, sondern das Ändern von Slices in DataFrames löst auch häufig das berüchtigte Drawback aus SettingWithCopyWarning. Mit dieser Warnung weist Pandas darauf hin, dass nicht garantiert werden kann, ob Sie eine Kopie oder den ursprünglichen Array-Puffer im Speicher ändern.

Indem Sie Ihre Datenbereinigungspipeline in Klammern setzen, können Sie Pandas-Methoden sequentiell verketten. Benutzen .assign() um neue Spalten zu deklarieren, .question() zur Zeilenfilterung und .pipe() Durch die Anwendung benutzerdefinierter Funktionen bleiben Ihre Abläufe linear, lesbar und vor Nebenwirkungen geschützt.

Dieser zwingende Stil modifiziert den DataFrame Schritt für Schritt, wodurch das Risiko von Warnmeldungen besteht und die Isolierung von Zwischenstufen schwierig wird:

import pandas as pd
import numpy as np

# Pattern uncooked gross sales information
information = {
    'sale_date': ('2026-01-01', '2026-01-02', 'invalid_date', '2026-01-04'),
    'item_code': ('  PROD_A ', ' PROD_B', 'PROD_C  ', '  PROD_D '),
    'worth': (100.0, 250.0, -99.0, 150.0),
    'amount': (2, 1, 5, 3)
}
df = pd.DataFrame(information)

# Naive multi-step cleansing
df('sale_date') = pd.to_datetime(df('sale_date'), errors="coerce")
df('item_code') = df('item_code').str.strip()
df('total_revenue') = df('worth') * df('amount')

# Filtering out unhealthy dates and invalid costs
df = df(df('sale_date').notna())
df = df(df('worth') > 0)

# Renaming columns for consistency
df.rename(columns={'item_code': 'product_id'}, inplace=True)

print(df)

Hier strukturieren wir genau dieselbe Logik in eine einzige, zusammenhängende, von oben nach unten verlaufende Pipeline um. Wir verwenden eine benutzerdefinierte Hilfsfunktion mit .pipe() So behandeln Sie benutzerdefinierte Anomalien:

import pandas as pd
import numpy as np

information = {
    'sale_date': ('2026-01-01', '2026-01-02', 'invalid_date', '2026-01-04'),
    'item_code': ('  PROD_A ', ' PROD_B', 'PROD_C  ', '  PROD_D '),
    'worth': (100.0, 250.0, -99.0, 150.0),
    'amount': (2, 1, 5, 3)
}
df_raw = pd.DataFrame(information)

# Customized modular cleansing step
def clean_item_codes(df):
    df('item_code') = df('item_code').str.strip()
    return df

# Technique Chaining pipeline
cleaned_df = (
    df_raw
    .copy()  # Prevents modifying the unique uncooked information
    .assign(
        sale_date=lambda d: pd.to_datetime(d('sale_date'), errors="coerce"),
        total_revenue=lambda d: d('worth') * d('amount')
    )
    .pipe(clean_item_codes)
    .question("sale_date.notna() and worth > 0")
    .rename(columns={'item_code': 'product_id'})
)

print(cleaned_df)

Ausgabe:

   sale_date product_id  worth  amount  total_revenue
0 2026-01-01     PROD_A  100.0         2          200.0
1 2026-01-02     PROD_B  250.0         1          250.0
3 2026-01-04     PROD_D  150.0         3          450.0

Durch Einschließen des Ausdrucks ( ... )Python erlaubt mehrzeilige Ketten ohne die Verwendung von Backslashes.

• .assign() akzeptiert Schlüsselwortargumente, bei denen Lambdas den aktuellen Standing des DataFrame empfangen (d), sodass Sie mehrere Spalten nacheinander erstellen oder ändern können.
• .pipe() übergibt den Zwischen-DataFrame an eine externe Funktion. Dadurch wird die wiederverwendbare Reinigungslogik von der Hauptkette getrennt.
• .question() akzeptiert einen booleschen Ausdruck als String. Es ist sauberer als verschachtelte Klammern (df((df(a) > 0) & (df(b).notna()))) und läuft unter der Haube schneller mit dem schnellen numerischen Ausdrucks-Evaluator von NumPy, NumExpr.

Dieses Funktionsmuster vermeidet SettingWithCopyWarning weil es niemals Zwischen-Slices verändert.

# 2. Speicher- und Geschwindigkeitsoptimierung mit kategorialen und vektorisierten String-Methoden

Standardmäßig weist Pandas das Generikum zu object Datentyp für Spalten mit Textual content. Eine Objektspalte speichert Python-Zeiger auf Zeichenfolgen, die im Heapspeicher verstreut sind, und nicht auf zusammenhängende, gepackte Werte. Bei großen Datensätzen mit Zeichenfolgen mit geringer Kardinalität (Spalten mit sich wiederholenden Kategorien wie Statusflaggen, Städtenamen oder Geschlecht) ist dies standardmäßig ein offensichtlicher Speicherbedarf.

Darüber hinaus wenden Entwickler häufig benutzerdefinierte Zeichenfolgenmodifikationen an, indem sie Python-Lambda-Ausdrücke an übergeben .apply(). Dies zwingt Pandas dazu, bei langsamer Python-Interpreter-Geschwindigkeit nacheinander jede Zeile zu durchlaufen.

Wir können sowohl die RAM-Nutzung als auch die Ausführungszeit optimieren, indem wir:

1. Konvertieren von Zeichenfolgenspalten mit niedriger Kardinalität in die native class Datentyp
2. Langsamer Austausch .apply() Schleifen mit optimierten vektorisierten String-Methoden über die .str Zugriffsberechtigter

Lassen Sie uns die Bereinigung eines großen Datensatzes (1.000.000 Zeilen) simulieren, indem wir Textual content als Objektspalten beibehalten und Leerzeichen mit bereinigen .apply():

import pandas as pd
import numpy as np
import time

# Create a mock dataset with 1 million rows of low-cardinality string information
n_rows = 1000000
classes = (' PENDING ', ' COMPLETED ', ' FAILED ', ' SHIPPED ')
df = pd.DataFrame({
    'standing': np.random.selection(classes, dimension=n_rows),
    'val': np.random.rand(n_rows)
})

# Benchmark reminiscence utilization earlier than cleansing
mem_before = df('standing').memory_usage(deep=True) / (1024 ** 2)

start_time = time.time()

# Naive cleansing: sluggish Python apply loops
df('standing') = df('standing').apply(lambda x: x.strip().higher())
duration_apply = time.time() - start_time

mem_after = df('standing').memory_usage(deep=True) / (1024 ** 2)

print(f"Apply cleansing accomplished in: {duration_apply:.4f} seconds")
print(f"Standing column reminiscence utilization: {mem_after:.2f} MB (initially {mem_before:.2f} MB)")

Durch Umwandlung der Statusspalte in class Zuerst und unter Verwendung der vektorisierten .str Mit dem Accessor erzielen wir sofortige Beschleunigungen und sparen erheblich Speicher:

import pandas as pd
import numpy as np
import time

n_rows = 1000000
classes = (' PENDING ', ' COMPLETED ', ' FAILED ', ' SHIPPED ')
df = pd.DataFrame({
    'standing': np.random.selection(classes, dimension=n_rows),
    'val': np.random.rand(n_rows)
})

# Convert to class dtype
df('standing') = df('standing').astype('class')

# Benchmark reminiscence utilization
mem_category = df('standing').memory_usage(deep=True) / (1024 ** 2)

start_time = time.time()

# Vectorized string cleansing immediately on classes
df('standing') = df('standing').cat.rename_categories(lambda x: x.strip().higher())
duration_vectorized = time.time() - start_time

print(f"Vectorized class cleansing accomplished in: {duration_vectorized:.4f} seconds")
print(f"Class standing column reminiscence utilization: {mem_category:.2f} MB")
print(f"Speedup: {duration_apply / duration_vectorized:.2f}x sooner")

Kombinierte Ausgabe:

Apply cleansing accomplished in: 0.1213 seconds
Standing column reminiscence utilization: 53.64 MB (initially 55.55 MB)

Vectorized class cleansing accomplished in: 0.0003 seconds
Class standing column reminiscence utilization: 0.95 MB
Speedup: 407.83x sooner

Wir nennen diese Leistungsverbesserungen einen Sieg.

Wenn eine Spalte umgewandelt wird classPandas kodiert die Zeichenfolgen unter der Haube in Ganzzahlschlüssel (z PENDING -> 0, COMPLETED -> 1).

• Anstatt 1.000.000 Strings zu speichern, speichert Pandas 1.000.000 kleine Ganzzahlen und eine winzige Karte mit 4 tatsächlichen String-Kategorien. Dadurch reduziert sich der Speicherbedarf von ~56 MB auf weniger als 1 MB.
• Durch die direkte Reinigung der Etiketten .cat.rename_categories()führt Pandas die String-Operationen nur für die 4 eindeutigen Kategorien durch, anstatt eine Schleife durch 1.000.000 Zeilen zu durchlaufen. Die Ausführungszeit sinkt auf nahezu Null.

Notiz: Wenn Sie mit Textual content mit hoher Kardinalität arbeiten (bei dem sich Werte selten wiederholen), behalten Sie es bei class spart keinen Speicher. In diesen Fällen sollten Sie es dennoch vermeiden .apply() und verwenden Sie vektorisierte String-Methoden direkt in der Objektspalte: df('standing').str.strip().str.higher()das in kompiliertem C und nicht in Python ausgeführt wird.

# 3. Gruppenbewusste Imputation und Interpolation mit groupby() Und .rework()

Der Umgang mit fehlenden Daten ist ein grundlegender Schritt bei der Datenbereinigung. In vielen Fällen führt das Ersetzen fehlender Werte durch einen globalen Durchschnitt oder eine Konstante zu einer statistischen Verzerrung. Wenn Sie beispielsweise einen fehlenden Produktpreis angeben, ist die Verwendung des globalen Durchschnittspreises aller Filialprodukte ungenau. Es ist viel präziser, die Berechnung anhand des Durchschnittspreises dieser spezifischen Produktkategorie vorzunehmen.

Der naive Ansatz besteht darin, die Produktkategorien zu durchlaufen, den Gruppenmittelwert zu berechnen, den DataFrame zu filtern, die fehlenden Werte zu füllen und die Gruppen wieder zusammenzufügen. Alternativ können Sie eine benutzerdefinierte Funktion darin verwenden groupby().apply() löst langsame Break up-Apply-Mix-Zyklen aus, die sich schlecht skalieren lassen.

Die optimale Lösung ist die Kombination groupby() mit dem .rework() Verfahren.

Hier simulieren wir die Imputation fehlender numerischer Preise (dargestellt durch NaN) mithilfe einer Schleife oder einer benutzerdefinierten Funktion, die an übergeben wird .apply():

import pandas as pd
import numpy as np
import time

# Create a mock catalog of 100,000 objects grouped by class
n_items = 100000
classes = (f"CAT_{i}" for i in vary(100))

df = pd.DataFrame({
    'class': np.random.selection(classes, dimension=n_items),
    'worth': np.random.uniform(10.0, 500.0, dimension=n_items)
})

# Introduce 10% lacking costs (NaN)
nan_mask = np.random.rand(n_items) < 0.1
df.loc(nan_mask, 'worth') = np.nan

df_clunky = df.copy()

start_time = time.time()

# Break up-apply-combine utilizing apply() with a customized lambda
df_clunky('worth') = df_clunky.groupby('class')('worth').apply(lambda x: x.fillna(x.imply())).reset_index(stage=0, drop=True)
duration_clunky = time.time() - start_time

print(f"Apply-based group imputation took: {duration_clunky:.4f} seconds")

Durch Hebelwirkung .rework()umgehen wir benutzerdefinierte Lambda-Schleifen und ermöglichen Pandas, die Indexausrichtung und Vektorisierung nativ zu handhaben:

import pandas as pd
import numpy as np
import time

# Use the identical setup
df_optimized = df.copy()

start_time = time.time()

# Optimized method utilizing rework
group_means = df_optimized.groupby('class')('worth').rework('imply')
df_optimized('worth') = df_optimized('worth').fillna(group_means)
duration_opt = time.time() - start_time

print(f"Remodel-based group imputation took: {duration_opt:.4f} seconds")
print(f"Speedup: {duration_clunky / duration_opt:.2f}x sooner")

Ausgabe:

Apply-based group imputation took: 0.0224 seconds
Remodel-based group imputation took: 0.0032 seconds
Speedup: 7.04x sooner

Verstehen wie .rework() „operiert“ ist der Schlüssel zum Schreiben von leistungsstarkem Pandas-Code:

• Wenn du rennst df.groupby('class')('worth').rework('imply')Pandas berechnet den Durchschnittspreis für jede Kategorie.
• Anstatt eine kleinere gruppierte Übersichtstabelle zurückzugeben, .rework() Sendet die berechneten Werte zurück in die Größe und Ausrichtung des ursprünglichen DataFrame. Es wird eine Reihe mit genau der gleichen Länge wie der Originaldatensatz ausgegeben, wobei der Index gilt i enthält den Mittelwert der Gruppe dieser Zeile i gehört dazu.
• Wir können es dann verwenden df('worth').fillna(group_means). Dadurch werden die fehlenden Werte durch eine saubere, vektorisierte, indexausgerichtete Zuweisung aufgefüllt.

Dieses Muster ist sehr vielseitig. Sie können damit eine Standardisierung auf Gruppenebene durchführen (z. B. Gruppenmittelwerte subtrahieren) oder fehlende Werte professional Gruppe vorwärts ergänzen, indem Sie Folgendes verwenden: df.groupby('group')('val').rework('ffill').

# Zusammenfassung

Indem Sie über einfache, naive Schleifenkonstrukte hinausgehen und idiomatische Pandas-Entwurfsmuster übernehmen, können Sie Datenvorbereitungspipelines erstellen, die sich nahtlos von lokalen Prototypen bis hin zu Produktionsumgebungen skalieren lassen.

Fassen wir noch einmal zusammen:

• Methodenverkettung ersetzt spröde, mehrzeilige crucial Mutationen durch lesbare, deklarative Verarbeitungssequenzen, die vollständig vermeiden SettingWithCopyWarning
• Kategoriales Casting und vektorisierte String-Methoden Optimieren Sie Speicherlayouts und verlagern Sie String-Transformationen auf die Ausführung mit C-Geschwindigkeit, wodurch die RAM-Nutzung bei Daten mit geringer Kardinalität um bis zu 98 % gesenkt wird
• Gruppenbewusste Imputation mit .rework() Berechnet Statistiken auf Gruppenebene und richtet sie nativ wieder auf die ursprünglichen Indexformen aus, wodurch langsame benutzerdefinierte Gruppierungsschleifen vermieden werden

Wenn Sie diese Muster in Ihre tägliche Arbeit integrieren, werden Ihre Function-Engineering- und Datenbereinigungsprozesse schnell, sauber und äußerst wartbar.

Matthew Mayo (@mattmayo13) hat einen Grasp-Abschluss in Informatik und ein Diplom in Information Mining. Als geschäftsführender Herausgeber von KDnuggets & Statistikund Mitherausgeber bei Beherrschung des maschinellen LernensZiel von Matthew ist es, komplexe datenwissenschaftliche Konzepte zugänglich zu machen. Zu seinen beruflichen Interessen zählen die Verarbeitung natürlicher Sprache, Sprachmodelle, Algorithmen für maschinelles Lernen und die Erforschung neuer KI. Seine Mission ist es, das Wissen in der Datenwissenschaftsgemeinschaft zu demokratisieren. Matthew programmiert seit seinem sechsten Lebensjahr.

Bild vom Herausgeber

# Einführung

Als Datenexperte wissen Sie, dass Modelle für maschinelles Lernen, Analyse-Dashboards und Geschäftsberichte alle von Daten abhängen, die genau, konsistent und richtig formatiert sind. Aber hier ist die unbequeme Wahrheit: Die Datenbereinigung nimmt einen großen Teil der Projektzeit in Anspruch. Datenwissenschaftler und -analysten verbringen einen Großteil ihrer Zeit damit, Daten zu bereinigen und aufzubereiten, anstatt sie tatsächlich zu analysieren.

Die Rohdaten, die Sie erhalten, sind chaotisch. Es gibt verstreut fehlende Werte, doppelte Datensätze, inkonsistente Formate, Ausreißer, die Ihre Modelle verzerren, und Textfelder voller Tippfehler und Inkonsistenzen. Das manuelle Bereinigen dieser Daten ist mühsam, fehleranfällig und lässt sich nicht skalieren.

In diesem Artikel werden fünf Python-Skripte behandelt, die speziell zur Automatisierung der häufigsten und zeitaufwändigsten Datenbereinigungsaufgaben entwickelt wurden, denen Sie in realen Projekten häufig begegnen.

Hyperlink zum Code auf GitHub

# 1. Handler für fehlende Werte

Der Schmerzpunkt: In Ihrem Datensatz fehlen überall Werte – einige Spalten sind zu 90 % vollständig, andere enthalten spärliche Daten. Sie müssen entscheiden, was mit den einzelnen Zeilen geschehen soll: Löschen Sie die Zeilen, füllen Sie sie mit Mittelwerten, verwenden Sie die Vorwärtsfüllung für Zeitreihen oder wenden Sie eine komplexere Imputation an. Dies manuell für jede Spalte durchzuführen ist mühsam und inkonsistent.

Was das Skript macht: Analysiert automatisch Muster fehlender Werte in Ihrem gesamten Datensatz, empfiehlt geeignete Handhabungsstrategien basierend auf Datentyp und Fehlmustern und wendet die ausgewählten Imputationsmethoden an. Erstellt einen detaillierten Bericht, der zeigt, was fehlte und wie damit umgegangen wurde.

Wie es funktioniert: Das Skript durchsucht alle Spalten, um fehlende Prozentsätze und Muster zu berechnen, bestimmt Datentypen (numerisch, kategorisch, Datum/Uhrzeit) und wendet entsprechende Strategien an:

• Mittelwert/Median für numerische Daten,
• Modus für kategoriale,
• Interpolation für Zeitreihen.

Es kann die Muster „Lacking Utterly at Random“ (MCAR), „Lacking at Random“ (MAR) und „Lacking Not at Random“ (MNAR) unterschiedlich erkennen und verarbeiten und protokolliert alle Änderungen zur Reproduzierbarkeit.

Holen Sie sich das Skript für den Handler für fehlende Werte

# 2. Detektor und Resolver für doppelte Datensätze

Der Schmerzpunkt: Ihre Daten weisen Duplikate auf, es handelt sich jedoch nicht immer um exakte Übereinstimmungen. Manchmal handelt es sich um denselben Kunden mit leicht unterschiedlicher Schreibweise des Namens oder um dieselbe Transaktion, die zweimal mit geringfügigen Abweichungen erfasst wurde. Um diese unscharfen Duplikate zu finden und zu entscheiden, welcher Datensatz aufbewahrt werden soll, ist eine manuelle Überprüfung Tausender Zeilen erforderlich.

Was das Skript macht: Identifiziert sowohl exakte als auch unscharfe doppelte Datensätze mithilfe konfigurierbarer Abgleichsregeln. Gruppiert ähnliche Datensätze, bewertet ihre Ähnlichkeit und markiert sie entweder zur Überprüfung oder führt sie automatisch basierend auf von Ihnen definierten Überlebensregeln zusammen, z. B. „Neueste beibehalten“, „Am vollständigsten beibehalten“ und mehr.

Wie es funktioniert: Das Skript findet aus Geschwindigkeitsgründen zunächst mithilfe eines Hash-basierten Vergleichs exakte Duplikate. Anschließend werden Fuzzy-Matching-Algorithmen verwendet Levenshtein-Distanz Und Jaro-Winkler auf Schlüsselfeldern, um Beinahe-Duplikate zu finden. Datensätze werden in Duplikatgruppen gruppiert und Überlebensregeln bestimmen, welche Werte beim Zusammenführen beibehalten werden sollen. Ein detaillierter Bericht zeigt alle gefundenen doppelten Gruppen und ergriffenen Maßnahmen.

Holen Sie sich das Duplikatdetektorskript

# 3. Datentyp-Fixierer und Standardisierer

Der Schmerzpunkt: Ihr CSV-Import hat alles in Strings umgewandelt. Termine gibt es in fünf verschiedenen Formaten. Zahlen haben Währungssymbole und Tausendertrennzeichen. Boolesche Werte werden als „Ja/Nein“, „J/N“, „1/0“ und „Wahr/Falsch“ alle in derselben Spalte dargestellt. Um konsistente Datentypen zu erhalten, muss für jede chaotische Spalte eine benutzerdefinierte Parsing-Logik geschrieben werden.

Was das Skript macht: Erkennt automatisch den beabsichtigten Datentyp für jede Spalte, standardisiert Formate und konvertiert alles in die richtigen Typen. Verarbeitet Datumsangaben in mehreren Formaten, bereinigt numerische Zeichenfolgen, normalisiert boolesche Darstellungen und validiert die Ergebnisse. Stellt einen Konvertierungsbericht bereit, der zeigt, was geändert wurde.

Wie es funktioniert: Das Skript tastet Werte aus jeder Spalte ab, um mithilfe von Mustervergleichen und Heuristiken auf den beabsichtigten Typ zu schließen. Anschließend wird das entsprechende Parsing angewendet: dateutil für versatile Datumsanalyse, Regex für numerische Extraktion, Zuordnungswörterbücher für boolesche Normalisierung. Fehlgeschlagene Konvertierungen werden mit den problematischen Werten zur manuellen Überprüfung protokolliert.

Holen Sie sich das Datentyp-Fixer-Skript

# 4. Ausreißerdetektor

Der Schmerzpunkt: Ihre numerischen Daten weisen Ausreißer auf, die Ihre Analyse zerstören. Bei einigen handelt es sich um Dateneingabefehler, bei anderen handelt es sich um legitime Extremwerte, die Sie beibehalten möchten, und bei anderen handelt es sich um mehrdeutige Werte. Sie müssen sie identifizieren, ihre Auswirkungen verstehen und entscheiden, wie mit jedem Fall umgegangen werden soll – winsorisieren, begrenzen, entfernen oder zur Überprüfung markieren.

Was das Skript macht: Erkennt Ausreißer mithilfe mehrerer statistischer Methoden wie IQR, Z-Rating, Isolationswaldvisualisiert deren Verteilung und Wirkung und wendet konfigurierbare Behandlungsstrategien an. Unterscheidet zwischen univariaten und multivariaten Ausreißern. Erstellt Berichte mit der Anzahl der Ausreißer, ihren Werten und der Artwork und Weise, wie sie behandelt wurden.

Wie es funktioniert: Das Skript berechnet Ausreißergrenzen mithilfe der von Ihnen gewählten Methode(n), markiert Werte, die Schwellenwerte überschreiten, und wendet eine Behandlung an: Entfernung, Kappung bei Perzentilen, Winsorisierung oder Imputation mit Grenzwerten. Für multivariate Ausreißer wird die Isolation Forest- oder Mahalanobis-Distanz verwendet. Alle Ausreißer werden zu Prüfzwecken mit ihren ursprünglichen Werten protokolliert.

Holen Sie sich das Skript zur Ausreißererkennung

# 5. Textdatenreiniger und -normalisierer

Der Schmerzpunkt: Ihre Textfelder sind ein Chaos. Namen haben eine inkonsistente Groß- und Kleinschreibung, Adressen verwenden unterschiedliche Abkürzungen (St. vs. Avenue vs. ST), Produktbeschreibungen enthalten HTML-Tags und Sonderzeichen und Freitextfelder enthalten überall führende/nachgestellte Leerzeichen. Die Standardisierung von Textdaten erfordert die konsistente Anwendung Dutzender Regex-Muster und Zeichenfolgenoperationen.

Was das Skript macht: Bereinigt und normalisiert Textdaten automatisch: Standardisiert Groß- und Kleinschreibung, entfernt unerwünschte Zeichen, erweitert oder standardisiert Abkürzungen, entfernt HTML, normalisiert Leerzeichen und behandelt Unicode-Probleme. Mit konfigurierbaren Reinigungspipelines können Sie unterschiedliche Regeln auf verschiedene Spaltentypen (Namen, Adressen, Beschreibungen usw.) anwenden.

Wie es funktioniert: Das Skript stellt eine Pipeline von Texttransformationen bereit, die professional Spaltentyp konfiguriert werden können. Es übernimmt die Groß-/Kleinschreibung, die Bereinigung von Leerzeichen, die Entfernung von Sonderzeichen, die Standardisierung von Abkürzungen mithilfe von Nachschlagewörterbüchern und die Unicode-Normalisierung. Jede Transformation wird protokolliert und Vorher/Nachher-Beispiele werden zur Validierung bereitgestellt.

Holen Sie sich das Textreiniger-Skript

# Abschluss

Diese fünf Skripte befassen sich mit den zeitaufwändigsten Herausforderungen bei der Datenbereinigung, denen Sie in realen Projekten gegenüberstehen. Hier ist eine kurze Zusammenfassung:

• Der Handler für fehlende Werte analysiert und unterstellt fehlende Daten clever
• Der Duplikatdetektor findet exakte und unscharfe Duplikate und löst sie auf
• Der Datentyp-Fixierer standardisiert Formate und konvertiert sie in geeignete Typen
• Der Ausreißerdetektor identifiziert und behandelt statistische Anomalien
• Textual content Cleaner normalisiert unordentliche Zeichenfolgendaten konsistent

Jedes Skript ist modular aufgebaut. Sie können sie additionally einzeln verwenden oder zu einer vollständigen Datenbereinigungspipeline verketten. Beginnen Sie mit dem Skript, das Ihr größtes Drawback angeht, testen Sie es anhand einer Stichprobe Ihrer Daten, passen Sie die Parameter für Ihren spezifischen Anwendungsfall an und bauen Sie nach und nach Ihren automatisierten Reinigungsworkflow auf.

Viel Spaß beim Bereinigen Ihrer Daten!

Bala Priya C ist ein Entwickler und technischer Redakteur aus Indien. Sie arbeitet gerne an der Schnittstelle von Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Zu ihren Interessen- und Fachgebieten gehören DevOps, Datenwissenschaft und Verarbeitung natürlicher Sprache. Sie liebt es zu lesen, zu schreiben, zu programmieren und Kaffee zu trinken! Derzeit arbeitet sie daran, zu lernen und ihr Wissen mit der Entwickler-Group zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt außerdem ansprechende Ressourcenübersichten und Programmier-Tutorials.

Bild vom Autor

# Einführung

Wenn Sie an die Datenbereinigung denken, denken Sie wahrscheinlich an die Inbetriebnahme eines Jupyter-Notizbuch. Aber hier ist etwas, das Sie vielleicht überraschen wird: Einige der leistungsstärksten Datenbereinigungen können direkt in Ihrem Terminal erfolgen, mit Instruments, die bereits auf Ihrem System installiert sind.

In diesem Artikel erfahren Sie, wie Sie grundlegende Befehlszeilen-Dienstprogramme zum Bereinigen, Transformieren und Durchsuchen von Datendateien verwenden. Es sind keine Installationen erforderlich; nur Ihr Terminal und einige CSV-Dateien.

Bevor wir mit der Datenbereinigung über die Befehlszeile beginnen, sprechen wir darüber, warum dies wichtig ist:

• Befehlszeilentools sind einfach zu verwenden, schnell und effizient, insbesondere bei großen Dateien.
• Diese Instruments sind in Linux/macOS integriert und unter Home windows verfügbar.
• Sie eignen sich hervorragend, um einen ersten Blick auf Daten zu werfen, bevor sie mit Python geladen und analysiert werden.
• Es ist einfach, Befehle in Skripten miteinander zu verketten und diese Skripte zur Automatisierung zu verwenden.

Jetzt fangen wir mit dem Codieren an!

Notiz: Hier finden Sie alle Befehle in diesem Bash-Skript auf GitHub. Um das Beste aus diesem Artikel herauszuholen, empfehle ich Ihnen, Ihr Terminal zu öffnen und mitzucoden.

# Beispieldaten einrichten

Lassen Sie uns eine unordentliche CSV-Datei erstellen, mit der wir arbeiten können. Dies simuliert reale Datenprobleme, auf die Sie wahrscheinlich stoßen werden.

cat > messy_data.csv << 'EOF'
identify,age,wage,division,e mail
John Lee,32,50000,Engineering,john@instance.com
Jane Smith,28,55000,Advertising,jane@instance.com
   Bob Davis    ,35,60000,Engineering,bob@instance.com
Alice Williams,29,,Advertising,alice@instance.com
Charlie Brown,45,70000,Gross sales,charlie@instance.com
Dave Wilson,31,52000,Engineering,
Emma Davis,,58000,Advertising,emma@instance.com
Frank Miller,38,65000,Gross sales,frank@instance.com
John Lee,32,50000,Engineering,john@instance.com
Grace Lee,27,51000,Engineering,grace@instance.com
EOF

Dieser Datensatz weist mehrere häufige Probleme auf: führende und nachfolgende Leerzeichen, fehlende Werte und doppelte Zeilen. Es eignet sich hervorragend zum Lernen!

# 1. Erkunden Sie Ihre Daten mit head, tailUnd wc

Bevor Sie Ihre Daten bereinigen, müssen Sie verstehen, womit Sie arbeiten. Beginnen wir mit den Grundlagen.

# See the primary 5 rows (together with header)
head -n 5 messy_data.csv

# See the final 3 rows
tail -n 3 messy_data.csv

# Rely complete rows (together with header)
wc -l messy_data.csv

Folgendes passiert:

• head -n 5 zeigt die ersten 5 Zeilen an und gibt Ihnen eine schnelle Vorschau.
• tail -n 3 zeigt die letzten 3 Zeilen an (nützlich zur Überprüfung, ob die Daten vollständig sind).
• wc -l zählt Zeilen – subtrahieren Sie 1 für die Kopfzeile, um die Anzahl Ihrer Datensätze zu erhalten.

Ausgabe:

identify,age,wage,division,e mail
John Lee,32,50000,Engineering,john@instance.com
Jane Smith,28,55000,Advertising,jane@instance.com
   Bob Davis    ,35,60000,Engineering,bob@instance.com
Alice Williams,29,,Advertising,alice@instance.com
Frank Miller,38,65000,Gross sales,frank@instance.com
John Lee,32,50000,Engineering,john@instance.com
Grace Lee,27,51000,Engineering,grace@instance.com
11 messy_data.csv

# 2. Anzeigen bestimmter Spalten mit minimize

Es müssen nicht immer alle Spalten angezeigt werden. Extrahieren wir nur die Namen und Abteilungen.

minimize -d',' -f1,4 messy_data.csv

Aufschlüsselung:

• minimize ist ein Werkzeug zum Extrahieren von Abschnitten aus jeder Zeile.
• -d',' setzt das Trennzeichen auf ein Komma (für CSV-Dateien).
• -f1,4 wählt die Felder (Spalten) 1 und 4 aus.
• Sie können auch Bereiche verwenden: -f1-3 für die Spalten 1 bis 3.

Hier ist die Ausgabe:

identify,division
John Lee,Engineering
Jane Smith,Advertising
   Bob Davis    ,Engineering
Alice Williams,Advertising
Charlie Brown,Gross sales
Dave Wilson,Engineering
Emma Davis,Advertising
Frank Miller,Gross sales
John Lee,Engineering
Grace Lee,Engineering

# 3. Doppelte Zeilen entfernen mit kind Und uniq

Beachten Sie, dass „John Lee“ in unserem Datensatz zweimal vorkommt. Lasst uns das beheben.

# Save the header first
head -n 1 messy_data.csv > cleaned_data.csv

# Take away duplicates from the info (excluding header)
tail -n +2 messy_data.csv | kind | uniq >> cleaned_data.csv

Hier ist, was jeder Befehl bewirkt: head -n 1 erfasst nur die Kopfzeile. tail -n +2 Ruft alles ab Zeile 2 ab (überspringt den Header). Dann, kind sortiert die Zeilen. Bitte beachten Sie das uniq Funktioniert nur mit sortierten Daten und uniq Entfernt benachbarte doppelte Zeilen. Endlich, >> wird an die Datei angehängt (im Gegensatz zu > was überschreibt).

# 4. Suchen und Filtern mit grep

Lassen Sie uns nun einige Such- und Filtervorgänge durchführen. Möchten Sie alle Ingenieure finden oder Zeilen mit fehlenden Daten herausfiltern? grep ist für alle derartigen Aufgaben praktisch.

# Discover all engineers
grep "Engineering" messy_data.csv

# Discover rows with empty fields (two consecutive commas)
grep ",," messy_data.csv

# Exclude rows with lacking information
grep -v ",," messy_data.csv > no_missing.csv

Hier, grep "sample" sucht nach Zeilen, die dieses Muster enthalten. grep -v kehrt die Übereinstimmung um (zeigt Zeilen an, die NICHT übereinstimmen). Dies ist eine schnelle Möglichkeit, unvollständige Datensätze herauszufiltern, sofern der fehlende Wert zu einem Doppelkomma (,,) führt.

# 5. Leerzeichen mit entfernen sed

Sehen Sie, dass die Platte von „Bob Davis“ zusätzliche Leerzeichen enthält? Lasst uns das aufräumen.

sed 's/^( t)*//; s/( t)*$//' messy_data.csv > trimmed_data.csv

Lassen Sie uns nun den Befehl verstehen: sed ist ein Stream-Editor zur Texttransformation. s/sample/alternative/ ist die Substitutionssyntax. ^( t)* Entspricht Leerzeichen/Tabulatoren am Anfang einer Zeile. ( t)*$ Entspricht Leerzeichen/Tabulatoren am Ende einer Zeile. Das Semikolon trennt zwei Vorgänge (Zeilenanfang kürzen, dann Zeilenende kürzen).

# 6. Werte ersetzen durch sed

Manchmal müssen Sie Werte standardisieren oder Tippfehler korrigieren. Versuchen wir, alle Vorkommen von „Engineering“ durch „Tech“ zu ersetzen.

# Change all "Engineering" with "Tech"
sed 's/Engineering/Tech/g' messy_data.csv

Als Nächstes füllen wir leere E-Mail-Felder (gekennzeichnet durch ein Komma am Ende der Zeile) mit einem Normal-E-Mail-Wert.

# Change empty e mail fields with "no-email@instance.com"
sed 's/,$/,no-email@instance.com/' messy_data.csv

Führen Sie die obigen Befehle aus und beobachten Sie die Ausgabe. Ich habe die Ausgabe hier ausgeschlossen, um Wiederholungen zu vermeiden.

Aufschlüsselung:

• Der g Flag bedeutet „world“ – ersetzt alle Vorkommen in jeder Zeile.
• ,$ Entspricht einem Komma am Ende einer Zeile (was auf ein leeres letztes Feld hinweist).
• Sie können mehrere Ersetzungen mit verketten ; zwischen ihnen.

# 7. Zählen und Zusammenfassen mit awk

awk ist sehr nützlich für Einsätze vor Ort. Lassen Sie uns eine grundlegende Analyse durchführen.

# Rely data by division
tail -n +2 messy_data.csv | minimize -d',' -f4 | kind | uniq -c

# Calculate common age (excluding header and empty values)
tail -n +2 messy_data.csv | awk -F',' '{if($2) sum+=$2; if($2) rely++} END {print "Common age:", sum/rely}'

Dabei awk Befehl, -F',' setzt das Feldtrennzeichen auf ein Komma und $2 bezieht sich auf das zweite Feld (Alter). Der Zustand if($2) stellt sicher, dass nur nicht leere Werte verarbeitet werden sum += $2 summiert die Summe. Schließlich ist die END Der Block wird ausgeführt, nachdem alle Zeilen gelesen wurden, um das Durchschnittsalter zu berechnen und auszudrucken.

Ausgabe:

      5 Engineering
      3 Advertising
      2 Gross sales
Common age: 33

# 8. Befehle mit Pipes kombinieren

Sie erhalten eine nützlichere Verarbeitung, wenn Sie diese Befehlszeilentools miteinander verketten.

# Get distinctive departments, sorted alphabetically
tail -n +2 messy_data.csv | minimize -d',' -f4 | kind | uniq

# Discover engineers with wage > 55000
tail -n +2 messy_data.csv | grep "Engineering" | awk -F',' '$3 > 55000' | minimize -d',' -f1,3

# Rely workers per division with counts
tail -n +2 messy_data.csv | minimize -d',' -f4 | kind | uniq -c | kind -rn

Hier, jeder | übergibt die Ausgabe eines Befehls als Eingabe an den nächsten. Dadurch können Sie Schritt für Schritt komplexe Datentransformationen erstellen. Der letzte Schritt sortiert nach Anzahl in umgekehrter numerischer Reihenfolge (-rn).

Dies gibt aus:

Engineering
Advertising
Gross sales
   Bob Davis    ,60000
      5 Engineering
      3 Advertising
      2 Gross sales

# 9. Konvertieren von Datenformaten

Manchmal müssen Sie mit unterschiedlichen Trennzeichen arbeiten. Hier versuchen wir, anstelle eines Kommas einen Tabulator als Trennzeichen zu verwenden.

# Convert CSV to TSV (tab-separated)
sed 's/,/t/g' messy_data.csv > information.tsv

# Add a brand new column with a hard and fast worth
awk -F',' 'BEGIN{OFS=","} {print $0, "2024"}' messy_data.csv > data_with_year.csv

Dabei awk Befehl, BEGIN{OFS=","} Setzt das Ausgabefeldtrennzeichen auf ein Komma. $0 stellt die gesamte Eingabezeile dar und print $0, "2024" Hängt „2024“ als neue Spalte an jede Ausgabezeile an.

# 10. Eine vollständige Reinigungspipeline

Fassen wir alles in einem nützlichen Befehl zusammen, der unsere unordentlichen Daten bereinigt:

# Save header
head -n 1 messy_data.csv > final_clean.csv

# Clear the info: take away duplicates, trim whitespace, exclude lacking values
tail -n +2 messy_data.csv | 
  sed 's/^( t)*//; s/( t)*$//' | 
  grep -v ",," | 
  kind | 
  uniq >> final_clean.csv

echo "Cleansing full! Examine final_clean.csv"

Diese Pipeline speichert zunächst den Header, um die Spaltennamen beizubehalten, und überspringt ihn dann bei der Verarbeitung der Datenzeilen. Es entfernt führende und nachfolgende Leerzeichen aus jeder Zeile, entfernt alle Zeilen, die leere Felder (insbesondere Doppelkommas) enthalten, sortiert die Daten und eliminiert doppelte Einträge. Schließlich werden die bereinigten Daten an die Ausgabedatei angehängt.

# Abschluss

Die Datenbereinigung über die Befehlszeile ist eine leistungsstarke, aber unterschätzte Fähigkeit für Datenwissenschaftler. Diese Instruments sind schnell und zuverlässig. Während Sie Python weiterhin für komplexe Analysen verwenden, werden Sie durch die Beherrschung dieser Grundlagen effizienter und haben Optionen, wenn Python nicht ultimate ist.

Das Beste daran ist, dass diese Fähigkeiten auf Datentechnik-, DevOps- und Systemadministrationsfunktionen übertragen werden können. Wenn Sie lernen, Daten über die Befehlszeile zu manipulieren, werden Sie zu einem vielseitigeren Entwickler.

Beginnen Sie mit dem Üben mit Ihren eigenen Datensätzen und Sie werden überrascht sein, wie oft Sie zu diesen Instruments greifen, anstatt Python-Notizbücher zu erstellen. Viel Spaß beim Bereinigen Ihrer Daten!

Bala Priya C ist ein Entwickler und technischer Redakteur aus Indien. Sie arbeitet gerne an der Schnittstelle von Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Zu ihren Interessen- und Fachgebieten gehören DevOps, Datenwissenschaft und Verarbeitung natürlicher Sprache. Sie liebt es zu lesen, zu schreiben, zu programmieren und Kaffee zu trinken! Derzeit arbeitet sie daran, zu lernen und ihr Wissen mit der Entwickler-Neighborhood zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt außerdem ansprechende Ressourcenübersichten und Programmier-Tutorials.

Daten aus der realen Welt sind selten perfekt – sie sind oft chaotisch, inkonsistent und voller Überraschungen. In diesem Beitrag erfahren Sie, wie Sie in Python eine Datenbereinigung für einen Datensatz aus dem Museum of Fashionable Artwork (MoMA) durchführen. Der Datensatz, der Hunderte von Kunstwerken katalogisiert, enthält häufige Datenprobleme wie fehlende Werte, inkonsistente Formate und schwierige Datumsbereiche.

Über den MoMA-Datensatz

Kunst ist ein chaotisches Geschäft. Im Laufe der Jahrhunderte haben Künstler alles geschaffen, von einfachen Gemälden bis hin zu komplexen Skulpturen, und Kunsthistoriker haben dabei alles katalogisiert, was ihnen möglich warfare. Das Museum of Fashionable Artwork, kurz MoMA, ist eines der einflussreichsten Museen der Welt und hat seinen Kunstkatalog öffentlich zugänglich gemacht. Sie können den Datensatz herunterladen unter GitHub und begleiten Sie uns bei der Reinigung und Vorbereitung für die Analyse.

Das Museum hat jedoch einen Haftungsausschluss herausgegeben, dass der Datensatz noch in Arbeit ist – vielleicht ein sich weiterentwickelndes Kunstwerk für sich. Wie bei vielen realen Datensätzen bedeutet dies, dass sie Qualitätsprobleme enthalten, die behoben werden müssen. Wir verwenden Python, um diese Eigenheiten zu untersuchen, Muster zu identifizieren und den Datensatz in ein saubereres Format für tiefere Einblicke umzuwandeln.

Warum Datenbereinigung in Python durchführen?

Python hat sich dank seiner Benutzerfreundlichkeit und leistungsstarken Bibliotheken zu einem der beliebtesten Instruments für die Arbeit mit Daten entwickelt. Organisationen aller Branchen verlassen sich auf Python, von der Verarbeitung von Finanzberichten bis hin zur Analyse wissenschaftlicher Forschung. Wenn es um die Datenbereinigung geht, bietet die Pandas-Bibliothek von Python effiziente Instruments für den Umgang mit unordentlichen Datensätzen, wie wir sie vom MoMA verwenden.

Gleich werden wir Pandas verwenden, um den Datensatz schnell zu laden, seine Struktur zu untersuchen und häufige Probleme zu beheben. Wenn Sie neu bei Python sind oder die Grundlagen auffrischen möchten, schauen Sie sich unsere an Einführung in die Python-Programmierung Kurs, der eine solide Grundlage für den Einstieg bietet.

Mit Pandas die Daten erkunden

Bevor wir mit der Bereinigung beginnen, werfen wir einen genaueren Blick auf den MoMA-Datensatz, um seine Struktur zu verstehen und mögliche Probleme zu identifizieren. Wir verwenden Pandas, eine beliebte Python-Bibliothek zum Arbeiten mit Daten, um die ersten 100 Zeilen in einen DataFrame zu laden. Dadurch können wir den Datensatz erkunden und eine Vorschau auf das erhalten, womit wir arbeiten.

import pandas
artworks_100 = pandas.read_csv("MOMA_Artworks.csv")
artworks_100.head(10)

Der .head() Die Methode zeigt die ersten paar Zeilen des Datensatzes an und hilft uns, etwaige Unregelmäßigkeiten sofort zu erkennen. Auf den ersten Blick enthält der Datensatz wertvolle Metadaten wie Titel, Künstler, Jahr und Medium jedes Kunstwerks. Allerdings können wir bereits einige Unregelmäßigkeiten feststellen Date Spalte, wie Jahresbereiche und nicht standardmäßige Einträge wie Unknown. Wir werden uns mit diesen Problemen befassen, während wir den Reinigungsprozess durchlaufen.

Arbeiten mit Daten in Pandas

Datumsangaben sind ein wichtiger Bestandteil vieler Datensätze, insbesondere bei der Analyse von Tendencies oder Mustern im Zeitverlauf. Im MoMA-Datensatz ist die Date Die Spalte enthält eine Mischung aus Formaten, z. B. Jahresbereiche (1976-77) und nicht standardmäßige Einträge (Unknown). Diese Inkonsistenzen erschweren die effektive Nutzung der Daten, sei es für die grafische Darstellung oder die Filterung nach Jahren.

Schauen wir uns zunächst die einzigartigen Werte im genauer an Date Spalte mit der .value_counts() Verfahren. Dies verschafft uns einen Überblick über die Daten und hilft uns, Muster oder Unregelmäßigkeiten zu erkennen, die behoben werden müssen.

# Verify the distribution of values within the 'Date' column
artworks_100('Date').value_counts()

Folgendes finden wir:

1976-77    25
1980-81    15
1979       12
Unknown     7
1980        5
1917        5
1978        5
1923        4
1935        3
1987        2
1903        2
1970        1
1896        1
1975        1
1984        1
1918        1
1986        1
n.d.        1
1906        1
1905        1
1930        1
1974        1
1936        1
1968        1
1900        1
c. 1917     1
dtype: int64

Diese Ausgabe hebt vier Schlüsselmuster in den Daten hervor:

• Muster 1: Jahresbereiche wie 1976-77
• Muster 2: Ungefähre Daten wie c. 1917
• Muster 3: Fehlende Werte mit der Bezeichnung Unknown
• Muster 4: Fehlende Werte mit der Bezeichnung n.d.

Bereinigen der Daten

Nachdem wir nun Unregelmäßigkeiten festgestellt haben Date Lassen Sie uns in der Spalte skizzieren, wie wir die Datenbereinigung in Python durchführen, um diese Probleme zu beheben. Jedes der vier Muster erfordert einen etwas anderen Ansatz:

• Muster 1: Jahresbereiche ersetzen (z. B. 1976-77) mit dem ersten Jahr im Bereich.
• Muster 2: Ungefähre Daten standardisieren (z. B. c. 1917) durch Entfernen der c. Präfix.
• Muster 3: Fehlende Werte mit der Bezeichnung belassen Unknown unverändert.
• Muster 4: Fehlende Werte mit der Bezeichnung konvertieren n.d. Zu Unknown für Konsistenz.

Durch die Anwendung dieser Transformationen stellen wir sicher, dass alle Werte in der Date In der Spalte sind entweder standardisierte Jahresangaben enthalten oder eindeutig als fehlende Informationen gekennzeichnet. Dadurch lässt sich der Datensatz einfacher analysieren und visualisieren.

Als Nächstes schreiben wir etwas Python-Code, um diese Änderungen Schritt für Schritt umzusetzen.

Muster 1: Jahresbereiche

Jahresbereiche wie 1976-77 erschweren die Analyse oder Visualisierung der Daten. Der Einfachheit halber ersetzen wir diese Bereiche durch das erste Jahr im Bereich. Zum Beispiel, 1976-77 wird werden 1976.

Dies können wir erreichen, indem wir den Wert am Bindestrich teilen (-) und nur den ersten Teil beibehalten. So geht’s:

def clean_split_dates(row):
    # Convert the present 'Date' worth to a string
    initial_date = str(row('Date'))
    # Break up the string on the hyphen
    split_date = initial_date.cut up('-')
    # Return the primary half if a hyphen is discovered; in any other case, return the unique worth
    return split_date(0) if len(split_date) > 1 else initial_date

# Apply the perform row by row to the 'Date' column
artworks_100('Date') = artworks_100.apply(clean_split_dates, axis=1)

# Verify the up to date distribution of values within the 'Date' column
artworks_100('Date').value_counts()

Nach Anwendung dieser Transformation wurden alle Jahresbereiche durch einzelne Jahre ersetzt, wodurch die Date Spalte konsistenter:

1976       25
1980       20
1979       12
Unknown     7
1917        5
1978        5
1923        4
1935        3
1987        2
1903        2
c. 1917     1
1918        1
1975        1
1968        1
n.d.        1
1905        1
1896        1
1984        1
1930        1
1970        1
1974        1
1986        1
1936        1
1900        1
1906        1
dtype: int64

Als nächstes werden wir darauf eingehen Muster 2 durch Standardisierung ungefährer Daten.

Muster 2: Ungefähre Daten

Im Datensatz werden einige Daten mithilfe des Präfixes als ungefähr gekennzeichnet c. (z.B, c. 1917). Um diese Einträge zu standardisieren, entfernen wir die c. Präfix, während das Jahr intakt bleibt. Zum Beispiel, c. 1917 wird werden 1917.

So können wir diese Einträge bereinigen:

def clean_approx_dates(row):
    # Convert the present 'Date' worth to a string
    initial_date = str(row('Date'))
    # Take away the 'c.' prefix if it exists
    if initial_date.startswith('c. '):
        return initial_date(3:)  # Return the string ranging from the 4th character
    return initial_date

# Apply the perform row by row to the 'Date' column
artworks_100('Date') = artworks_100.apply(clean_approx_dates, axis=1)

# Verify the up to date distribution of values within the 'Date' column
artworks_100('Date').value_counts()

Nach diesem Schritt wurden die ungefähren Daten bereinigt, so dass standardisierte Jahre übrig blieben. Hier ist eine aktualisierte Verteilung der Date Spalte:

1976       25
1980       20
1979       12
Unknown     7
1917        6
1978        5
1923        4
1935        3
1987        2
1903        2
1918        1
1975        1
1968        1
n.d.        1
1905        1
1896        1
1984        1
1930        1
1970        1
1974        1
1986        1
1936        1
1900        1
1906        1
dtype: int64

Nach diesem Schritt wurden die ungefähren Daten bereinigt, so dass standardisierte Jahre übrig blieben. Wir überspringen Muster 3 (Unknown), da wir diese Einträge unverändert lassen. Gehen wir stattdessen direkt zu Muster 4wobei wir andere fehlende Werte mit der Bezeichnung standardisieren n.d..

Muster 4: Fehlende Werte (n.d.)

Zusätzlich zu den Einträgen mit der Bezeichnung Unknownder Datensatz verwendet n.d. um fehlende Datumsinformationen anzuzeigen. Um die Daten konsistenter zu machen, ersetzen wir alle Instanzen von n.d. mit Unknown. Dadurch wird sichergestellt, dass fehlende Werte im gesamten Datensatz einheitlich dargestellt werden.

So können wir damit umgehen:

def clean_missing_dates(row):
    # Change 'n.d.' with 'Unknown' if discovered within the 'Date' column
    return 'Unknown' if row('Date') == 'n.d.' else row('Date')

# Apply the perform row by row to the 'Date' column
artworks_100('Date') = artworks_100.apply(clean_missing_dates, axis=1)

# Verify the up to date distribution of values within the 'Date' column
artworks_100('Date').value_counts()

1976       25
1980       20
1979       12
Unknown     8
1917        6
1978        5
1923        4
1935        3
1987        2
1903        2
1918        1
1975        1
1968        1
1905        1
1896        1
1984        1
1930        1
1970        1
1974        1
1986        1
1936        1
1900        1
1906        1
dtype: int64

Mit n.d. Einträge vereinheitlicht, alle fehlenden Werte werden nun mit gekennzeichnet Unknown. Diese Konsistenz erleichtert die Analyse oder Filterung der Daten bei fehlenden Daten.

Zu diesem Zeitpunkt haben wir alle Muster erfolgreich angegangen Date Spalte. Der Datensatz ist jetzt viel sauberer und bereit für die weitere Analyse.

Nächste Schritte

Wir haben einige wichtige Datenbereinigungstechniken in Python beim Bereinigen behandelt Date Spalte im MoMA-Datensatz, aber bei der Datenbereinigung müssen häufig eine Reihe von Problemen über mehrere Spalten hinweg behoben werden. Wenn Sie noch weiter gehen möchten, ist unser Exemplarische Vorgehensweise für das Datenbereinigungsprojekt Kurs ist ein toller nächster Schritt. In diesem sechsteiligen Kurs lernen Sie nicht nur, wie Sie Daten mit Python und Pandas bereinigen und transformieren, sondern umfassen auch zwei geführte Projekte, die sich perfekt für den Aufbau eines Portfolios eignen.

Während Sie diese Projekte durcharbeiten, sammeln Sie praktische Erfahrungen, die Sie potenziellen Arbeitgebern präsentieren können. Tipps, wie Sie Ihre Projekte wirkungsvoll präsentieren, finden Sie in unserem Leitfaden Erstellen eines Information-Science-Portfolios das fällt auf.

Bild vom Autor | Erstellt auf Canva

Wenn Sie Linux oder Mac verwenden, haben Sie wahrscheinlich schon grep in der Befehlszeile, um Dateien nach übereinstimmenden Mustern zu durchsuchen. Mit regulären Ausdrücken (Regex) können Sie Textual content anhand von Mustern suchen, abgleichen und bearbeiten. Das macht sie zu leistungsstarken Werkzeugen für die Textverarbeitung und Datenbereinigung.

Für reguläre Ausdrucksübereinstimmungsoperationen in Python können Sie die integrierte re-Modul. In diesem Tutorial sehen wir uns an, wie Sie mit regulären Ausdrücken Daten bereinigen können. Wir beschäftigen uns mit der Entfernung unerwünschter Zeichen, dem Extrahieren bestimmter Muster, dem Suchen und Ersetzen von Textual content und vielem mehr.

1. Entfernen Sie unerwünschte Zeichen

Bevor wir fortfahren, importieren wir das integrierte Re-Modul:

Zeichenfolgenfelder müssen (quick) immer gründlich bereinigt werden, bevor Sie sie analysieren können. Unerwünschte Zeichen – oft aufgrund unterschiedlicher Formate – können die Analyse Ihrer Daten erschweren. Mithilfe von Regex können Sie diese effizient entfernen.

Sie können die sub() Funktion aus dem Modul re, um alle Vorkommen eines Musters oder Sonderzeichens zu ersetzen oder zu entfernen. Angenommen, Sie haben Zeichenfolgen mit Telefonnummern, die Bindestriche und Klammern enthalten. Sie können sie wie gezeigt entfernen:

textual content = "Contact information: (123)-456-7890 and 987-654-3210."
cleaned_text = re.sub(r'(()-)', '', textual content)
print(cleaned_text) 

Hier, re.sub(Muster, Ersetzung, Zeichenfolge) ersetzt alle Vorkommen des Musters in der Zeichenfolge durch den Ersatz. Wir verwenden die R'(()-)‘ Muster, das mit jedem Vorkommen von (, ), oder übereinstimmt, was uns die Ausgabe gibt:

Output >>> Contact information: 1234567890 or 9876543210

2. Extrahieren Sie bestimmte Muster

Das Extrahieren von E-Mail-Adressen, URLs oder Telefonnummern aus Textfeldern ist eine häufige Aufgabe, da es sich hierbei um relevante Informationen handelt. Und um alle spezifischen Muster von Interesse zu extrahieren, können Sie die findall() Funktion.

Sie können E-Mail-Adressen aus einem Textual content wie folgt extrahieren:

textual content = "Please attain out to us at help@instance.org or assist@instance.org."
emails = re.findall(r'b(w.-)+?@w+?.w+?b', textual content)
print(emails)

Der re.findall(Muster, Zeichenfolge) Funktion findet und gibt (als Liste) alle Vorkommen des Musters in der Zeichenfolge zurück. Wir verwenden das Muster r’b(w.-)+?@w+?.w+?b‘ um alle E-Mail-Adressen abzugleichen:

Output >>> ('help@instance.com', 'gross sales@instance.org')

3. Muster ersetzen

Wir haben bereits die sub() Funktion zum Entfernen unerwünschter Sonderzeichen. Sie können jedoch ein Muster durch ein anderes ersetzen, um das Feld für eine konsistentere Analyse geeignet zu machen.

Hier ist ein Beispiel zum Entfernen unerwünschter Leerzeichen:

textual content = "Utilizing     common     expressions."
cleaned_text = re.sub(r's+', ' ', textual content)
print(cleaned_text) 

Der r’s+‘ Das Muster entspricht einem oder mehreren Leerzeichen. Die Ersatzzeichenfolge ist ein einzelnes Leerzeichen und ergibt die Ausgabe:

Output >>> Utilizing common expressions.

4. Datenformate validieren

Durch die Validierung von Datenformaten wird die Konsistenz und Richtigkeit der Daten sichergestellt. Regex kann Formate wie E-Mails, Telefonnummern und Daten validieren.

So nutzen Sie die match() Funktion zum Validieren von E-Mail-Adressen:

electronic mail = "check@instance.com"
if re.match(r'^b(w.-)+?@w+?.w+?b$', electronic mail):
    print("Legitimate electronic mail")  
else:
    print("Invalid electronic mail")

In diesem Beispiel ist die E-Mail-Zeichenfolge gültig:

5. Strings nach Mustern aufteilen

Manchmal möchten Sie einen String in mehrere Strings aufteilen, basierend auf Mustern oder dem Vorkommen bestimmter Trennzeichen. Sie können den cut up() Funktion, um das zu tun.

Teilen wir die textual content Zeichenfolge in Sätze:

textual content = "That is sentence one. And that is sentence two! Is that this sentence three?"
sentences = re.cut up(r'(.!?)', textual content)
print(sentences) 

Hier, re.cut up(Muster, Zeichenfolge) teilt den String an allen Stellen, an denen das Muster vorkommt. Wir verwenden die R'(.!?)‘ Muster zum Abgleichen von Punkten, Ausrufezeichen oder Fragezeichen:

Output >>> ('That is sentence one', ' And that is sentence two', ' Is that this sentence three', '')

Bereinigen Sie Pandas-Datenrahmen mit Regex

Durch die Kombination von Regex mit Pandas können Sie Datenrahmen effizient bereinigen.

So entfernen Sie nicht-alphabetische Zeichen aus Namen und validieren E-Mail-Adressen in einem Datenrahmen:

import pandas as pd

information = {
	'names': ('Alice123', 'Bob!@#', 'Charlie$$$'),
	'emails': ('alice@instance.com', 'bob_at_example.com', 'charlie@instance.com')
}
df = pd.DataFrame(information)

# Take away non-alphabetic characters from names
df('names') = df('names').str.substitute(r'(^a-zA-Z)', '', regex=True)

# Validate electronic mail addresses
df('valid_email') = df('emails').apply(lambda x: bool(re.match(r'^b(w.-)+?@w+?.w+?b$', x)))

print(df)

Im obigen Codeausschnitt:

• df('names').str.substitute(sample, substitute, regex=True) ersetzt Vorkommen des Musters in der Reihe.
• lambda x: bool(re.match(sample, x)): Diese Lambda-Funktion wendet die Regex-Übereinstimmung an und konvertiert das Ergebnis in einen Booleschen Wert.

Die Ausgabe sieht wie folgt aus:

 	  names           	   emails    valid_email
0	  Alice	        alice@instance.com     	    True
1  	  Bob          bob_at_example.com    	    False
2         Charlie     charlie@instance.com     	    True

Einpacken

Ich hoffe, Sie fanden dieses Tutorial hilfreich. Lassen Sie uns noch einmal wiederholen, was wir gelernt haben:

• Verwenden re.sub um unnötige Zeichen zu entfernen, wie etwa Bindestriche und Klammern in Telefonnummern und dergleichen.
• Verwenden re.findall um bestimmte Muster aus Textual content zu extrahieren.
• Verwenden re.sub um Muster zu ersetzen, beispielsweise um mehrere Leerzeichen in ein einziges Leerzeichen umzuwandeln.
• Validieren Sie Datenformate mit re.match um sicherzustellen, dass Daten bestimmte Formate einhalten, beispielsweise durch die Validierung von E-Mail-Adressen.
• Um Zeichenfolgen basierend auf Mustern aufzuteilen, wenden Sie re.cut up.

In der Praxis kombinieren Sie Regex mit Pandas, um Textfelder in Datenrahmen effizient zu bereinigen. Es ist auch eine gute Praxis, Ihre Regex zu kommentieren, um ihren Zweck zu erklären und so die Lesbarkeit und Wartbarkeit zu verbessern. Weitere Informationen zur Datenbereinigung mit Pandas finden Sie unter 7 Schritte zur Beherrschung der Datenbereinigung mit Python und Pandas.

Bala Priya C ist Entwicklerin und technische Redakteurin aus Indien. Sie arbeitet gerne an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessens- und Fachgebiete umfassen DevOps, Datenwissenschaft und natürliche Sprachverarbeitung. Sie liest, schreibt, programmiert und trinkt gerne Kaffee! Derzeit arbeitet sie daran, ihr Wissen zu lernen und mit der Entwickler-Group zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt auch ansprechende Ressourcenübersichten und Programmier-Tutorials.

Einführung

Stellen Sie sich vor, Sie planen ein großes Familientreffen. Sie haben eine Teilnehmerliste, aber diese ist voller falscher Kontakte, der gleichen Kontakte und einige Namen sind falsch geschrieben. Wenn Sie sich nicht die Zeit nehmen, diese Liste zu bereinigen, besteht die Möglichkeit, dass Ihr Treffen zu einem Desaster wird. Unternehmen und Konzerne benötigen saubere und genaue Daten, um richtig zu funktionieren und die richtigen Entscheidungen zu treffen. Der Vorgang, Ihre Daten zu bereinigen und sicherzustellen, dass sie genau, frei von Duplikaten und so aktuell wie möglich sind, wird als Datenbereinigung bezeichnet. Datenbereinigung verbessert daher die Betriebsleistung und die Entscheidungsfindung von Unternehmen, genau wie eine angemessene Vorbereitung des Treffens.

Überblick

• Definition der Datenbereinigung und Informationen zu ihrer Bedeutung.
• Erfahren Sie mehr über die Techniken und Werkzeuge zur Datenbereinigung.
• Informieren Sie sich über die Bereiche, die die Datenqualität am stärksten beeinträchtigen, und erfahren Sie, wie Sie die Probleme beheben können.
• Erfahren Sie mehr über Möglichkeiten, wie Sie die Datenbereinigung effektiv in Ihrem Unternehmen implementieren können.
• Identifizieren Sie die Probleme der Datenbereinigung und erfahren Sie, wie Sie diese vermeiden können.

Was ist Datenbereinigung?

Datenbereinigung ist eine Datenmanagement Prozess zum Auffinden und Beheben von Dateneingabeproblemen wie Genauigkeitsproblemen und Inkonsistenzen in den Daten. Solche Probleme können durch Fehler wie falsche Eingaben bei der Dateneingabe, Probleme in den Computerdatenbanken sowie das Zusammenführen von Daten aus verschiedenen Quellen entstehen. Dies ist wichtig, da für Analyse, Berichterstellung und Entscheidungsfindung saubere Daten in den Prozess eingespeist werden müssen.

Schritte zur Datenbereinigung

Datenbereinigung bezieht sich auf den Prozess des Waschens, da dabei eine Reihe von Protokollen befolgt werden müssen, um Probleme mit Daten zu beheben. Dabei handelt es sich in der Regel um die Überprüfung, Bearbeitung und Normalisierung die Daten, um Genauigkeit und Einheitlichkeit der Daten zu erreichen.

Datenvalidierung

In diesem Schritt werden die Daten auf Fehler und Inkonsistenzen geprüft. Dabei wird überprüft, ob die Daten innerhalb akzeptabler Bereiche liegen und vordefinierten Formaten entsprechen. Stellen Sie beispielsweise sicher, dass die Daten im richtigen Format vorliegen (z. B. JJJJ-MM-TT) und die numerischen Werte innerhalb der angegebenen Bereiche liegen.

Duplikatserkennung und -entfernung

Dies führt häufig dazu, dass zwei oder mehr Einträge mit ähnlichen oder identischen Informationen vorhanden sind. Dies kann verschiedene Ursachen haben, darunter Eingabefehler und Probleme, die mit Systemschnittstellen zusammenhängen. Beim Datenscrubbing werden diese Einträge auch ausgesondert, um sicherzustellen, dass alle Datensätze im Datensatz nichts anderes als Duplikate voneinander sind.

Datenstandardisierung

Verschiedene Datenquellen können unterschiedliche Formate oder Einheiten verwenden. Beim Datenscrubbing werden Daten in ein standardisiertes Format konvertiert, um Konsistenz im gesamten Datensatz sicherzustellen. Beispielsweise können Datumsformate standardisiert oder alle Währungswerte in eine gemeinsame Währung konvertiert werden.

Datenkorrektur

Die Eingabefehler müssen korrigiert werden. Dazu gehören Tippfehler, falsche Eingaben und veraltete Informationen. Bei der Datenberichtigung werden diese Fehler korrigiert, um die Glaubwürdigkeit und Zuverlässigkeit des betreffenden Datensatzes aufrechtzuerhalten.

Datenanreicherung

Manchmal umfasst die Datenbereinigung auch das Hinzufügen fehlender Informationen oder das Verbessern vorhandener Daten. Dazu kann das Ausfüllen fehlender Werte aus externen Quellen oder das Aktualisieren von Datensätzen mit den neuesten Informationen gehören.

Datentransformation

Ein weiterer Aspekt der Datenbereinigung ist die Umwandlung von Daten in ein für Analysen oder Berichte geeignetes Format. Dies kann die Aggregation von Daten, die Erstellung neuer berechneter Felder oder die Umstrukturierung von Daten zur Anpassung an analytische Modelle umfassen.

Datenintegration

Wenn Daten aus mehreren Quellen stammen, integrieren Sie sie in ein einheitliches Format. Durch Datenbereinigung wird eine genaue und aussagekräftige Kombination von Daten aus verschiedenen Quellen gewährleistet.

Datenprüfung

Regelmäßige Audits werden durchgeführt, um die Qualität der Daten und die Wirksamkeit der Datenbereinigungsprozesse zu überprüfen. Dies hilft dabei, die Datenqualität aufrechtzuerhalten und Bereiche zu identifizieren, die verbessert werden können.

Sehen wir uns nun die folgenden Techniken und Instruments zur Datenbereinigung an:

Techniken

• Datenvalidierung: Überprüfen der Daten anhand vordefinierter Regeln oder Requirements, um deren Richtigkeit sicherzustellen.
• Datenanalyse: Zerlegen Sie die Daten in kleinere, handhabbare Teile, um Fehler zu erkennen.
• Datenstandardisierung: Konvertieren der Daten in ein gemeinsames Format zur Gewährleistung der Konsistenz.
• Duplikatsentfernung: Identifizieren und Eliminieren doppelter Datensätze im Datensatz.
• Fehlerkorrektur: Manuelles oder automatisches Korrigieren erkannter Fehler in den Daten.
• Datenanreicherung: Hinzufügen fehlender Informationen oder Anreichern von Daten mit zusätzlichen relevanten Particulars.

Werkzeuge

• OpenRefine: Ein wichtiges Mittel zum Bereinigen und Verschieben der Daten.
• Drei Fakten: Eine Datenmanipulationsumgebung, in der ein Benutzer Daten mit Hilfe künstlicher Intelligenz verwalten und vorbereiten kann.
• Talend: Ein elektronisches Information Warehouse, das Methoden zur effektiven Datenbereinigung beinhaltet.
• Datenleiter: Ein auf Geschwindigkeit basierendes Device zum Sammeln und Abgleichen von Datensätzen.
• Pandas (Python-Bibliothek): Schmutzige Daten sind Datenanalysten seit Jahren ein Dorn im Auge und Information Body ist ein sehr flexibles Werkzeug, das in der Umgang mit Daten und säubern Sie es dabei.

Bedeutung der Datenbereinigung

Datenbereinigung ist ein wichtiger Prozess, um sicherzustellen, dass Daten in einer Reihe von Bereichen konsistent und nutzbar sind. Aus diesen Gründen ist Datenbereinigung unerlässlich:

Verbesserte Entscheidungsfindung

Daher sind saubere Daten erforderlich, damit die richtigen Entscheidungen auf die richtige Weise getroffen werden können. Falsche Informationen können sehr schädlich sein, da sie detrimental Folgen für die Entscheidungsfindung bei jeder strategischen Entwicklung oder bei operativen Aktivitäten haben können. Auf diese Weise können Unternehmen sicher sein, dass sie qualitativ hochwertige Daten erhalten, die zur Verbesserung der Geschäftsleistung beitragen können.

Gesteigerte Effizienz

Durch die Datenbereinigung werden Duplikate und Redundanzen in den Daten eliminiert, Fehler korrigiert und Datenformate standardisiert, was die Datenverarbeitung erleichtert. Dies verbessert den Arbeitsablauf, reduziert den Zeitaufwand für die Korrektur falsch eingegebener Daten und steigert die Produktivität.

Verbesserte Kundenbeziehungen

Intestine gepflegte Kundendatenbanken verbessern die Artwork und Weise, wie Unternehmen mit ihren Kunden interagieren und sie ansprechen. Auf diese Weise können Unternehmen aufgrund der Reduzierung von Fehlern und Unterschieden in den Kundeninformationen ihre Fehler minimieren und ihren Kunden maximale Zufriedenheit und Loyalität bieten, was letztendlich zu einer Vergrößerung des Kundenstamms führt.

Einhaltung gesetzlicher Vorschriften

Dies liegt zum Teil daran, dass zahlreiche Branchen gesetzliche Verpflichtungen in Bezug auf Datengenauigkeit und Datenschutz haben. Datenbereinigung hilft dabei, diese Vorschriften einzuhalten und so mögliche Rechtsfälle sowie Geldbußen zu vermeiden.

Kosteneinsparungen

Dies bedeutet auch, dass bei fehlerhaften Daten viel Geld, Zeit und andere Ressourcen vergeblich eingesetzt werden und wichtige Gelegenheiten verpasst werden. Unternehmen können solche Kosten vermeiden, da durch die Bereinigung von Daten häufige Bereinigungen, Korrekturen und Abfragen vermieden werden, die sehr kostspielig sein können.

Verbesserte Datenintegration

In Organisationen werden verschiedene Datenquellen verwendet. Durch Datenbereinigung können Daten aus verschiedenen Systemen in einem umfassenderen Ansatz abgerufen werden. Dies ermöglicht eine integrierte Betrachtung der für die Analyse- und Berichtsanforderungen wichtigsten Informationen.

Bessere Analysen und Berichte

Analytik ist eine wichtige Funktion in Unternehmen und Organisationen, aber ihre Wirksamkeit hängt von der Qualität der Daten ab, die ihr zugeführt werden. Mit einer guten und sauberen Datenschicht trägt die Datenbereinigung dazu bei, sicherzustellen, dass die für Berichte und Analysen verwendeten Daten stets sauber sind, was zu möglichst genauen Berichten und Analysen führt.

Häufige Probleme mit der Datenqualität und deren Lösungen

• Fehlende Werte: Verwenden Sie Techniken wie Imputation, bei der fehlende Werte durch geschätzte Werte ersetzt werden, oder entfernen Sie Datensätze mit fehlenden Daten.
• Inkonsistente Datenformate: Standardisieren Sie Formate (z. B. Daten, Adressen), um Konsistenz zu gewährleisten.
• Doppelte Datensätze: Implementieren Sie Algorithmen zum Identifizieren und Zusammenführen oder Entfernen von Duplikaten.
• Ausreißer: Erkennen und untersuchen Sie Ausreißer, um festzustellen, ob es sich um Fehler oder gültige Werte handelt.
• Falsche Daten: Validieren Sie die Daten anhand vertrauenswürdiger Quellen oder verwenden Sie automatisierte Korrekturalgorithmen.

Greatest Practices für die Datenbereinigung

• Legen Sie Datenqualitätsstandards fest: Darüber hinaus muss angegeben werden, welche Artwork von Daten für eine Organisation als sauber angesehen werden können.
• Automatisieren Sie, wo möglich: Wenden Sie eine Automatisierung der Datenbereinigung an und verwenden Sie Skripte, wenn der Einsatz von Datenbereinigungstools nicht möglich ist.
• Überprüfen und aktualisieren Sie die Daten regelmäßig: Die Datenbereinigung sollte tatsächlich ein iterativer Prozess sein und nicht als einmalige Maßnahme betrachtet werden.
• Dateneigentümer einbeziehen: Besprechen Sie die Angelegenheit mit den Personen, die die Daten intestine kennen, um Probleme zu erkennen und zu lösen.
• Dokumentieren Sie Ihren Prozess: Führen Sie detaillierte Aufzeichnungen über Datenbereinigungsaktivitäten und -entscheidungen.

Herausforderungen bei der Datenbereinigung

• Datenmenge: Die Arbeit mit Huge Information stellt eine Herausforderung im Umgang mit den großen verfügbaren Datenmengen und deren Verwaltung dar.
• Komplexität der Daten: Die großen Datenmengen sind zudem unterschiedlicher Natur und können strukturiert, unstrukturiert, als Textual content, numerisch, kategorisch, nominal, ordinal und mehr sein.
• Fehlende Standardisierung: Inkonsistente Datenstandards zwischen den verschiedenen Quellen erschweren den Bereinigungsprozess.
• Ressourcenintensiv: Die Datenbereinigung kann erhebliche personelle und technische Ressourcen erfordern.
• Kontinuierlicher Prozess: Die Aufrechterhaltung der Datenqualität erfordert ständige Anstrengungen und Wachsamkeit.

Abschluss

Ein entscheidender Schritt zur Gewährleistung der Genauigkeit und Zuverlässigkeit der für Analysen und Entscheidungen verwendeten Daten ist die Datenbereinigung. Unternehmen können die Qualität ihrer Daten drastisch steigern, was zu genaueren Erkenntnissen und besseren Geschäftsergebnissen führt, indem sie Greatest Practices und effiziente Datenbereinigungsprozesse in die Praxis umsetzen. Trotz der Schwierigkeiten ist die Datenbereinigung eine lohnende Investition, denn saubere Daten haben viele Vorteile.

Häufig gestellte Fragen

Bild vom Autor | DALLE-3 & Canva

Haben Sie schon einmal mit unübersichtlichen Datensätzen zu tun gehabt? Sie sind eine der größten Hürden in jedem Information-Science-Projekt. Diese Datensätze können Inkonsistenzen, fehlende Werte oder Unregelmäßigkeiten enthalten, die die Analyse erschweren. Die Datenbereinigung ist der wesentliche erste Schritt, der die Grundlage für genaue und zuverlässige Erkenntnisse legt, aber sie ist langwierig und zeitaufwändig.

Keine Angst! Ich möchte Ihnen Pyjanitor vorstellen, eine fantastische Python-Bibliothek, die Ihnen den Tag retten kann. Es ist ein praktisches Python-Paket, das eine einfache Lösung für diese Herausforderungen bei der Datenbereinigung bietet. In diesem Artikel werde ich die Bedeutung von Pyjanitor sowie seine Funktionen und praktische Anwendung erläutern.

Am Ende dieses Artikels haben Sie ein klares Verständnis davon, wie Pyjanitor die Datenbereinigung und ihre Anwendung in alltäglichen datenbezogenen Aufgaben vereinfacht.

Was ist Pyjanitor?

Pyjanitor ist ein erweitertes R-Paket von Python, das auf Pandas aufbaut und Datenbereinigungs- und Vorverarbeitungsaufgaben vereinfacht. Es erweitert seine Funktionalität, indem es eine Vielzahl nützlicher Funktionen bietet, die den Prozess der Bereinigung, Transformation und Vorbereitung von Datensätzen verfeinern. Betrachten Sie es als Improve Ihres Datenbereinigungs-Toolkits. Möchten Sie mehr über Pyjanitor erfahren? Ich auch. Lassen Sie uns beginnen.

Erste Schritte

Als Erstes müssen Sie Pyjanitor installieren. Öffnen Sie Ihr Terminal oder Ihre Eingabeaufforderung und führen Sie den folgenden Befehl aus:

Der nächste Schritt besteht darin, Pyjanitor und Pandas in Ihr Python-Skript zu importieren. Dies kann folgendermaßen erfolgen:

import janitor
import pandas as pd

Jetzt können Sie Pyjanitor für Ihre Datenbereinigungsaufgaben verwenden. Im Folgenden werde ich einige der nützlichsten Funktionen von Pyjanitor erläutern:

1. Spaltennamen bereinigen

Heben Sie die Hand, wenn Sie jemals über inkonsistente Spaltennamen frustriert waren. Ja, ich auch. Mit Pyjanitors clean_names() Mit dieser Funktion können Sie Ihre Spaltennamen schnell standardisieren und sie mit nur einem einfachen Aufruf einheitlich und konsistent machen. Diese leistungsstarke Funktion ersetzt Leerzeichen durch Unterstriche, konvertiert alle Zeichen in Kleinbuchstaben, entfernt führende und nachfolgende Leerzeichen und ersetzt sogar Punkte durch Unterstriche. Lassen Sie uns dies anhand eines einfachen Beispiels verstehen.

#Create a knowledge body with inconsistent column names
student_df = pd.DataFrame({
    'Pupil.ID': (1, 2, 3),
    'Pupil Identify': ('Sara', 'Hanna', 'Mathew'),
    'Pupil Gender': ('Feminine', 'Feminine', 'Male'),
    'Course*': ('Algebra', 'Information Science', 'Geometry'),
    'Grade': ('A', 'B', 'C')
})

#Clear the column names
clean_df = student_df.clean_names()
print(clean_df)

Ausgabe:

   student_id    student_name    student_gender        course    grade
0           1            Sara            Feminine       Algebra        A
1           2           Hanna            Feminine  Information Science        B
2           3          Mathew              Male      Geometry        C

2. Spalten umbenennen

Manchmal verbessert das Umbenennen von Spalten nicht nur unser Verständnis der Daten, sondern auch deren Lesbarkeit und Konsistenz. Dank der rename_column() Funktion wird diese Aufgabe mühelos. Ein einfaches Beispiel, das die Benutzerfreundlichkeit dieser Funktion zeigt, ist wie folgt:

student_df = pd.DataFrame({
    'stu_id': (1, 2),
    'stu_name': ('Ryan', 'James'),
})
# Renaming the columns
student_df = student_df.rename_column('stu_id', 'Student_ID')
student_df =student_df.rename_column('stu_name', 'Student_Name')
print(student_df.columns)

Ausgabe:

Index(('Student_ID', 'Student_Name'), dtype="object")

3. Umgang mit fehlenden Werten

Fehlende Werte sind ein echtes Downside bei der Arbeit mit Datensätzen. Glücklicherweise fill_missing() ist praktisch, um diese Probleme zu beheben. Lassen Sie uns anhand eines praktischen Beispiels untersuchen, wie fehlende Werte mit Pyjanitor behandelt werden. Zuerst erstellen wir einen Dummy-Datenrahmen und füllen ihn mit einigen fehlenden Werten.

# Create a knowledge body with lacking values
employee_df = pd.DataFrame({
    'employee_id': (1, 2, 3, 4, 5),
    'title': ('Ryan', 'James', 'Alicia'),
    'division': ('HR', None, 'Engineering'),
    'wage': (60000, 55000, None)
})

Sehen wir uns nun an, wie Pyjanitor beim Ausfüllen dieser fehlenden Werte helfen kann:

# Substitute lacking 'division' with 'Unknown'
# Substitute the lacking 'wage' with the imply of salaries
employee_df = employee_df.fill_missing({
    'division': 'Unknown',
    'wage': employee_df('wage').imply(),
})
print(employee_df)

Ausgabe:

   employee_id     title   division   wage
0            1     Ryan           HR  60000.0
1            2    James      Unknown  55000.0
2            3   Alicia  Engineering  57500.0

In diesem Beispiel die Abteilung des Mitarbeiters ‚James‘ wird ersetzt durch ‚Unbekannt‘und das Gehalt von ‚Alicia‘ wird ersetzt durch den Durchschnitt von „Ryan“ – Die wunderbare Welt des Wahnsinns Und ‚James‘ Gehälter. Sie können verschiedene Strategien zum Umgang mit fehlenden Werten verwenden, z. B. Vorwärtsdurchlauf, Rückwärtsdurchlauf oder Auffüllen mit einem bestimmten Wert.

4. Zeilen filtern und Spalten auswählen

Das Filtern von Zeilen und Spalten ist eine wichtige Aufgabe bei der Datenanalyse. Pyjanitor vereinfacht diesen Prozess, indem es Funktionen bereitstellt, mit denen Sie Spalten auswählen und Zeilen basierend auf bestimmten Bedingungen filtern können. Angenommen, Sie haben einen Datenrahmen mit Studentendatensätzen und möchten Studenten (Zeilen) herausfiltern, deren Noten unter 60 liegen. Sehen wir uns an, wie Pyjanitor uns dabei hilft.

# Create a knowledge body with scholar information
students_df = pd.DataFrame({
    'student_id': (1, 2, 3, 4, 5),
    'title': ('John', 'Julia', 'Ali', 'Sara', 'Sam'),
    'topic': ('Maths', 'Common Science', 'English', 'Historical past''),
    'marks': (85, 58, 92, 45, 75),
    'grade': ('A', 'C', 'A+', 'D', 'B')
})

# Filter rows the place marks are lower than 60
filtered_students_df = students_df.question('marks >= 60')
print(filtered_students_df)

Ausgabe:

   student_id    title  topic  marks grade
0           1    John     Math     85     A
2           3   Lucas  English     92    A+
4           5  Sophia     Math     75     B

Nehmen wir nun an, Sie möchten auch nur bestimmte Spalten ausgeben, z. B. nur den Namen und die ID, und nicht die gesamten Daten. Pyjanitor kann Ihnen dabei auch wie folgt helfen:

# Choose particular columns
selected_columns_df = filtered_students_df.loc(:,('student_id', 'title'))

Ausgabe:

   student_id    title  
0           1    John    
2           3   Lucas 
4           5  Sophia 

5. Verkettungsmethoden

Mit der Methodenverkettungsfunktion von Pyjanitor können Sie mehrere Vorgänge in einer einzigen Zeile ausführen. Diese Funktion ist eine der besten Funktionen. Betrachten wir zur Veranschaulichung einen Datenrahmen, der Daten über Autos enthält:

# Create a knowledge body with pattern automobile information
cars_df =pd.DataFrame ({
    'Automobile ID': (101, None, 103, 104, 105),
    'Automobile Mannequin': ('Toyota', 'Honda', 'BMW', 'Mercedes', 'Tesla'),
    'Value ($)': (25000, 30000, None, 40000, 45000),
    'Yr': (2018, 2019, 2017, 2020, None)
})
print("Vehicles Information Earlier than Making use of Technique Chaining:")
print(cars_df)

Ausgabe:

Vehicles Information Earlier than Making use of Technique Chaining:
   Automobile ID Automobile Mannequin  Value ($)    Yr
0   101.0    Toyota    25000.0  2018.0
1     NaN     Honda    30000.0  2019.0
2   103.0       BMW        NaN  2017.0
3   104.0  Mercedes    40000.0  2020.0
4   105.0     Tesla    45000.0     NaN

Jetzt sehen wir, dass der Datenrahmen fehlende Werte und inkonsistente Spaltennamen enthält. Wir können dies lösen, indem wir Operationen sequenziell ausführen, wie zum Beispiel clean_names(), rename_column()Und, dropna()usw. in mehreren Zeilen. Alternativ können wir diese Methoden miteinander verketten – additionally mehrere Operationen in einer einzigen Zeile ausführen – für einen flüssigeren Workflow und saubereren Code.

# Chain strategies to scrub column names, drop rows with lacking values, choose particular columns, and rename columns
cleaned_cars_df = (
  cars_df
  .clean_names()  # Clear column names
  .dropna()  # Drop rows with lacking values
  .select_columns(('car_id', 'car_model', 'worth')) #Choose columns
  .rename_column('worth', 'price_usd')  # Rename column
)

print("Vehicles Information After Making use of Technique Chaining:")
print(cleaned_cars_df)

Ausgabe:

Vehicles Information After Making use of Technique Chaining:
   car_id car_model  price_usd 
0   101.0    Toyota  25000 
3   104.0  Mercedes  40000  

In dieser Pipeline wurden die folgenden Vorgänge ausgeführt:

• clean_names() Funktion bereinigt die Spaltennamen.
• dropna() Funktion löscht die Zeilen mit fehlenden Werten.
• select_columns() Die Funktion wählt die spezifischen Spalten „car_id“, „car_model“ und „worth“ aus.
• rename_column() Die Funktion benennt die Spalte „Preis“ in „Preis_USD“ um.

Einpacken

Zusammenfassend erweist sich Pyjanitor als magische Bibliothek für jeden, der mit Daten arbeitet. Es bietet viel mehr Funktionen als in diesem Artikel besprochen, wie z. B. das Kodieren kategorialer Variablen, das Abrufen von Merkmalen und Beschriftungen, das Identifizieren doppelter Zeilen und vieles mehr. Alle diese erweiterten Funktionen und Methoden können in seinem Dokumentation. Je tiefer Sie in die Funktionen eintauchen, desto mehr werden Sie von der leistungsstarken Funktionalität überrascht sein. Und schließlich: Viel Spaß beim Bearbeiten Ihrer Daten mit Pyjanitor.

Kanwal Mehreen Kanwal ist Ingenieurin für maschinelles Lernen und technische Autorin mit einer großen 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 Variety 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.

Bild vom Autor

Pandas ist die am häufigsten verwendete Python-Bibliothek für die Datenanalyse und -bearbeitung. Die Daten, die Sie aus der Quelle lesen, erfordern jedoch häufig eine Reihe von Datenbereinigungsschritten – bevor Sie sie analysieren können, um Erkenntnisse zu gewinnen, Geschäftsfragen zu beantworten oder Modelle für maschinelles Lernen zu erstellen.

Dieser Leitfaden unterteilt den Prozess der Datenbereinigung mit Pandas in 7 praktische Schritte. Wir erstellen einen Beispieldatensatz und arbeiten die Schritte zur Datenbereinigung durch.

Lass uns anfangen!

Hochfahren eines Beispiel-DataFrames

Hyperlink zum Colab Pocket book

Bevor wir mit den eigentlichen Datenbereinigungsschritten beginnen, erstellen wir einen Pandas-Datenrahmen mit Mitarbeiterdatensätzen. Wir verwenden Faker zur Generierung synthetischer Daten. Installieren Sie es additionally zuerst:

Wenn Sie möchten, können Sie dasselbe Beispiel nachmachen. Sie können auch einen Datensatz Ihrer Wahl verwenden. Hier ist der Code zum Generieren von 1000 Datensätzen:

import pandas as pd
from faker import Faker
import random

# Initialize Faker to generate artificial knowledge
pretend = Faker()

# Set seed for reproducibility
Faker.seed(42)

# Generate artificial knowledge
knowledge = ()
for _ in vary(1000):
    knowledge.append({
        'Title': pretend.identify(),
        'Age': random.randint(18, 70),
        'E mail': pretend.e mail(),
        'Telephone': pretend.phone_number(),
        'Deal with': pretend.handle(),
        'Wage': random.randint(20000, 150000),
        'Join_Date': pretend.date_this_decade(),
        'Employment_Status': random.selection(('Full-Time', 'Half-Time', 'Contract')),
        'Division': random.selection(('IT', 'Engineering','Finance', 'HR', 'Advertising'))
    })

Lassen Sie uns diesen Datenrahmen ein wenig optimieren, um fehlende Werte, doppelte Datensätze, Ausreißer und mehr einzuführen:

# Let's tweak the information a bit!
# Introduce lacking values
for i in random.pattern(vary(len(knowledge)), 50):
    knowledge(i)('E mail') = None

# Introduce duplicate information
knowledge.prolong(random.pattern(knowledge, 100))

# Introduce outliers
for i in random.pattern(vary(len(knowledge)), 20):
    knowledge(i)('Wage') = random.randint(200000, 500000)

Erstellen wir nun einen Datenrahmen mit diesen Datensätzen:

# Create dataframe
df = pd.DataFrame(knowledge)

Beachten Sie, dass wir den Seed für Faker und nicht für das Zufallsmodul festlegen. Die von Ihnen generierten Datensätze sind daher teilweise zufällig.

Schritt 1: Die Daten verstehen

Schritt 0 besteht immer darin, die geschäftliche Frage/das geschäftliche Drawback zu verstehen, das Sie lösen möchten. Sobald Sie das wissen, können Sie mit den Daten arbeiten, die Sie in Ihren Pandas-Datenrahmen eingelesen haben.

Bevor Sie jedoch irgendetwas Sinnvolles mit dem Datensatz machen können, ist es wichtig, sich zunächst einen allgemeinen Überblick über den Datensatz zu verschaffen. Dazu gehört, einige grundlegende Informationen zu den verschiedenen Feldern und der Gesamtzahl der Datensätze zu erhalten, den Kopf des Datenrahmens zu überprüfen und dergleichen.

Hier führen wir die data() Methode im Datenrahmen:

Output >>>

RangeIndex: 1100 entries, 0 to 1099
Knowledge columns (whole 9 columns):
 #   Column             Non-Null Rely  Dtype 
---  ------             --------------  ----- 
 0   Title               1100 non-null   object
 1   Age                1100 non-null   int64 
 2   E mail              1047 non-null   object
 3   Telephone              1100 non-null   object
 4   Deal with            1100 non-null   object
 5   Wage             1100 non-null   int64 
 6   Join_Date          1100 non-null   object
 7   Employment_Status  1100 non-null   object
 8   Division         1100 non-null   object
dtypes: int64(2), object(7)
reminiscence utilization: 77.5+ KB

Und untersuchen Sie den Kopf des Datenrahmens:

Ausgabe von df.head()

Schritt 2: Umgang mit Duplikaten

Doppelte Datensätze sind ein häufiges Drawback, das die Analyseergebnisse verfälscht. Daher sollten wir alle doppelten Datensätze identifizieren und entfernen, damit wir nur mit den eindeutigen Datensätzen arbeiten.

So finden wir alle Duplikate im Datenrahmen und löschen dann alle Duplikate an Ort und Stelle:

# Test for duplicate rows
duplicates = df.duplicated().sum()
print("Variety of duplicate rows:", duplicates)

# Eradicating duplicate rows
df.drop_duplicates(inplace=True)

Output >>>
Variety of duplicate rows: 100

Schritt 3: Umgang mit fehlenden Daten

Fehlende Daten sind ein häufiges Datenqualitätsproblem in vielen Knowledge Science-Projekten. Wenn Sie einen kurzen Blick auf das Ergebnis der data() Methode aus dem vorherigen Schritt sollten Sie sehen, dass die Anzahl der nicht-null-Objekte nicht für alle Felder identisch ist und dass in der E-Mail-Spalte Werte fehlen. Wir erhalten trotzdem die genaue Anzahl.

Um die Anzahl der fehlenden Werte in jeder Spalte zu ermitteln, können Sie Folgendes ausführen:

# Test for lacking values
missing_values = df.isna().sum()
print("Lacking Values:")
print(missing_values)

Output >>>
Lacking Values:
Title                  0
Age                   0
E mail                50
Telephone                 0
Deal with               0
Wage                0
Join_Date             0
Employment_Status     0
Division            0
dtype: int64

Wenn in einer oder mehreren numerischen Spalten Werte fehlen, können wir geeignete Imputationstechniken anwenden. Da das Feld „E-Mail“ fehlt, setzen wir die fehlenden E-Mails einfach wie folgt auf eine Platzhalter-E-Mail:

# Dealing with lacking values by filling with a placeholder
df('E mail').fillna('unknown@instance.com', inplace=True)

Schritt 4: Daten transformieren

Wenn Sie am Datensatz arbeiten, kann es sein, dass ein oder mehrere Felder nicht den erwarteten Datentyp haben. In unserem Beispieldatenrahmen muss das Feld „Join_Date“ in ein gültiges Datums-/Uhrzeitobjekt umgewandelt werden:

# Convert 'Join_Date' to datetime
df('Join_Date') = pd.to_datetime(df('Join_Date'))
print("Join_Date after conversion:")
print(df('Join_Date').head())

Output >>>
Join_Date after conversion:
0   2023-07-12
1   2020-12-31
2   2024-05-09
3   2021-01-19
4   2023-10-04
Title: Join_Date, dtype: datetime64(ns)

Da wir über das Eintrittsdatum verfügen, ist es eigentlich hilfreicher, eine Spalte „Beschäftigungsjahre“ zu haben, wie gezeigt:

# Creating a brand new characteristic 'Years_Employed' primarily based on 'Join_Date'
df('Years_Employed') = pd.Timestamp.now().yr - df('Join_Date').dt.yr
print("New characteristic 'Years_Employed':")
print(df(('Join_Date', 'Years_Employed')).head())

Output >>>
New characteristic 'Years_Employed':
   Join_Date  Years_Employed
0 2023-07-12               1
1 2020-12-31               4
2 2024-05-09               0
3 2021-01-19               3
4 2023-10-04               1

Schritt 5: Textdaten bereinigen

Es kommt häufig vor, dass Zeichenfolgenfelder inkonsistent formatiert sind oder ähnliche Probleme aufweisen. Das Bereinigen von Textual content kann so einfach sein wie das Anwenden einer Groß-/Kleinschreibung oder so schwierig wie das Schreiben eines komplexen regulären Ausdrucks, um die Zeichenfolge in das erforderliche Format zu bringen.

In unserem Beispieldatenrahmen sehen wir, dass die Spalte „Adresse“ viele „n“-Zeichen enthält, die die Lesbarkeit beeinträchtigen. Ersetzen wir sie additionally durch Leerzeichen wie folgt:

# Clear handle strings
df('Deal with') = df('Deal with').str.substitute('n', ' ', regex=False)
print("Deal with after textual content cleansing:")
print(df('Deal with').head())

Output >>>
Deal with after textual content cleansing:
0    79402 Peterson Drives Apt. 511 Davisstad, PA 35172
1     55341 Amanda Gardens Apt. 764 Lake Mark, WI 07832
2                 710 Eric Property Carlsonfurt, MS 78605
3                 809 Burns Creek Natashaport, IA 08093
4    8713 Caleb Brooks Apt. 930 Lake Crystalbury, CA...
Title: Deal with, dtype: object

Schritt 6: Umgang mit Ausreißern

Wenn Sie wieder nach oben scrollen, sehen Sie, dass wir einige Werte in der Spalte „Gehalt“ extrem hoch angesetzt haben. Solche Ausreißer sollten ebenfalls identifiziert und entsprechend behandelt werden, damit sie die Analyse nicht verfälschen.

Sie werden oft berücksichtigen wollen Was macht einen Datenpunkt zu einem Ausreißer (wenn es sich um eine falsche Dateneingabe handelt oder wenn es sich tatsächlich um gültige Werte und nicht um Ausreißer handelt). Sie können dann entscheiden, wie Sie damit umgehen: Datensätze mit Ausreißern löschen oder die Teilmenge der Zeilen mit Ausreißern abrufen und separat analysieren.

Verwenden wir den Z-Rating und ermitteln wir die Gehaltswerte, die mehr als drei Standardabweichungen vom Mittelwert abweichen:

# Detecting outliers utilizing z-score
z_scores = (df('Wage') - df('Wage').imply()) / df('Wage').std()
outliers = df(abs(z_scores) > 3)
print("Outliers primarily based on Wage:")
print(outliers(('Title', 'Wage')).head())

Output >>>
Outliers primarily based on Wage:
                Title  Wage
16    Michael Powell  414854
131    Holly Jimenez  258727
240  Daniel Williams  371500
328    Walter Bishop  332554
352     Ashley Munoz  278539

Schritt 7: Daten zusammenführen

In den meisten Projekten können die Daten, die Sie haben, nicht sind die Daten, die Sie für die Analyse verwenden möchten. Sie müssen die relevantesten Felder finden und auch Daten aus anderen Datenrahmen zusammenführen, um nützlichere Daten zu erhalten, die Sie für die Analyse verwenden können.

Erstellen Sie als schnelle Übung einen weiteren zugehörigen Datenrahmen und führen Sie ihn mit dem vorhandenen Datenrahmen in einer gemeinsamen Spalte zusammen, sodass die Zusammenführung sinnvoll ist. Das Zusammenführen in Pandas funktioniert sehr ähnlich wie Joins in SQL, daher schlage ich vor, dass Sie das als Übung ausprobieren!

Einpacken

Das ist alles für dieses Tutorial! Wir haben einen Beispieldatenrahmen mit Datensätzen erstellt und die verschiedenen Schritte zur Datenbereinigung durchgearbeitet. Hier ist eine Übersicht über die Schritte: Verstehen der Daten, Umgang mit Duplikaten, fehlenden Werten, Transformieren von Daten, Bereinigen von Textdaten, Umgang mit Ausreißern und Zusammenführen von Daten.

Wenn Sie alles über Knowledge Wrangling mit Pandas erfahren möchten, schauen Sie sich an 7 Schritte zum Meistern der Datenbereinigung mit Pandas und Python.

Bala Priya C ist Entwicklerin und technische Redakteurin aus Indien. Sie arbeitet gerne an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessens- und Fachgebiete umfassen DevOps, Datenwissenschaft und natürliche Sprachverarbeitung. Sie liest, schreibt, programmiert und trinkt gerne Kaffee! Derzeit arbeitet sie daran, ihr Wissen zu lernen und mit der Entwickler-Group zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt auch ansprechende Ressourcenübersichten und Programmier-Tutorials.