Erste Schritte: Verbessern und Bereinigen von Daten

Artikel
09/30/2024

Dieser erste Artikel führt Sie durch die Verwendung eines Azure Databricks-Notebooks zum Bereinigen und Verbessern der New York State-Babynamendaten, die zuvor mithilfe von Python, Scala und R in eine Tabelle im Unity-Katalog geladen wurden. In diesem Artikel ändern Sie Spaltennamen, ändern Groß-/Kleinschreibung und geben das Geschlecht jedes Babynamens aus der Rohdatentabelle an, und speichern dann den DataFrame in einer silbernen Tabelle. Anschließend filtern Sie die Daten so, dass nur Daten für 2021 enthalten sind, gruppieren diese Daten auf Statusebene und sortieren die Daten dann nach Anzahl. Schließlich speichern Sie diesen DataFrame in einer Goldtabelle und visualisieren die Daten in einem Balkendiagramm. Weitere Informationen zu Silber- und Goldtabellen finden Sie in der Medallion-Architektur.

Wichtig

Dieser Artikel für die ersten Schritte baut auf Erste Schritte: Aufnehmen und Einfügen zusätzlicher Daten auf. Sie müssen die Schritte in dem Artikel abgeschlossen haben, um diesen Artikel ausführen zu können. Das vollständige Notebook für diesen Artikel mit den ersten Schritten finden Sie unter Aufnehmen zusätzlicher Datennotebooks.

Anforderungen

Um die Aufgaben in diesem Artikel abzuschließen, müssen die folgenden Anforderungen erfüllt sein:

Ihr Arbeitsbereich muss für Unity Catalog aktiviert sein. Weitere Informationen zu den ersten Schritten mit Unity Catalog finden Sie unter Einrichten und Verwalten von Unity Catalog.
Sie müssen das WRITE VOLUME-Recht für ein Volume, das USE SCHEMA-Recht für das übergeordnete Schema und das USE CATALOG-Recht für den übergeordneten Katalog haben.
Sie müssen über die Berechtigung verfügen, eine vorhandene Computeressource zu verwenden oder eine neue Computeressource zu erstellen. Siehe Erste Schritte mit Azure Databricks oder wenden Sie sich an Ihren Databricks-Administrator.

Tipp

Ein vollständiges Notebook für diesen Artikel finden Sie unter Bereinigen und Verbessern von Datennotebooks.

Schritt 1: Erstellen eines neuen Notebooks

Wenn Sie ein Notebook in Ihrem Arbeitsbereich erstellen möchten, wählen Sie in der Randleiste Neu aus, und wählen Sie dann Notebook aus. Im Arbeitsbereich wird ein leeres Notebook geöffnet.

Weitere Informationen zum Erstellen und Verwalten von Notebooks finden Sie unter Verwalten von Notebooks.

Schritt 2: Definieren von Variablen

In diesem Schritt definieren Sie Variablen für die Verwendung im Beispiel-Notebook, das Sie in diesem Artikel erstellen.

Kopieren Sie den folgenden Code, und fügen Sie ihn in die neue leere Notebookzelle ein. Ersetzen Sie <catalog-name>, <schema-name> und <volume-name> durch die Katalog-, Schema- und Volumenamen für ein Unity Catalog-Volume. Ersetzen Sie optional den table_name-Wert durch einen Tabellennamen Ihrer Wahl. Im weiteren Verlauf dieses Artikels speichern Sie die Babynamendaten in dieser Tabelle.

Drücken Sie Shift+Enter, um die Zelle auszuführen und eine neue leere Zelle zu erstellen.

Python

catalog = "<catalog_name>"
schema = "<schema_name>"
table_name = "baby_names"
silver_table_name = "baby_names_prepared"
gold_table_name = "top_baby_names_2021"
path_table = catalog + "." + schema
print(path_table) # Show the complete path

Scala

val catalog = "<catalog_name>"
val schema = "<schema_name>"
val tableName = "baby_names"
val silverTableName = "baby_names_prepared"
val goldTableName = "top_baby_names_2021"
val pathTable = s"${catalog}.${schema}"
print(pathTable) // Show the complete path

R

