The expression node allows executing a single line of python code and return its value. The node can have multiple typed inputs which can be used as variables in the python expression. The inputs can’t be defined in the node itself because the space is reserved to the variable name representing the input.


One of the simplest uses of this node is computing long mathematical equations. For instance, if one wants to compute the value of the polynomial 5x^3+3x^2+1 at some x one would have to add six nodes for multiplication, power and addition. Alternatively, one could just write that in an expression node as follows.


Advanced Node Settings

  • Modules - Importing python modules is done by writing their names with comma as a separator. For instance, if one wants to use numpy and math modules, one would write numpy, math.
  • Debug Mode - If enabled, any errors will be caught and displayed in the node. If disabled, any error in the expression will cause a fatal error stopping the execution of the node tree. It should be noted that enabling debug mode slows down execution.
  • Correct Type - If enabled, the node will attempt to convert the output to the required output type. If disabled, if the type output is different from the output type, the node will cause a fatal error stopping the execution of the node tree.
  • Inline Expression - By default, modules are star imported and their attributes can be used directly. If this option is enabled, modules are normally imported and their attributes have to be preceded by the module name. For instance, in order to use the argpartition function from numpy one would write numpy.argpartition instead of argpartition. Enabling this option improves performance by avoiding start importing.
  • Fixed Data Type - If disabled, the node will automatically change the type of the output socket based on what it gets connected to. If enabled, the type is fixed and doesn’t automatically change, in which case, the type can be defined using the gear button in the node.

Python Inline Expressions

One is limited to a single line of code when using the expression node. Luckily, Python provides some features like conditional operators and list comprehensions that can provide a feature rich inline environment. Below, we shall explore some of these features for comprehensiveness.

Condition Operator

The conditional operator takes the form:

a if condition else b

Where a, condition and b are all expressions. First, condition expression is evaluated, if its value was evaluated to be True, a is evaluated and its value is returned, otherwise, b is evaluated and its value is returned. Some examples:

# Return the absolute value of a.
a if a > 0 else -a
# Return vectorA if its magnitude is bigger than that of vectorB.
# And return vectorB otherwise.
vectorA if vectorA.length > vectorB.length else vectorB

It should be noted that the last expression can be another conditional operator resulting in a chained conditional operator that is analogous to elif in If statements.

a if condition else b if anotherCondition else c

Which means, a is evaluated and returned if condition is True, otherwise, b is evaluated and returned if anotherCondition is True, otherwise (When both condition are not True), c is evaluated and returned. This can, of course, be extended by chaining more conditional operators.

List Comprehension

List comprehensions provides a robust way for creating lists. It takes the form:

[a for e in list]

Where a is an expression possibly containing e which is the value of the elements of the list which can be any iterable. e is just a local variable in the scope of the comprehension and can have whatever name you choose. The comprehension loop over every element of list, assign the value of the element to e and append the value of a to an initially empty list, this list is the value of the list comprehension. For a given list l = [0, 1, 2, 3, 4].

[x + 10 for x in l]
# Returns [10, 11, 12, 13, 14]
[y**2 for y in l]
# Returns [0, 1, 4, 9, 16]

Note that the expression needn’t depend on the iterable at all. For instance.

# Create a list of five elements which are all zeros.
[0 for _ in range(5)]
# Returns [0, 0, 0, 0, 0]

List comprehensions can have conditions, that is, a condition that has to be met for the element to be appended. For instance, for some list g = [5, -6, -7, 8, 9].

# Return only positive elements.
[x for x in g if x > 0]
# Returns [5, 8, 9]

zip() function can be used when multiple iterables are needed. For instance, for a=[0, 1, 2, 3, 4] b=[1, 2, -1, 0, -2].

# To sum a and b element wise.
[x + y for x, y in zip(a, b)]
# Returns [1, 3, 1, 3, 2]

Multiple for can be used to repeat lists as follows. Notice how order matters in this case. The latter for is always executed first.

# l = [0, 1, 2, 3, 4]
[x for x in l for _ in range(3)]
# Returns [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]
# Equivalent to:
# for x in l:
#     for _ in range(3):
#         append x
[x for _ in range(3) for x in l]
# Returns [0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
# Equivalent to:
# for _ in range(3):
#     for x in l:
#         append x

List comprehensions can be nested. For instance, if the values of pixels of a gray-scale image is represented by a list i = [0.5, 0.25, 0.1, ...] and one wants to generate an RGBA representation such that all red, green and blue channels have the gray-scale value and the alpha is always 1, then a list comprehension can be used as follows.

[[v for _ in range(3)].append(1) for v in i]
# Returns [[0.5, 0.5, 0.5, 1], [0.25, 0.25, 0.25, 1], [0.1, 0.1, 0.1, 1], ...]

Inline Tips

Below we list some tips on using inline expressions.

None Returns

If one appends some values to a list in an expression, None is returned because the append function have no return statement. But what if we wants the list after appending, how do we get its value? In this case, a little trick can be used.

[list.append(element), list][1]

We create a list from two elements, the first element is the append expression which, as we said before, returns None and the other element is the list itself. Because python evaluates the first element first, the second element is actually the list after appending and getting it using the index [1] gets us what we want.