Tutorial: Operador de calculadora de interés compuesto

En este tutorial, creará un operador de Python UDF para Lakeflow Designer que calcula el interés compuesto. Utilice este ejemplo para aprender los fundamentos de la creación de operadores que transforman valores individuales o columnas. Para más información, consulte Operadores definidos por el usuario en Lakeflow Designer.

Información general

Este tutorial le guiará a través de la creación de un operador definido por el usuario mediante un Python UDF. El operador calcula el valor futuro de una inversión mediante la fórmula de interés compuesta, A = P × (1 + r/n)^(n×t), donde:

P = Principal (importe inicial)
r = Tasa de interés anual (como decimal)
n = Número de períodos compuestos por año
t = Tiempo en años

Requirements

Acceso a Lakeflow Designer en un espacio de trabajo habilitado con Unity Catalog. Consulte Requisitos previos.
USE CATALOG en el main catálogo, y CREATE SCHEMA en main, o USE SCHEMA y CREATE FUNCTION en un esquema existente main.example_output . Para usar un catálogo o esquema diferente, reemplaza main.example_output en todas partes. Consulte Referencia de privilegios del catálogo de Unity.
Compute que pueda ejecutar UDFs de Python del catálogo de Unity. Consulte las funciones definidas por el usuario (UDFs) de SQL y Python en Unity Catalog.

Step 1: Escribir y probar la función Python

En primer lugar, defina la función principal de Python que realiza el cálculo. Pruóbelo en una celda del cuaderno para asegurarse de que funciona correctamente.

def compound_amount(principal: float,
                    annual_rate: float,
                    compounds_per_year: int,
                    years: float) -> float:
    """
    Compute compound interest future value.

    A = P * (1 + r/n)^(n*t)

    principal: starting amount (P)
    annual_rate: annual nominal rate as decimal (r), e.g. 0.05
    compounds_per_year: compounding periods per year (n), e.g. 12
    years: time in years (t), can be fractional
    """
    import math
    if principal is None or annual_rate is None or compounds_per_year is None or years is None:
        return None

    if compounds_per_year <= 0:
        raise ValueError("compounds_per_year must be > 0")

    return principal * math.pow(1.0 + annual_rate / compounds_per_year,
                                 compounds_per_year * years)

Pruebe la función con una inversión de ejemplo: 1.000 dólares, a un tipo de interés anual del 5 %, con capitalización mensual durante 10 años. El resultado debería ser aproximadamente 1647.01.

compound_amount(1000, 0.05, 12, 10)

Paso 2: Creación del código YAML para el operador

La configuración de YAML define cómo aparece el operador en Lakeflow Designer. Para este operador:

Principal usa un expression widget para que los usuarios seleccionen una columna de sus datos
Tasa anual, Compuestos por año y Años usan number widgets con valores predeterminados y restricciones
El operador tiene un puerto de entrada que proporciona datos de columna para el parámetro de expresión.

schema: user-defined-operator-v0.1.0
type: uc-udf
name: Compound Amount
id: finance.compound_amount
version: '1.0.0'
description: >
  Computes the future value of an investment using compound interest.
  Formula: A = P * (1 + r/n)^(n*t)
config:
  type: object
  properties:
    principal:
      type: string
      format: expression
      title: Principal
      examples:
        - 'Select principal column or expression'
      x-ui:
        widget: expression
        port: in
    annual_rate:
      type: number
      title: Annual rate (decimal)
      default: 0.05
      minimum: 0
      examples:
        - 'e.g. 0.05 for 5%'
      x-ui:
        widget: number
    compounds_per_year:
      type: number
      title: Compounds per year
      default: 12
      minimum: 1
      examples:
        - 'e.g. 12 for monthly'
      x-ui:
        widget: number
    years:
      type: number
      title: Years
      default: 10
      minimum: 0
      examples:
        - 'Time in years (t)'
      x-ui:
        widget: number
  required:
    - principal
    - annual_rate
    - compounds_per_year
    - years
  additionalProperties: false
ports:
  input:
    - name: in
      title: Input
  output:
    - name: out
      title: Output

Para todas las propiedades, tipos de datos, widgets y opciones disponibles, consulte Referencia YAML del operador definido por el usuario.

Paso 3: Crear la función catálogo de Unity