catalog <- "<catalog_name>"
schema <- "<schema_name>"
volume <- "<volume_name>"
table_name <- "baby_names"
silver_table_name <- "baby_names_prepared"
gold_table_name <- "top_baby_names_2021"
path_table <- paste(catalog, ".", schema, sep = "")
print(path_table) # Show the complete path

Schritt 3: Laden der Rohdaten in ein neues DataFrame

In diesem Schritt werden die zuvor in einer Delta-Tabelle gespeicherten Rohdaten in einen neuen DataFrame geladen, um diese Daten zur weiteren Analyse zu reinigen und zu verbessern.

Kopieren Sie den folgenden Code, und fügen Sie ihn in die neue leere Notebookzelle ein.

Python

df_raw = spark.read.table(f"{path_table}.{table_name}")
display(df_raw)

Scala

val dfRaw = spark.read.table(s"${pathTable}.${tableName}")
display(dfRaw)

R

# Load the SparkR package that is already preinstalled on the cluster.
library(SparkR)
df_raw = sql(paste0("SELECT * FROM ", path_table, ".", table_name))
display(df_raw)

Drücken Sie Shift+Enter, um die Zelle auszuführen, und wechseln Sie dann zur nächsten Zelle.

Schritt 4: Bereinigen und Verbessern von Rohdaten und Speichern

In diesem Schritt ändern Sie den Namen der Year-Spalte, ändern die Daten in der First_Name-Spalte in Anfangsbuchstaben, aktualisieren die Werte der Sex-Spalte auf die Schreibweise des Geschlechts und speichern dann den DataFrame in einer neuen Tabelle.

Kopieren Sie den folgenden Code, und fügen Sie ihn in eine leere Notebookzelle ein.

Python

from pyspark.sql.functions import col, initcap, when

# Rename "Year" column to "Year_Of_Birth"
df_rename_year = df_raw.withColumnRenamed("Year", "Year_Of_Birth")

# Change the case of "First_Name" column to initcap
df_init_caps = df_rename_year.withColumn("First_Name", initcap(col("First_Name").cast("string")))

# Update column values from "M" to "male" and "F" to "female"
df_baby_names_sex = df_init_caps.withColumn(
"Sex",
    when(col("Sex") == "M", "Male")
    .when(col("Sex") == "F", "Female")
)

# display
display(df_baby_names_sex)

# Save DataFrame to table
df_baby_names_sex.write.mode("overwrite").saveAsTable(f"{path_table}.{silver_table_name}")

Scala

import org.apache.spark.sql.functions.{col, initcap, when}

// Rename "Year" column to "Year_Of_Birth"
val dfRenameYear = dfRaw.withColumnRenamed("Year", "Year_Of_Birth")

// Change the case of "First_Name" data to initial caps
val dfNameInitCaps = dfRenameYear.withColumn("First_Name", initcap(col("First_Name").cast("string")))

// Update column values from "M" to "Male" and "F" to "Female"
val dfBabyNamesSex = dfNameInitCaps.withColumn("Sex",
    when(col("Sex") equalTo "M", "Male")
    .when(col("Sex") equalTo "F", "Female"))

// Display the data
display(dfBabyNamesSex)

// Save DataFrame to a table
dfBabyNamesSex.write.mode("overwrite").saveAsTable(s"${pathTable}.${silverTableName}")

R

# Rename "Year" column to "Year_Of_Birth"
df_rename_year <- withColumnRenamed(df_raw, "Year", "Year_Of_Birth")

# Change the case of "First_Name" data to initial caps
df_init_caps <- withColumn(df_rename_year, "First_Name", initcap(df_rename_year$First_Name))

# Update column values from "M" to "Male" and "F" to "Female"
df_baby_names_sex <- withColumn(df_init_caps, "Sex",
                                ifelse(df_init_caps$Sex == "M", "Male",
                                      ifelse(df_init_caps$Sex == "F", "Female", df_init_caps$Sex)))
# Display the data
display(df_baby_names_sex)

# Save DataFrame to a table
saveAsTable(df_baby_names_sex, paste(path_table, ".", silver_table_name), mode = "overwrite")

Drücken Sie Shift+Enter, um die Zelle auszuführen, und wechseln Sie dann zur nächsten Zelle.

Schritt 5: Gruppieren und Visualisieren von Daten

