Teradata Package for Python Function Reference - 17.00 - Derive - Teradata Package for Python

Teradata® Package for Python Function Reference

Product
Teradata Package for Python
Release Number
17.00
Release Date
April 2021
Content Type
Programming Reference
Publication ID
B700-4008-070K
Language
English (United States)
teradataml.analytics.Transformations.Derive.__init__ = __init__(self, formula, columns, out_column, datatype=None, fillna=None)
DESCRIPTION:
    The Derive transformation requires the free-form transformation be specified
    as a formula using the following operators, arguments, and functions:
        +, -, **, *, /, %, (, ), x, y, z, abs, exp, ln, log, sqrt
    The arguments x, y, and z can only assume the value of an input column.
    An implied multiply operator is automatically inserted when a number, argument
    (x, y, z), or parenthesis is immediately followed by an argument or parenthesis.
    For example,
        4x means 4*x, xy means x*y, and x(x+1) is equivalent to x*(x+1).
 
    An example formula for the quadratic equation is below.
        formula="(-y+sqrt(y**2-4xz))/(2x)"
 
    Note:
        Output of this function is passed to "derive" argument of "Transform"
        function from Vantage Analytic Library.
 
PARAMETERS:
    formula:
        Required Argument.
        Specifies the free-form transformation required for Derive.
        Arithmetic formula can be specified as string using following operators,
        arguments, and functions:
            +, -, **, *, /, %, (, ), x, y, z, abs, exp, ln, log, sqrt
        Types: str
 
    columns:
        Required Argument.
        Specifies the names of the columns to use for formula.
        Types: str or list of str
 
    out_column:
        Required Argument.
        Specifies the name of the output column.
        Types: str
 
    datatype:
        Optional Argument.
        Specifies the name of the intended datatype of the output column.
        Intended data types for the output column can be specified using the
        permitted strings below:
         -------------------------------------------------------------------
        | If intended SQL Data Type is  | Permitted Value to be passed is   |
        |-------------------------------------------------------------------|
        | bigint                        | bigint                            |
        | byteint                       | byteint                           |
        | char(n)                       | char,n                            |
        | date                          | date                              |
        | decimal(m,n)                  | decimal,m,n                       |
        | float                         | float                             |
        | integer                       | integer                           |
        | number(*)                     | number                            |
        | number(n)                     | number,n                          |
        | number(*,n)                   | number,*,n                        |
        | number(n,n)                   | number,n,n                        |
        | smallint                      | smallint                          |
        | time(p)                       | time,p                            |
        | timestamp(p)                  | timestamp,p                       |
        | varchar(n)                    | varchar,n                         |
        --------------------------------------------------------------------
        Notes:
            1. Argument is ignored if "columns" argument is not used.
            2. char without a size is not supported.
            3. number(*) does not include the * in its datatype format.
        Examples:
            1. If intended datatype for the output column is "bigint", then
               pass string "bigint" to the argument as shown below:
               datatype="bigint"
            2. If intended datatype for the output column is "decimal(3,5)", then
               pass string "decimal,3,5" to the argument as shown below:
               datatype="decimal,3,5"
        Types: str
 
    fillna:
        Optional Argument.
        Specifies whether the null replacement/missing value treatment should
        be performed with derive or not. Output of FillNa() can be passed to
        this argument.
        Note:
            If the FillNa object is created with its arguments "columns",
            "out_columns" and "datatype", then values passed in FillNa() arguments
            are ignored. Only nullstyle information is captured from the same.
        Types: FillNa
 
RETURNS:
    An instance of Derive class.
 
RAISES:
    TeradataMlException, TypeError, ValueError
 
EXAMPLE:
    # Note:
    #   To run any tranformation, user needs to use Transform() function.
    #   To do so import valib first and set the "val_install_location".
    >>> from teradataml import configure, DataFrame, Derive, FillNa, load_example_data, valib
    >>> configure.val_install_location = "SYSLIB"
    >>>
 
    # Load example data.
    >>> load_example_data("dataframe", "sales")
    >>>
 
    # Create the required DataFrame.
    >>> sales = DataFrame("sales")
    >>> sales
                  Feb    Jan    Mar    Apr    datetime
    accounts
    Blue Inc     90.0   50.0   95.0  101.0  04/01/2017
    Alpha Co    210.0  200.0  215.0  250.0  04/01/2017
    Jones LLC   200.0  150.0  140.0  180.0  04/01/2017
    Yellow Inc   90.0    NaN    NaN    NaN  04/01/2017
    Orange Inc  210.0    NaN    NaN  250.0  04/01/2017
    Red Inc     200.0  150.0  140.0    NaN  04/01/2017
    >>>
 
    # Example: Includes multiple derive transformations.
    # Derive transformation 1 is done with 3 variables, x, y, z, to calculate
    # the total sales for the first quarter for each account.
    >>> fn_1 = FillNa(style='literal', value=0)
    >>> dr_1 = Derive(formula="x+y+z", columns=["Jan", "Feb", "Mar"],
    ...               out_column="q1_sales", fillna=fn_1)
    >>>
 
    # Derive transformation 2 is done with 2 variables, x, y, to calculate
    # the sale growth from the month of Jan to Feb.
    >>> fn_2 = FillNa(style='median')
    >>> dr_2 = Derive(formula="((y-x)/x)*100", columns=["Jan", "Feb"],
    ...               out_column="feb_growth", fillna=fn_2, datatype='bigint')
    >>>
 
    # Perform the derive transformation using Transform() function
    # from Vantage Analytic Library.
    >>> obj = valib.Transform(data=sales, derive=[dr_1, dr_2], key_columns="accounts")
    >>> obj.result
         accounts  q1_sales  feb_growth
    0    Alpha Co     625.0           4
    1     Red Inc     490.0          33
    2  Orange Inc       NaN          40
    3   Jones LLC     490.0          33
    4  Yellow Inc       NaN         -40
    5    Blue Inc     235.0          79
    >>>