Ler em inglês

Compartilhar via

Introdução: Aprimorar e limpar dados

  • Artigo

Este artigo de introdução guia você pelo uso de um notebook do Azure Databricks para limpar e melhorar os dados de nomes de bebês do Estado de Nova York que foram previamente carregados em uma tabela no Catálogo do Unity, usando Python, Scala e R. Neste artigo, você alterará os nomes das colunas, alterará a capitalização e escreverá por extenso o sexo de cada nome de bebê a partir da tabela de dados brutos, e então salvará o DataFrame em uma tabela prata. Em seguida, você filtrará os dados para incluir somente os dados de 2021, agrupará os dados em nível estadual e classificará os dados por contagem. Por fim, você salvará esse DataFrame em uma tabela ouro e visualizará os dados em um gráfico de barras. Para obter mais informações sobre tabelas Prata e Ouro, consulte arquitetura de medalhão.

Importante

Este artigo de introdução baseia-se em Iniciar: Ingerir e inserir dados adicionais. Você deve concluir as etapas desse artigo para concluir esse artigo. Para obter o notebook completo desse artigo de introdução, consulte Ingestão de notebooks de dados adicionais.

Requisitos

Para concluir as tarefas neste artigo, você deve atender aos seguintes requisitos:

  • Seu espaço de trabalho deve ter o Catálogo do Unity habilitado. Para obter informações sobre como começar a usar o Catálogo do Unity, consulte Configurar e gerenciar o Catálogo do Unity.
  • O usuário também deve ter o privilégio WRITE VOLUME em um volume, o privilégio USE SCHEMA no esquema pai e o privilégio USE CATALOG no catálogo pai.
  • Você deve ter permissão para usar um recurso de computação existente ou criar um recurso de computação. Consulte Comece a usar o Azure Databricks ou consulte o administrador do Azure Databricks.

Dica

Para obter um notebook completo para esse artigo, consulte Limpar e aprimorar notebooks de dados.

Etapa 1: Criar um notebook

Para criar um bloco de notas na sua área de trabalho, clique em ícone NovoNovo na barra lateral e, em seguida, clique em Notebook. Um notebook em branco é aberto no workspace.

Para saber mais sobre como criar e gerenciar notebooks, consulte Gerenciar notebooks.

Etapa 2: definir variáveis

Nesta etapa, você definirá variáveis para uso no notebook de exemplo criado neste artigo.

  1. Copie e cole o código a seguir na nova célula vazia do notebook. Substitua <catalog-name>, <schema-name> e <volume-name> pelos nomes do catálogo, esquema e volume de um volume do Catálogo do Unity. Opcionalmente, substitua o valor table_name por um nome de tabela à sua escolha. Você salvará os dados do nome do bebê nesta tabela mais adiante neste artigo.

  2. Pressione Shift+Enter para executar a célula e criar uma nova célula em branco.

    Python

    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

    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

    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

Etapa 3: Carregar os dados brutos em um novo DataFrame

Esta etapa carrega os dados brutos salvos anteriormente em uma tabela Delta em um novo DataFrame, em preparação para a limpeza e o aprimoramento desses dados para análise posterior.

  1. Copie e cole o código a seguir na nova célula vazia do notebook.

    Python

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

    Scala

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

    R

    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. Pressione Shift+Enter para executar a célula e depois vá para a próxima célula.

Etapa 4: Limpar e aprimorar os dados brutos e salvar

Nesta etapa, você alterará o nome da coluna Year, alterará os dados na coluna First_Name para iniciais maiúsculas, atualizará os valores da coluna Sex para escrever o sexo por extenso, e então salvará o DataFrame em uma nova tabela.

  1. Copie e cole o código a seguir em uma célula vazia do notebook.

    Python

    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

    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

    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. Pressione Shift+Enter para executar a célula e depois vá para a próxima célula.

Etapa 5: Agrupar e visualizar dados

Nesta etapa, você filtrará os dados para o ano de 2021, agrupará os dados por sexo e nome, agregará pela contagem e ordenará pela contagem. Em seguida, você salvará o DataFrame em uma tabela e visualizará os dados em um gráfico de barras.

  1. Copie e cole o código a seguir em uma célula vazia do notebook.

    Python

    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

    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

    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. Pressione Ctrl+Enter para executar a célula.

    1. Ao lado da guia Tabela, clique + e, em seguida, clique em Visualização.

  4. No editor de visualização, clique em Tipo de visualização e verifique se Barra está selecionado.

  5. Na coluna X, selecioneFirst_Name.

  6. Clique em Adicionar coluna abaixo das Colunas Y e selecione Total_Count.

  7. Em Agrupar por, selecione Sexo.

    tabela ouro

  8. Clique em Save (Salvar).

Limpar e aprimorar notebooks de dados

Use um dos notebooks a seguir para seguir as etapas desse artigo. Substitua <catalog-name>, <schema-name> e <volume-name> pelos nomes do catálogo, esquema e volume de um volume do Catálogo do Unity. Opcionalmente, substitua o valor table_name por um nome de tabela à sua escolha.

Python

Limpar e aprimorar dados usando Python

Obter notebook

Scala

Limpar e aprimorar dados usando Scala

Obter notebook

R

Limpar e aprimorar dados usando R

Obter notebook

Recursos adicionais