In diesem Schritt filtern Sie die Daten nur auf das Jahr 2021, gruppieren die Daten nach Geschlecht und Name, aggregieren nach Anzahl und sortieren nach Anzahl. Anschließend speichern Sie den DataFrame in einer Tabelle und visualisieren dann die Daten in einem Balkendiagramm.

Kopieren Sie den folgenden Code, und fügen Sie ihn in eine leere Notebookzelle ein.

Python

from pyspark.sql.functions import expr, sum, desc
from pyspark.sql import Window

# Count of names for entire state of New York by sex
df_baby_names_2021_grouped=(df_baby_names_sex
.filter(expr("Year_Of_Birth == 2021"))
.groupBy("Sex", "First_Name")
.agg(sum("Count").alias("Total_Count"))
.sort(desc("Total_Count")))

# Display data
display(df_baby_names_2021_grouped)

# Save DataFrame to a table
df_baby_names_2021_grouped.write.mode("overwrite").saveAsTable(f"{path_table}.{gold_table_name}")

Scala

import org.apache.spark.sql.functions.{expr, sum, desc}
import org.apache.spark.sql.expressions.Window

// Count of male and female names for entire state of New York by sex
val dfBabyNames2021Grouped = dfBabyNamesSex
  .filter(expr("Year_Of_Birth == 2021"))
  .groupBy("Sex", "First_Name")
  .agg(sum("Count").alias("Total_Count"))
  .sort(desc("Total_Count"))

// Display data
display(dfBabyNames2021Grouped)

// Save DataFrame to a table
dfBabyNames2021Grouped.write.mode("overwrite").saveAsTable(s"${pathTable}.${goldTableName}")

R

# Filter to only 2021 data
df_baby_names_2021 <- filter(df_baby_names_sex, df_baby_names_sex$Year_Of_Birth == 2021)

# Count of names for entire state of New York by sex
df_baby_names_grouped <- agg(
  groupBy(df_baby_names_2021, df_baby_names_2021$Sex, df_baby_names_2021$First_Name),
  Total_Count = sum(df_baby_names_2021$Count)
)
# Display data
display(arrange(select(df_baby_names_grouped, df_baby_names_grouped$Sex, df_baby_names_grouped$First_Name, df_baby_names_grouped$Total_Count), desc(df_baby_names_grouped$Total_Count)))

# Save DataFrame to a table
saveAsTable(df_baby_names_2021_grouped, paste(path_table, ".", gold_table_name), mode = "overwrite")

Drücken Sie Ctrl+Enter, um die Zelle auszuführen.
1. Klicken Sie neben der Registerkarte Tabelle auf + und klicken Sie dann auf Visualisierung.
Klicken Sie im Visualisierungs-Editor auf Visualisierungstyp und stellen Sie sicher, dass Balken ausgewählt ist.
Wählen Sie in der X-Spalte die Option First_Name aus.
Klicken Sie auf Spalte hinzufügen unter Y-Spalten und wählen Sie dann Total_Count aus.
Wählen Sie unter Gruppieren nach die Option Geschlecht aus.
Klicken Sie auf Speichern.

Bereinigen und Verbessern von Datennotebooks

Verwenden Sie eines der folgenden Notebooks, um die Schritte in diesem Artikel auszuführen. Ersetzen Sie <catalog-name>, <schema-name> und <volume-name> durch die Katalog-, Schema- und Volumenamen für ein Unity Catalog-Volume. Ersetzen Sie optional den table_name-Wert durch einen Tabellennamen Ihrer Wahl.

Freigeben über

Erste Schritte: Verbessern und Bereinigen von Daten

Anforderungen

Schritt 1: Erstellen eines neuen Notebooks

Schritt 2: Definieren von Variablen

Python

Scala

R

Schritt 3: Laden der Rohdaten in ein neues DataFrame

Python

Scala

R

Schritt 4: Bereinigen und Verbessern von Rohdaten und Speichern

Python

Scala

R

Schritt 5: Gruppieren und Visualisieren von Daten

Python

Scala

R

Bereinigen und Verbessern von Datennotebooks

Python

Bereinigen und Verbessern von Daten mithilfe von Python

Scala

Bereinigen und Verbessern von Daten mithilfe von Scala

R

Bereinigen und Verbessern von Daten mithilfe von R

Zusätzliche Ressourcen

Feedback

Zusätzliche Ressourcen