Anaconda Code

​

Initializing Anaconda Code

​

Understanding Anaconda Code

​

Running code

1. From Home, click , then select a cell where you want to insert your code.
   If you’re already in the code editor, select more next to the active code cell reference, then Add New to create a new code cell.
   Subsequent code cells will be in the same language as the previously created one. To change the language, first create a new code cell, then change the code cell’s language selection in the code editor.
2. Set the cell linking and output options.
3. Select Python or R as the code language for the cell.
   If you change the language for the cell to a language you haven’t yet used, you might need to click Load Environment to load the new language’s environment for the first time.
4. Enter your code in the code editor.
5. (Optional) If you want to reference a range of data from your spreadsheet or an Anaconda Code object in your code, click REF, then select the range of cells or Anaconda Code cell.
   Using the REF function

   When you use REF to select data cells or Anaconda Code cells, Anaconda Code creates a REF function in your code that returns a list of lists. The Imports and Definitions tab includes the following pre-defined functions to help convert the returned list of lists to different data structures.

   • Python
   • R

   Function	Use case	Notes
   to_df(REF(<CELL_RANGE>))	Create a DataFrame	to_df assumes your data has headers
   to_array(REF(<CELL_RANGE>))	Create a NumPy array	to_array assumes all data is of the same type
   to_list(REF(<CELL_RANGE>))	Create a 1D list	to_list handles wide (1 x n) or tall (n x 1) data

   You can change the behavior of to_df(), to_array(), and to_list() from the Imports and Definitions tab.
6. Click Run. The cell will display the return value of the last evaluated expression. Your changes are automatically saved whenever you re-run the code.
   If you write code that doesn’t have a return value (for example, you define a function but don’t call the function) and click Run, the cell will display </>NoneType.

​

Editing code

1. From the Home page, click more on the code you want to edit.
2. Click Edit in full view to open the edit view.
3. Adjust your code, then click Run.

​

Managing the environment

​

Choosing a Pyodide or WebR version

1. From the Environment tab, click Edit.
2. Select the Pyodide or WebR version.
3. Click Save Changes.

​

Managing software packages

1. From the Environment tab, click Edit.
2. To add new packages, click Add.
3. (Optional for Python) Click the down arrow to add from either PyPI, the PyScript app, or a direct download link to a Python wheel (.whl).
4. Search for the package name, then click Add beside the package you want to add.
5. Once you’ve added all the packages you want to include, click Add Packages.

​

Customizing code initialization

​

Creating user-defined functions

UDFs in Python

Creating and calling a UDF

1. From the Imports and Definitions tab, decorate a function with @UDF, as shown in the following example:
   Python UDF Example

   Report incorrect code

   Copy

   Ask AI

   @UDF
   def my_custom_function(x, y):
       return x ** y
   

2. Click Apply.
3. In an open cell, enter =ANACONDA. If you added the example above to your definitions list, the option to call ANACONDA.MY_CUSTOM_FUNCTION appears in the dropdown.
   
4. Arrow down to ANACONDA.MY_CUSTOM_FUNCTION, press Tab, and then complete the function.
5. Use Ctrl+Enter (Windows)/Ctrl+Return (macOS) to run the code.

If you’d prefer the UDF uses a name other than the function name, use the name argument to provide a unique name. Set nested to False to remove ANACONDA. from the name.

Renaming Python UDF Example

Report incorrect code

Copy

Ask AI

@UDF(name="MYBANK.PORTFOLIO_ANALYSIS", nested=False)
def my_custom_function(x, y):
    return x ** y

Using range argumentsSpecifying a UDF.Range argument tells Excel that the input of the function is a 2D range. Without specifying this, Excel will show a #CALC! Unliftable Array error if a 2D range is passed into the UDF. Parameters specified as UDF.Range will always be passed as a 2D array to the function, even if a single cell is passed in.Example usage of UDF.Range:

Python Range Example

Report incorrect code

Copy

Ask AI

@UDF
def square_me(data: UDF.Range) -> UDF.Range:
    return [[val ** 2 for val in row] for row in data]

You can also add type hints for ranges. For example,UDF.Range[str].

UDFs in R

Creating and calling a UDF

1. From the Imports and Definitions tab, register the UDF with UDF.register() and pass the function as an argument, as shown in the following example:
   The UDF must be registered after the function is defined.
   R UDF Example

   Report incorrect code

   Copy

   Ask AI

   my_custom_r_function <- function(x, y) {
       x ^ y
   }
   UDF.register(my_custom_r_function)
   

