Fundamentos del Data Management con Databricks
Gestión Avanzada de Big Data con Databricks y Delta Lake
Fundamentos de Databricks para Big Data y Machine Learning
Arquitectura de Clústeres en Databricks: Procesamiento y Almacenamiento
Uso de Apache Spark en Big Data: Procesamiento y Análisis
Quiz: Fundamentos del Data Management con Databricks
Administración y Gestion de la Plataforma de Databricks
Creación y Configuración de Clúster en Databricks
Gestión de Datos y Notebooks en Databricks File System
Transformaciones y Acciones en Apache Spark
Conceptos básicos de RDDs en Apache Spark
Creación y Transformaciones de RDDs en Databricks
Acciones en Apache Spark: Uso y Ejemplos Prácticos
Lectura de Datos en Apache Spark con Databricks
Exploración de SparkUI en Databricks: Monitorización y Configuración
Instalación de Librerías en Databricks paso a paso
Alternativas para Trabajar con Apache Spark: Local vs. Nube
Quiz: Administración y Gestion de la Plataforma de Databricks
Apache Spark SQL y UDF
Lectura y escritura de DataFrames en Apache Spark
Comandos en Apache Spark SQL: Uso Práctico y Ejemplos
Consultas y Filtrado Avanzado con Spark SQL
Creación y Uso de Funciones UDF en Apache Spark
Quiz: Apache Spark SQL y UDF
Implementacion de un Delta Lake en Databricks
Arquitecturas Data Lake y Delta Lake en Big Data
Delta Lake: Almacenamiento y Gestión de Datos en Big Data
Arquitectura Medallion en Data Lake House: Capas Bronze, Silver y Gold
Comandos Esenciales para Databricks File System (DBFS)
Implementación de arquitectura Delta Lake en Databricks
Arquitectura Delta Lake: Creación de Capas Bronce, Silver y Gold
Gestión de Datos Avanzada con Databricks y Delta Lake
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Creación y Uso de Funciones UDF en Apache Spark
18/25Recursos
¿Qué son las UDF en Apache Spark y por qué son importantes?
Dentro del mundo de Apache Spark, las UDF (User Defined Functions) juegan un rol esencial al permitir a los usuarios definir sus propias funciones personalizadas que pueden ejecutarse de manera distribuida en todos los nodos de un clúster. Esto destaca porque Spark ya ofrece funciones nativas poderosas como map, filter y flatMap. Sin embargo, el poder registrar una UDF permite a los usuarios realizar transformaciones específicas que no son posibles con las funciones nativas.
¿Cómo se crea una UDF en Apache Spark?
Para crear una UDF en Apache Spark, el primer paso es definir tu función en el lenguaje de programación que estés usando, como Python. El proceso es similar al de cualquier función estándar, pero con la capacidad añadida de ejecutarse en paralelo. Aquí tienes un ejemplo básico de cómo se define una UDF utilizando Python:
def determinar_nivel_salario(salario):
level = None
if salario > 5000:
level = "High salary"
elif salario > 2000:
level = "Medium salary"
elif salario > 0:
level = "Low salary"
else:
level = "Invalid salary"
return level
Una vez que la función está definida, se registra como una UDF dentro de Spark. Esta función definida por el usuario ahora puede ejecutarse de manera distribuida, permitiendo clasificar salarios dentro de un DataFrame.
¿Cómo registrar y aplicar una UDF en un DataFrame?
Después de definir la función, el siguiente paso es registrarla como una UDF. El registro debe indicar el tipo de datos que la función va a devolver, lo que permite que Spark la integre eficazmente en sus procesos.
from pyspark.sql.functions import udf
from pyspark.sql.types import StringType
udfDeterminarNivelSalario = udf(determinar_nivel_salario, StringType())
Finalmente, aplicas esta UDF al DataFrame. En este ejemplo, se añade una nueva columna "nivel de salario" que categoriza el salario de cada fila:
df_con_nivel = df.withColumn("nivel_de_salario", udfDeterminarNivelSalario(df["salario"]))
df_con_nivel.show()
Esta abstracción muestra cómo las UDF permiten manejar tareas de clasificación o transformación que no existen de forma nativa en Spark, adaptándose a necesidades específicas del negocio.
Beneficios y mejores prácticas al usar UDF en Apache Spark
Entre los numerosos beneficios que ofrecen las UDF, destaca la capacidad de adaptabilidad y personalización en contextos complejos de procesamiento de datos. Aquí algunas recomendaciones para su uso:
- Flexibilidad y Personalización: La creación de funciones personalizadas te permite realizar tareas específicas que las funciones nativas de Spark no cubren.
- Ejecución Paralela: Aprovecha la capacidad de Spark para ejecutar la UDF en todos los nodos del clúster, asegurando así un procesamiento rápido y eficiente.
- Buenas Prácticas: Siempre etiqueta correctamente tus funciones y sus retornos para facilitar su lectura y mantenimiento. Usar prefijos como
udfal nombrar tus funciones puede ayudarte a identificar rápidamente este tipo de funciones personalizadas.
Apache Spark, junto con UDF, ofrece un entorno robusto para manejar grandes volúmenes de datos de manera eficiente. Experimenta con la creación de tus propias UDF para mejorar la manera en que manejas datos complejos e impulsa tus habilidades en ciencia de datos al siguiente nivel.
Aportes 9
Preguntas 3
Ordenar por:
En Apache Spark, una **UDF (User Defined Function)** es una función definida por el usuario que puedes utilizar para realizar transformaciones personalizadas en los datos. Las UDF permiten aplicar lógica compleja a columnas de un DataFrame que no está disponible con las funciones integradas de Spark.
### Características principales de las UDF:
1. **Personalización**: Permiten agregar lógica específica del negocio.
2. **Compatibilidad**: Se pueden usar con diferentes lenguajes como Python, Scala, Java y R.
3. **Desempeño**: Las UDF pueden ser más lentas que las funciones integradas de Spark porque se ejecutan en el intérprete del lenguaje (por ejemplo, Python) y no están optimizadas para la ejecución distribuida.
### 1. Crear una UDF en Python
Puedes registrar una función personalizada como una UDF y usarla en transformaciones.
#### Paso 1: Importar las funciones necesarias
from pyspark.sql.functions import udf
from pyspark.sql.types import StringType, IntegerType
#### Paso 2: Definir la función personalizada
\# Función Python normal
def categorize\_salary(salary):
if salary < 5000:
return "Low"
elif salary <= 8000:
return "Medium"
else:
return "High"
#### Paso 3: Registrar la función como UDF
categorize\_salary\_udf = udf(categorize\_salary, StringType())
#### Paso 4: Aplicar la UDF al DataFrame
data = \[
(1, "Alice", 4000),
(2, "Bob", 5000),
(3, "Charlie", 9000),
]
columns = \["id", "name", "salary"]
df = spark.createDataFrame(data, columns)
\# Usar la UDF para transformar los datos
df = df.withColumn("salary\_category", categorize\_salary\_udf(df\["salary"]))
df.show()
**Salida esperada:**
+---+-------+------+---------------+
| id| name|salary|salary\_category|
+---+-------+------+---------------+
| 1| Alice| 4000| Low|
| 2| Bob| 5000| Medium|
| 3|Charlie| 9000| High|
+---+-------+------+---------------+
### 2. UDF con SQL
Puedes registrar una UDF y usarla en consultas SQL.
\# Registrar la UDF en el contexto SQL
spark.udf.register("categorize\_salary", categorize\_salary, StringType())
\# Registrar la tabla temporal
df.createOrReplaceTempView("employees")
\# Ejecutar una consulta SQL con la UDF
result = spark.sql("SELECT id, name, salary, categorize\_salary(salary) AS salary\_category FROM employees")
result.show()
### 3. Tipos de datos soportados
Cuando defines una UDF, necesitas especificar el tipo de dato de salida usando las clases de `pyspark.sql.types`:
* **StringType**: Para cadenas.
* **IntegerType**: Para enteros.
* **DoubleType**: Para números decimales.
* **ArrayType**: Para listas o arreglos.
* **StructType**: Para estructuras anidadas.
Ejemplo con un tipo complejo:
from pyspark.sql.types import ArrayType
def split\_name(name):
return name.split(" ")
split\_name\_udf = udf(split\_name, ArrayType(StringType()))
df = df.withColumn("name\_parts", split\_name\_udf(df\["name"]))
df.show()
### 4. Consideraciones de rendimiento
* **Uso de funciones integradas**: Siempre que sea posible, usa las funciones integradas de Spark en lugar de UDF, ya que están optimizadas para la ejecución distribuida.
* **Vectorización con Pandas UDF**: Para mejorar el rendimiento, puedes usar Pandas UDFs, que están optimizadas para operaciones vectorizadas y aprovechan mejor los recursos de Spark.
Ejemplo de Pandas UDF:
from pyspark.sql.functions import pandas\_udf
from pyspark.sql.types import StringType
@pandas\_udf(StringType())
def categorize\_salary\_pandas(salary\_series):
return salary\_series.apply(categorize\_salary)
df = df.withColumn("salary\_category", categorize\_salary\_pandas(df\["salary"]))
Les comparto mis resultados:
Saludos.
```python
# Databricks notebook source
# Importacion de las librerias y los utilitarios
from pyspark.sql.types import *
from datetime import datetime
import math
# COMMAND ----------
# Definición de una variable
PARAM_NUMERO = 10
# Crear un DataFrame de ejemplo solo números
data_numeros = [(1,), (2,), (3,), (4,)]
columns = ["numero"]
df = spark.createDataFrame(data_numeros, columns)
# Crear un DataFrame de ejemplo solo texto
data_texto = [("Hola",), ("Mundo",), ("Databricks",), (None,)]
columns = ["cadena"]
df_texto = spark.createDataFrame(data_texto, columns)
# COMMAND ----------
# MAGIC %md
# MAGIC ### Ejercicio 1 cuadrado (UDF)
# COMMAND ----------
# Definir la función para calcular el cuadrado
def cuadrado(numero):
return numero ** 2
# COMMAND ----------
# Registro de la funcion: udf_calcular_cuadrado como UDF
udf_cuadrado = udf(cuadrado, LongType())
# COMMAND ----------
#Aplicación de la UDF
df_con_cuadrado = df.withColumn("cuadrado", udf_cuadrado(df["numero"]))
# Mostrar los resultados
df_con_cuadrado.show()
# COMMAND ----------
# MAGIC %md
# MAGIC ### Ejercicio 2 longitud (UDF)
# COMMAND ----------
# Definir la función para calcular la longitud de una cadena
def longitud(cadena):
return len(cadena) if cadena else 0
# COMMAND ----------
# Registrar la función como un UDF
udf_longitud = udf(longitud, LongType())
# COMMAND ----------
# Aplicar la UDF al DataFrame
df_con_longitud = df_texto.withColumn("longitud", udf_longitud(df_texto["cadena"]))
# Mostrar los resultados
df_con_longitud.show()
# COMMAND ----------
# MAGIC %md
# MAGIC ### Ejercicio 3 es_par (UDF)
# COMMAND ----------
# Definir la función para saber si un número es par
def es_par(numero):
if numero % 2 == 0:
return True
return False
# COMMAND ----------
# Registrar la función como un UDF
udf_es_par = udf(es_par, BooleanType())
# COMMAND ----------
#Aplicación de la UDF
print(df)
df_con_paridad = df.withColumn("cuadrado", udf_es_par (df["numero"]))
# Mostrar los resultados
df_con_paridad .show()
# COMMAND ----------
# MAGIC %md
# MAGIC ### Ejercicio 4 revertir (UDF)
# COMMAND ----------
# Definir la función para revertir una cadena de texto
def revertir(cadena):
if cadena is None:
return None
return "".join(reversed(cadena))
# COMMAND ----------
# Registrar la función como UDF
udf_revertir = udf(revertir, StringType())
# COMMAND ----------
# Aplicar la UDF al DataFrame
df_texto_revertido = df_texto.withColumn("revertir", udf_revertir(df_texto["cadena"]))
# Mostrar Resultados
df_texto_revertido.show()
# COMMAND ----------
# MAGIC %md
# MAGIC ### Ejercicio 5 sumar_elementos (UDF)
# COMMAND ----------
# Definir función para sumar elementos
def sumar_elementos(lista_numeros):
return sum(lista_numeros)
# COMMAND ----------
# Crear un DataFrame donde cada fila contiene listas de números
data_lista_numeros = [([1, 3],), ([2, 5],), ([3, 9],), ([4, 4],)]
columns = ["lista_numeros"]
df_lista_numeros = spark.createDataFrame(data_lista_numeros, columns)
# COMMAND ----------
# Registrar la función cómo UDF
udf_sumar_elementos = udf(sumar_elementos, LongType())
# COMMAND ----------
# Aplicar la UDF al DataFrame
df_suma = df_lista_numeros.withColumn("suma", udf_sumar_elementos(df_lista_numeros['lista_numeros']))
# Mostrar resultados
df_suma.show()
# COMMAND ----------
# MAGIC %md
# MAGIC ### Ejercicio 6 calcular_area_circulo (UDF)
# COMMAND ----------
# Definir función para calcular el area de un circulo
def calcular_area_circulo(radio):
return math.pi * radio ** 2
# COMMAND ----------
# Registrar la función cómo UDF
udf_calcular_area_circulo = udf(calcular_area_circulo, DoubleType())
# COMMAND ----------
# Aplicar la UDF al DataFrame
df_area = df.withColumn("area", calcular_area_circulo(df['numero']))
# Mostrar resultados
df_area.show()
# COMMAND ----------
# MAGIC %md
# MAGIC ### Ejercicio 7 convertir_mayusculas (UDF)
# COMMAND ----------
# Definir función convertir una cadena a mayúsculas
def convertir_mayusculas(cadena):
if cadena is None:
return None
return (cadena.upper())
# COMMAND ----------
# Registrar la función cómo UDF
udf_convertir_mayusculas = udf(convertir_mayusculas, StringType())
# COMMAND ----------
# Aplicar la UDF al DataFrame
df_area = df_texto.withColumn("texto", udf_convertir_mayusculas(df_texto['cadena']))
# Mostrar resultados
df_area.show()
# COMMAND ----------
# MAGIC %md
# MAGIC ### Ejercicio 8 calcular_edad (UDF)
# COMMAND ----------
# Definir función para calcular la edad (Por defecto dejamos el año en el 2023 si no envían uno)
def calcular_edad(fecha_nacimiento_str, anio_actual=2023):
fecha_nacimiento = datetime.strptime(fecha_nacimiento_str, "%Y-%m-%d")
fecha_actual = datetime(anio_actual, datetime.now().month, datetime.now().day)
edad = fecha_actual.year - fecha_nacimiento.year
if (fecha_actual.month < fecha_nacimiento.month or
(fecha_actual.month == fecha_nacimiento.month and fecha_actual.day < fecha_nacimiento.day)):
edad -= 1
return edad
# COMMAND ----------
# Registrar la función cómo UDF
udf_calcular_edad = udf(calcular_edad, IntegerType());
# COMMAND ----------
# Crear un DataFrame donde cada fila contiene listas de números
data_personas = [("Juan", "1980-01-01",), ("Pedro", "1988-12-11",)]
columns = ["name", "fecha_nacimiento"]
df_personas = spark.createDataFrame(data_personas, columns)
# COMMAND ----------
#Aplicacion de la udf
df_personas_con_edad = df_personas.withColumn("edad", udf_calcular_edad("fecha_nacimiento"))
df_personas_con_edad.show()
# COMMAND ----------
# MAGIC %md
# MAGIC ### Ejercicio 9 es_vocal (UDF)
# COMMAND ----------
# Definir función para saber si una letra es una vocal
def es_vocal(letra):
vocal = False
if letra.lower() in ['a', 'e', 'i', 'o', 'u']:
vocal = True
return vocal
# COMMAND ----------
# Crear un DataFrame con letas
data_letras = [("a",), ("b",), ("c",), ("e",), ("f",)]
columns = ["letras", ]
df_letras = spark.createDataFrame(data_letras, columns)
# COMMAND ----------
# Registrar la función cómo UDF
udf_es_vocal = udf(es_vocal, BooleanType())
# COMMAND ----------
#Aplicacion de la udf
df_personas_con_edad = df_letras.withColumn("letra", udf_es_vocal("letras"))
df_personas_con_edad.show()
```# Databricks notebook source
\# Importacion de las librerias y los utilitarios
from pyspark.sql.types import \*
from datetime import datetime
import math
\# COMMAND ----------
\# Definición de una variable
PARAM\_NUMERO = 10
\# Crear un DataFrame de ejemplo solo números
data\_numeros = \[(1,), (2,), (3,), (4,)]
columns = \["numero"]
df = spark.createDataFrame(data\_numeros, columns)
\# Crear un DataFrame de ejemplo solo texto
data\_texto = \[("Hola",), ("Mundo",), ("Databricks",), (None,)]
columns = \["cadena"]
df\_texto = spark.createDataFrame(data\_texto, columns)
\# COMMAND ----------
\# MAGIC %md
\# MAGIC ### Ejercicio 1 cuadrado (UDF)
\# COMMAND ----------
\# Definir la función para calcular el cuadrado
def cuadrado(numero):
return numero \*\* 2
\# COMMAND ----------
\# Registro de la funcion: udf\_calcular\_cuadrado como UDF
udf\_cuadrado = udf(cuadrado, LongType())
\# COMMAND ----------
\#Aplicación de la UDF
df\_con\_cuadrado = df.withColumn("cuadrado", udf\_cuadrado(df\["numero"]))
\# Mostrar los resultados
df\_con\_cuadrado.show()
\# COMMAND ----------
\# MAGIC %md
\# MAGIC ### Ejercicio 2 longitud (UDF)
\# COMMAND ----------
\# Definir la función para calcular la longitud de una cadena
def longitud(cadena):
return len(cadena) if cadena else 0
\# COMMAND ----------
\# Registrar la función como un UDF
udf\_longitud = udf(longitud, LongType())
\# COMMAND ----------
\# Aplicar la UDF al DataFrame
df\_con\_longitud = df\_texto.withColumn("longitud", udf\_longitud(df\_texto\["cadena"]))
\# Mostrar los resultados
df\_con\_longitud.show()
\# COMMAND ----------
\# MAGIC %md
\# MAGIC ### Ejercicio 3 es\_par (UDF)
\# COMMAND ----------
\# Definir la función para saber si un número es par
def es\_par(numero):
if numero % 2 == 0:
return True
return False
\# COMMAND ----------
\# Registrar la función como un UDF
udf\_es\_par = udf(es\_par, BooleanType())
\# COMMAND ----------
\#Aplicación de la UDF
print(df)
df\_con\_paridad = df.withColumn("cuadrado", udf\_es\_par (df\["numero"]))
\# Mostrar los resultados
df\_con\_paridad .show()
\# COMMAND ----------
\# MAGIC %md
\# MAGIC ### Ejercicio 4 revertir (UDF)
\# COMMAND ----------
\# Definir la función para revertir una cadena de texto
def revertir(cadena):
if cadena is None:
return None
return "".join(reversed(cadena))
\# COMMAND ----------
\# Registrar la función como UDF
udf\_revertir = udf(revertir, StringType())
\# COMMAND ----------
\# Aplicar la UDF al DataFrame
df\_texto\_revertido = df\_texto.withColumn("revertir", udf\_revertir(df\_texto\["cadena"]))
\# Mostrar Resultados
df\_texto\_revertido.show()
\# COMMAND ----------
\# MAGIC %md
\# MAGIC ### Ejercicio 5 sumar\_elementos (UDF)
\# COMMAND ----------
\# Definir función para sumar elementos
def sumar\_elementos(lista\_numeros):
return sum(lista\_numeros)
\# COMMAND ----------
\# Crear un DataFrame donde cada fila contiene listas de números
data\_lista\_numeros = \[(\[1, 3],), (\[2, 5],), (\[3, 9],), (\[4, 4],)]
columns = \["lista\_numeros"]
df\_lista\_numeros = spark.createDataFrame(data\_lista\_numeros, columns)
\# COMMAND ----------
\# Registrar la función cómo UDF
udf\_sumar\_elementos = udf(sumar\_elementos, LongType())
\# COMMAND ----------
\# Aplicar la UDF al DataFrame
df\_suma = df\_lista\_numeros.withColumn("suma", udf\_sumar\_elementos(df\_lista\_numeros\['lista\_numeros']))
\# Mostrar resultados
df\_suma.show()
\# COMMAND ----------
\# MAGIC %md
\# MAGIC ### Ejercicio 6 calcular\_area\_circulo (UDF)
\# COMMAND ----------
\# Definir función para calcular el area de un circulo
def calcular\_area\_circulo(radio):
return math.pi \* radio \*\* 2
\# COMMAND ----------
\# Registrar la función cómo UDF
udf\_calcular\_area\_circulo = udf(calcular\_area\_circulo, DoubleType())
\# COMMAND ----------
\# Aplicar la UDF al DataFrame
df\_area = df.withColumn("area", calcular\_area\_circulo(df\['numero']))
\# Mostrar resultados
df\_area.show()
\# COMMAND ----------
\# MAGIC %md
\# MAGIC ### Ejercicio 7 convertir\_mayusculas (UDF)
\# COMMAND ----------
\# Definir función convertir una cadena a mayúsculas
def convertir\_mayusculas(cadena):
if cadena is None:
return None
return (cadena.upper())
\# COMMAND ----------
\# Registrar la función cómo UDF
udf\_convertir\_mayusculas = udf(convertir\_mayusculas, StringType())
\# COMMAND ----------
\# Aplicar la UDF al DataFrame
df\_area = df\_texto.withColumn("texto", udf\_convertir\_mayusculas(df\_texto\['cadena']))
\# Mostrar resultados
df\_area.show()
\# COMMAND ----------
\# MAGIC %md
\# MAGIC ### Ejercicio 8 calcular\_edad (UDF)
\# COMMAND ----------
\# Definir función para calcular la edad (Por defecto dejamos el año en el 2023 si no envían uno)
def calcular\_edad(fecha\_nacimiento\_str, anio\_actual=2023):
fecha\_nacimiento = datetime.strptime(fecha\_nacimiento\_str, "%Y-%m-%d")
fecha\_actual = datetime(anio\_actual, datetime.now().month, datetime.now().day)
edad = fecha\_actual.year - fecha\_nacimiento.year
if (fecha\_actual.month < fecha\_nacimiento.month or
(fecha\_actual.month == fecha\_nacimiento.month and fecha\_actual.day < fecha\_nacimiento.day)):
edad -= 1
return edad
\# COMMAND ----------
\# Registrar la función cómo UDF
udf\_calcular\_edad = udf(calcular\_edad, IntegerType());
\# COMMAND ----------
\# Crear un DataFrame donde cada fila contiene listas de números
data\_personas = \[("Juan", "1980-01-01",), ("Pedro", "1988-12-11",)]
columns = \["name", "fecha\_nacimiento"]
df\_personas = spark.createDataFrame(data\_personas, columns)
\# COMMAND ----------
\#Aplicacion de la udf
df\_personas\_con\_edad = df\_personas.withColumn("edad", udf\_calcular\_edad("fecha\_nacimiento"))
df\_personas\_con\_edad.show()
\# COMMAND ----------
\# MAGIC %md
\# MAGIC ### Ejercicio 9 es\_vocal (UDF)
\# COMMAND ----------
\# Definir función para saber si una letra es una vocal
def es\_vocal(letra):
vocal = False
if letra.lower() in \['a', 'e', 'i', 'o', 'u']:
vocal = True
return vocal
\# COMMAND ----------
\# Crear un DataFrame con letas
data\_letras = \[("a",), ("b",), ("c",), ("e",), ("f",)]
columns = \["letras", ]
df\_letras = spark.createDataFrame(data\_letras, columns)
\# COMMAND ----------
\# Registrar la función cómo UDF
udf\_es\_vocal = udf(es\_vocal, BooleanType())
\# COMMAND ----------
\#Aplicacion de la udf
df\_personas\_con\_edad = df\_letras.withColumn("letra", udf\_es\_vocal("letras"))
df\_personas\_con\_edad.show()
Esta clase al igual que las demás está excelente, me está gustando mucho este curso! Estas funciones UDF dan mucha libertad a la hora de trabajar el código.
```python
# Pregunta 1
spark.sql("""
SELECT P.*
FROM personas P
WHERE edad > 28
""").show()
#Pregunta 2
f.createOrReplaceTempView("personas_all")
spark.sql("""
SELECT
P.nombre,
mean(p.edad) as avr_age
FROM personas_all P
GROUP BY nombre
""").show()
Pregunta 3
spark.sql("""
SELECT
P.nombre, P.edad, D.direccion
FROM personas_all as P
LEFT JOIN (SELECT * FROM direcciones) as D ON P.id = D.id
where direccion is not NULL
""").show()
```
Aquí mis respuestas (son válidas por 6 meses a partir de hoy 2024-04-03):
<https://databricks-prod-cloudfront.cloud.databricks.com/public/4027ec902e239c93eaaa8714f173bcfc/2644977103371408/2135980205045190/8714880492900796/latest.html>
En el examen se pregunta
"Cual es proposito principal de las UDF" y la respuesta "correcta" es: "*Filtrar datos en un DataFrame según un criterio personalizado*" lo cual no es correcto, este **NO** es su principal proposito.
Su principal proposito, como su nombre lo dice, es permitir la creacion de funciones personalizadas que no estan cubiertas por las funciones estandar.
Algunos ejemplos que cree
<https://github.com/jggomez/spark-demo>
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?