Combine el esquema YAML y la función Python en una sola instrucción CREATE FUNCTION. La configuración de YAML entra en la cadena docstring al principio del cuerpo de la función.

El ejemplo crea la función en main.example_output. Crea el esquema primero si no existe:

CREATE SCHEMA IF NOT EXISTS main.example_output

CREATE OR REPLACE FUNCTION main.example_output.compound_amount(
    principal DOUBLE,
    annual_rate DOUBLE,
    compounds_per_year INT,
    years FLOAT)
RETURNS DOUBLE
LANGUAGE PYTHON
AS $$
  """
  schema: user-defined-operator-v0.1.0
  type: uc-udf
  name: Compound Amount
  id: finance.compound_amount
  version: "1.0.0"
  description: >
    Computes the future value of an investment using compound interest.
    Formula: A = P * (1 + r/n)^(n*t)
  config:
    type: object
    properties:
      principal:
        type: string
        format: expression
        title: Principal
        examples:
          - "Select principal column or expression"
        x-ui:
          widget: expression
          port: in
      annual_rate:
        type: number
        title: Annual rate (decimal)
        default: 0.05
        minimum: 0
        examples:
          - "e.g. 0.05 for 5%"
        x-ui:
          widget: number
      compounds_per_year:
        type: number
        title: Compounds per year
        default: 12
        minimum: 1
        examples:
          - "e.g. 12 for monthly"
        x-ui:
          widget: number
      years:
        type: number
        title: Years
        default: 10
        minimum: 0
        examples:
          - "Time in years (t)"
        x-ui:
          widget: number
    required:
      - principal
      - annual_rate
      - compounds_per_year
      - years
    additionalProperties: false
  ports:
    input:
      - name: in
        title: Input
    output:
      - name: out
        title: Output
  """

  def compound_amount(principal: float,
                      annual_rate: float,
                      compounds_per_year: int,
                      years: float) -> float:
      import math
      if principal is None or annual_rate is None or compounds_per_year is None or years is None:
          return None

      if compounds_per_year <= 0:
          raise ValueError("compounds_per_year must be > 0")

      return principal * math.pow(1.0 + annual_rate / compounds_per_year,
                                   compounds_per_year * years)

  return compound_amount(principal, annual_rate, compounds_per_year, years)
$$

Paso 4: Probar la función

Prueba la función UC directamente con SQL. Estas consultas revisan tres situaciones:

1.000 dólares al 5 % con capitalización mensual durante 10 años, lo que genera aproximadamente 1647.01
$1,000 al 5 % con capitalización anual durante 1 año, lo que da 1050.00
1.000 dólares al 15 % con capitalización mensual durante 1 año, lo que da aproximadamente 1160.75

SELECT main.example_output.compound_amount(1000, 0.05, 12, 10);
SELECT main.example_output.compound_amount(1000, 0.05, 1, 1);
SELECT main.example_output.compound_amount(1000, 0.15, 12, 1);

Paso 5: Registrar el operador

Añada el operador a su archivo .user_defined_operators.yaml:

operators:
  - catalog: main
    schema: example_output
    functionName: compound_amount

Note

Si define este archivo en la carpeta de usuario, solo aparece para usted. Para más información, consulte Registrar y desplegar a su operador en Lakeflow Designer.

Paso 6: Configuración de permisos

Conceda acceso a los usuarios que necesitan usar este operador:

GRANT USE SCHEMA ON SCHEMA main.example_output TO `<user>`;
GRANT EXECUTE ON FUNCTION main.example_output.compound_amount TO `<user>`;

Paso 7: Utiliza el operador en Lakeflow Designer

En una preparación visual de datos, abre el menú de Operadores en el panel izquierdo y busca el operador Compound Amount.
Arrastra al operador sobre el lienzo y conecta una entrada a él.
Haz doble clic en el operador para abrir su panel de configuración y luego establece sus campos.
Selecciona el operador para previsualizar sus resultados en el panel de salida.

El panel de configuración del operador incluye:

Lista desplegable para seleccionar la columna principal de los datos de entrada
Entradas numéricas para velocidad, frecuencia compuesta y años (con valores predeterminados razonables)

Los usuarios pueden aplicar este operador para calcular valores futuros para columnas completas de datos de inversión.

Recursos adicionales

Comentarios

¿Le ha resultado útil esta página?

Se actualizó por última vez el 2026-10-22