Freigeben über


Erste Schritte: Verbessern und Bereinigen von Daten

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 Neues SymbolNeu 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.

  1. 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.

  2. 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.

  1. 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)
    
  2. 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.

  1. 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")
    
  2. 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.

  1. 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")
    
  2. Drücken Sie Ctrl+Enter, um die Zelle auszuführen.

    1. Klicken Sie neben der Registerkarte Tabelle auf + und klicken Sie dann auf Visualisierung.
  3. Klicken Sie im Visualisierungs-Editor auf Visualisierungstyp und stellen Sie sicher, dass Balken ausgewählt ist.

  4. Wählen Sie in der X-Spalte die Option First_Name aus.

  5. Klicken Sie auf Spalte hinzufügen unter Y-Spalten und wählen Sie dann Total_Count aus.

  6. Wählen Sie unter Gruppieren nach die Option Geschlecht aus.

    Goldtabelle

  7. 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.

Python

Bereinigen und Verbessern von Daten mithilfe von Python

Notebook abrufen

Scala

Bereinigen und Verbessern von Daten mithilfe von Scala

Notebook abrufen

R

Bereinigen und Verbessern von Daten mithilfe von R

Notebook abrufen

Zusätzliche Ressourcen