2. Click Save and Apply.
3. In an open cell, enter =ANACONDA. If you added the example above to your definitions list, the option to call ANACONDA.MY_CUSTOM_R_FUNCTION appears in the dropdown.
   
4. Arrow down to ANACONDA.MY_CUSTOM_R_FUNCTION, press Tab, and then complete the function call.
5. Use Ctrl+Enter (Windows)/Ctrl+Return (macOS) to run the code.

If you’d prefer the UDF uses a name other than the function name, register the function with the UDF, then use the name argument to provide a unique name and set nested to False to remove ANACONDA. from the name.

Renaming R UDF Example

Report incorrect code

Copy

Ask AI

my_custom_r_function <- function(x, y) {
    x ^ y
}
UDF.register(my_custom_r_function, name="MYBANK.PORTFOLIO_ANALYSIS", nested=FALSE)

Using range argumentsSetting the range_args parameter tells Excel that the input of the function is a 2D range. Without specifying this, Excel will show a #CALC! Unliftable Array error if a 2D range is passed into the UDF. Parameters specified as range_args will always be passed as a 2D array to the function, even if a single cell is passed in.Example usage of range_args:

R Range Example

Report incorrect code

Copy

Ask AI

my_custom_r_function <- function(data) {
    sum(data)
}
UDF.register(my_custom_r_function, range_args=c("data"))

Adding function documentationTo add documentation to your function, use the doc parameter:

R Documentation Example

Report incorrect code

Copy

Ask AI

my_custom_r_function <- function(x, y) {
    x ^ y
}
UDF.register(my_custom_r_function, doc="Computes x raised to the power of y.")

​

Modifying workbook settings

​

Cell linking

Run Isolated

When a code cell is run in isolated mode, its code runs independently of other cells. Variables defined within an isolated code cell can’t be referenced by other code cells, and variables in other code cells likewise can’t be referenced by the isolated code cell.

In the above image, the output_of_B2 variable is defined in cell B2 and assigned the string "I'm the B2 cell!". When this code is run in the B2 code cell, the B2 cell displays "I'm the B2 cell!". However, since both cells are running in isolated mode, when output_of_B2 is referenced in the B4 code cell, the B4 cell displays a #VALUE! error because B4 cannot access the variable in B2.Using the REF functionYou can bypass isolation rules as needed using the REF function to create a reference from one isolated code cell to another.

In the above image, the B4 cell now includes a reference to the B2 cell, REF("B2"). When the B4 code cell is run, it returns the value of B2, "I'm the B2 cell!". Changes to the B4 cell don’t cause the B2 cell to recalculate, but changes to the B2 cell will cause the B4 cell to recalculate. Code cells can include multiple REF function references, and changes to any referenced cells (in this example, B2) will cause the referencing cells to recalculate (in this example, B4).Working with code objectsIf you reference a cell that’s set to output a code object, the REF function will return an instance of that object in the referencing cell.

In the above image, the B2 code cell is set to output a code object (in this case, a list). Because the output of B2 is a non-scalar value, we see </> list in B2. In the B4 code cell, we define a variable called output_of_B2 and assign a REF function that references cell B2. The output mode for the B4 code cell is set to “Excel Values”, so the list spills across multiple cells in the spreadsheet.Benefits of isolated modeThe benefit of using the isolated mode is that referenced cells are not recalculated when changes are made to referencing cells. For complex processes, this allows you to:

• separate code that doesn’t change frequently from code you modify often.
• reduce unnecessary recalculations of computationally intensive operations.
• create a more modular approach to your data analysis.
• improve performance when working with larger datasets.

Run Linked

When a code cell is run in linked mode, variables defined within it can be accessed by any other code cell also running in linked mode. When any linked mode cell is recalculated, all linked mode cells are recalculated. Linked cells run left-to-right, top-to-bottom, and can access objects defined in previously linked cells.

In the above image, both the B2 and B4 cell are running in linked mode. The output_of_B2 variable is defined in cell B2 and assigned the string "I'm the B2 cell!". When this code is run in the B2 code cell, the B2 cell displays "I'm the B2 cell!". The output_of_B2 variable is then referenced in the B4 code cell, causing the B4 cell to also display "I'm the B2 cell!".Benefits of linked modeLinked mode is useful when:

• you want to create a continuous workflow across multiple cells.
• you need to share variables and objects between different parts of your analysis.
• your code follows a linear execution path.

​

Cell output

​

Troubleshooting

​

Error installing functions