Handledning: Operator för beräkning av sammansatt ränta

I den här självstudien skapar du en Python UDF-operator för Lakeflow Designer som beräknar sammansatt ränta. Använd det här exemplet om du vill lära dig grunderna i att skapa operatorer som transformerar enskilda värden eller kolumner. Mer information finns i Användardefinierade operatorer i Lakeflow Designer.

Overview

Den här självstudien beskriver hur du skapar en användardefinierad operator med hjälp av en Python UDF. Operatorn beräknar det framtida värdet för en investering med hjälp av formeln för sammansatt ränta, , A = P × (1 + r/n)^(n×t)där:

P = Principal (startbelopp)
r = Årlig ränta (som decimal)
n = Antal sammansatta perioder per år
t = Tid i år

Steg 1: Skriva och testa funktionen Python

Definiera först kärnfunktionen Python som utför beräkningen. Testa den i en notebook-cell för att se till att den fungerar korrekt.

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)

Testa funktionen med en exempelinvestering: 1 000 dollar med en årlig ränta på 5%, räntat månadsvis under 10 år. Resultatet bör vara ungefär 1647.01.

compound_amount(1000, 0.05, 12, 10)

Steg 2: Skapa YAML för operatorn

YAML-konfigurationen definierar hur operatorn visas i Lakeflow Designer. För den här operatorn:

Principal använder en expression-widget så att användare kan välja en kolumn i sina data
Årstakt, Föreningar per år och År använder number widgetar med standardvärden och begränsningar
Operatorn har en indataport som tillhandahåller kolumndata för uttrycksparametern

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

Mer information om alla tillgängliga egenskaper, datatyper, widgetar och alternativ finns i YAML-referens för användardefinierad operatör .

Steg 3: Skapa funktionen Unity Catalog

Kombinera YAML-schemat och funktionen Python till en enda CREATE FUNCTION-instruktion. YAML-konfigurationen finns i dokumentsträngen i början av funktionstexten.

Exemplet skapar funktionen i main.example_output. Skapa schemat först om det inte finns:

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)
$$

Steg 4: Testa funktionen

Testa UC-funktionen direkt med SQL. Dessa frågor kontrollerar tre scenarier:

$1 000 till 5 % ränta som kapitaliseras månadsvis i 10 år, vilket ger cirka 1647.01
1 000 dollar vid 5% sammansatts årligen under ett år, vilket ger avkastning 1050.00
1 000 dollar med 15 % ränta, beräknad månadsvis i 1 år, vilket ger ungefär 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);

Steg 5: Registrera operatorn

Lägg till operatorn i din .user_defined_operators.yaml-fil:

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

Note

Om du definierar den här filen i användarmappen visas den bara för dig. Mer information finns i Gör operatören identifierbar.

Steg 6: Konfigurera behörigheter

Bevilja åtkomst till användare som behöver använda den här operatorn:

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

Använda operatorn i Lakeflow Designer

När den har registrerats visas operatorn i Lakeflow Designer med:

En listruta för att välja huvudkolumnen från dina indata
Antal indata för frekvens, sammansatt frekvens och år (med lämpliga standardvärden)

Användare kan använda den här operatorn för att beräkna framtida värden för hela kolumner med investeringsdata.

Feedback

Var den här sidan till hjälp?

Uppdaterades senast 2026-10-09