DYNAMO + PYTHON

INTRODUCCIÓN A DYNAMO CON PYTHON

 Dynamo + Python

© Structuralia 2
 Introducción a Dynamo con Python

ÍNDICE

ÍNDICE........................................................................................................................................................................... 3

1. INTRODUCCIÓN ....................................................................................................................................................... 4

2. RAZONES PARA APRENDER PYTHON ................................................................................................................. 5

3. NODO PYTHON SCRIPT .......................................................................................................................................... 6

4. EDITORES DE TEXTO E INTÉRPRETES .............................................................................................................. 14

5. NODO PYTHON SCRIPT FROM STRING .............................................................................................................. 16

3 © Structuralia
 Dynamo + Python

1. INTRODUCCIÓN
A lo largo del máster ya hemos ido viendo cómo funciona Dynamo y el enorme potencial que
puede llegar a tener. Todo es un tema de practicar y en suma, de ponerse para llegar a cotas
considerables de dominio.

Sin embargo, hay veces que los nodos por defecto de Dynamo se nos pueden quedar cortos.
Es cierto que para eso están los paquetes, estupendos para realizar muchas de las acciones
que de otra forma se nos harían imposibles. Pero, de la misma forma, puede pasar que no
encontremos el paquete con el nodo que nos interese. Así que una de las soluciones a todo
esto es aprender a programar desde el nodo de Python de Dynamo del que ya hablaremos con
más profusión. Gracias a este nodo, que exige que entendamos el lenguaje de programación
Python, podemos ampliar e inclusive multiplicar, las posibilidades ya extensas de Dynamo.

Por supuesto, todo esto pasa porque tengamos un conocimiento suficiente de Python. Con lo
que habéis dado en módulos anteriores seguro que tenéis más que suficiente para afrontar
estos módulos. En mi opinión, como ya he dicho varias veces, es mucho mejor para aprender
lo que vamos a ver, que tengamos unas nociones generales suficientes de Python para que
todo esto no se nos haga demasiado cuesta arriba.

Aun así, algunos de los conceptos básicos los repasaremos aquí mismo para que sirvan de
repaso a lo dado con anterioridad y así que vayan calando poco a poco.

© Structuralia 4
 Introducción a Dynamo con Python

2. RAZONES PARA APRENDER PYTHON

Aunque ya he contado, a manera de introducción, la razón principal para aprender Python, voy
a resumir algunas de las razones principales.

1. En primer lugar porque es un gran lenguaje de programación y cada vez más utilizado.
Cuando escribo esto, es probablemente el primero ya (desde hace poco) en uso a nivel
mundial y el que más crece con diferencia año a año.

2. Por su sintaxis sencilla, fácil de familiarizarnos con ella y a su vez, fácil de leer. Como
ya hemos visto, aunque no seamos programadores profesionales, la curva de
aprendizaje es mucho menos pronunciada que con otros lenguajes de programación.

3. Para compactar nuestros flujos de trabajo con Dynamo. Es normal que a veces las
definiciones se vayan haciendo cada vez más grandes y uno empieza ya a perder el
hilo de dónde están las cosas. Así que utilizando Python podemos reducir todo eso, en
algunos casos a unas cuantas líneas de código.

4. Ampliar las posibilidades de los nodos por defecto y de los paquetes. Que es un poco lo
que hemos contado en la introducción, así pues probablemente es la principal razón.

Antes de embarcarnos en los siguientes capítulos, insistir en que esto de programar y

especialmente con lenguajes de programación requiere tiempo. De la misma forma que cuando
somos pequeños empezamos a balbucear y luego pasamos a decir cosas simples (pero vitales
para nuestra supervivencia) como “mamá”, “papá”, “agua”, etc, aquí es lo mismo. Al principio
nos puede descorazonar que lleva tiempo y pasar por mucha práctica y error, hasta que
podamos decir el equivalente de “mamá y papá, tengo ganas de tomar un vaso de agua muy
frio con hielos por favor” programando.

Así que mucho ánimo y a por ello. Todos hemos pasado por esto (y seguimos haciéndolo).

5 © Structuralia
 Dynamo + Python

3. NODO PYTHON SCRIPT

Para empezar a utilizar Python, vamos a utilizar a lo largo de estos módulos principalmente el
nodo Python Script. Para no hacer muy largo el tema vamos a hablar desde la versión de
Dynamo 2.0. Ya sabéis que todo esto ha traído consigo cambios en la interfaz y en la
estructura de las categorías, pero básicamente la esencia es la misma.

El nodo Python Script lo encontramos en Script>Editor. Como podemos apreciar tenemos dos
nodos relacionados con Python: el nodo Python Script, que es el que más vamos a utilizar y el
otro, del que hablaremos posteriormente, llamado Python Script from String.

El nodo Python Script (Figura 1), como podemos ver, puede recordarnos un poco a List.Create
por poner un ejemplo. Efectivamente tenemos estos + y – para poder controlar el número de
inputs.

Figura 1: El nodo Python Script, fundamental para todo lo que vamos a ver

Con el botón derecho por encima, podemos irnos a Editar o bien hacer doble click para ver la
interfaz dónde podemos crear nuestro código. (Figura 2).

© Structuralia 6
 Introducción a Dynamo con Python

Figura 2: La interfaz del nodo Python Script en la que podemos incorporar nuestro código

Aquí entonces es donde vamos a incorporar nuestro código. Aunque sin meternos en
profundidad, decir que verdaderamente desde aquí vamos a trabajar con IronPython que es,
por así decirlo, un implementador de Python, escrito en otro lenguaje: C#. La gran ventaja es
que vamos a poder interactuar con bibliotecas que están dentro de .NET de Microsoft que
hayan podido ser creadas en otros lenguajes como C#, Visual Basic, C++, etc, utilizando la
misma sintaxis que Python, para ser más exactos que Python. 2.7.

Siempre que abrimos este nodo por defecto nos aparecen siempre estas primeras 4 líneas
para importar una biblioteca de geometría. (Figura 3). No nos preocupemos demasiado de esas
líneas y sin más vamos a borrarlas porque sé por experiencia, que al principio imponen y para
lo que vamos a contar ahora no son necesarias. Así que las seleccionamos y las borramos tal
cual quedándonos solo con la línea 12 que pasa a ser la línea 1. (Figura 4).

7 © Structuralia
 Dynamo + Python

Figura 3: Las cuatro primeras líneas son prescindibles por ahora

Figura 4: Nos quedamos solo con OUT = 0 (Como vemos es el resultado que vemos en el nodo mismamente)

© Structuralia 8
 Introducción a Dynamo con Python

Como podemos ver nos ha quedado OUT = 0. El OUT este, hace un poco las veces de Print,
como hemos visto en los módulos anteriores del profesor Alfredo Sánchez. Digamos que es el
equivalente que permite que lo veamos en la salida del nodo.

Pongamos por caso que no quiero que me aparezca un 0, lo que quiero por ejemplo es un 5.
Lo cambiamos y utilizando Ejecutar, veríamos algo como la Figura 5.

Figura 5: Nos quedamos con OUT = 5 y ya vemos que es lo que conseguimos como output

Obviamente lo que hemos hecho es nada en comparación con lo que podemos ir haciendo,
pero ya es un principio.

Ahora lo que voy a hacer es incorporar un input a ese nodo Python. Pongamos por caso que
quiero incorporar un string, lo puedo hacer fuera por ejemplo del nodo e incorporarlo en el input
port IN[0] (Figura 6). Si en la interfaz del nodo le damos de nuevo a ejecutar, sigue dándonos 5
como resultado, y es lógico pues lo que aparece detrás de OUT = es lo que aparecerá como
output.

9 © Structuralia
 Dynamo + Python

Figura 6: Incorporarmos un input al nodo Python, aunque vemos que nada pasa si lo ejecutamos.

Una vez hecho todo esto, vamos a pasar lo que hemos incorporado al input port, al output port
del nodo, es decir se va a convertir en el resultado. Para ello solo tenemos que escribir: OUT =
IN[0], le damos a ejecutar y ya lo tenemos como resultado. (Figura 7)

Figura 7: Ahora conseguimos pasar lo que tenemos en IN[0] como output del nodo.

© Structuralia 10
 Introducción a Dynamo con Python

No está mal, pero vamos a ir más allá. Lo que hemos incorporado, que está en su mayoría en
minúsculas, lo voy a pasar a mayúsculas y para ello voy a utilizar un método que
probablemente ya conocéis: upper() que permite hacer eso precisamente. Así que nos
quedaría algo como lo que vemos en la Figura 8.

Figura 8: Utilizando punto seguido del método upper, conseguimos pasar toda esa cadena de texto a mayúsculas.

Podemos utilizar otros métodos y funciones, por ejemplo list(), para que la cadena nos la
devuelva como una lista. (Figura 9)

11 © Structuralia
 Dynamo + Python

Figura 9: Con la función list(), conseguimos una lista con los caracteres del string

Podemos también cerciorarnos que lo que hemos incorporado es un string, a través de la

función isinstance(), como podemos ver en la Figura 10.

Figura 10: Comprobamos que lo que tenemos en IN[0] sea un string.

© Structuralia 12
 Introducción a Dynamo con Python

Como podemos apreciar, el resultado es booleano, en este caso true. Ojo a los booleanos
porque aunque hablaremos sobradamente de ellos, fijarse que en DesignScript se escribe true
o false, mientras que en Python es True y False, así que la primera letra en mayúsculas por
favor.

Por supuesto podemos incorporar varios otros inputs a nuestro nodo y pasarlos a OUT, como
vemos en la Figura 11.

Figura 11: Incorporamos varios inputs de distinto tipo y los pasamos a OUT

Ya vemos que solo tenemos que crear input ports con + en el nodo, y por otro lado ir añadiendo
los inputs después de OUT = separados por comas.

Ahora vamos a utilizar el botón que tenemos debajo “Guardar cambios” y borramos todo. Si
ahora utilizamos “Revertir”, vamos a ver que aparece el código que teníamos con anterioridad.
Por decirlo de otra manera, nos da un CTRL+Z, para poder volver al código anterior en el caso
de que sea necesario.

13 © Structuralia
 Dynamo + Python

4. EDITORES DE TEXTO E INTÉRPRETES

Vamos a hacer una pequeña pausa, para hablar de editores de texto e intérpretes. Si bien no
vamos a hablar demasiado de ellos a este nivel, si decir que tenemos varios a nuestra
disposición. Los editores de texto se utilizan básicamente para crear código de forma efectiva.
Ya nos hemos fijado y sino ya lo veremos, que crear código en el nodo Python no es lo más
efectivo del mundo cuando ya estamos haciendo cosas de cierto empaque.

Los editores de texto en cambio, permiten crear código con la gran ventaja de autocompletado.
Es decir cuando colocamos un punto sobre una variable, nos da un menú de posibilidades de
métodos y demás, ahorrando un montón de errores y esfuerzo innecesario. Aparte de todo
esto, tiene otras ventajas a nivel de gestión de archivos. Algunos de estos editores de texto
son: Sublime (Figura 12) y Visual Studio Code (Figura 13).

Figura 12: Página web de Sublime Text

© Structuralia 14
 Introducción a Dynamo con Python

Figura 13: Página web de Visual Studio Code

Por otro lado tenemos los intérpretes para poder practicar nuestros conocimentos de Python,
pudiendo ver en todo momento el output de nuestro código. Sin ir más lejos, si nos vamos a
nuestro equipo y seguimos la ruta de la Figura 14, podemos hacer doble click en ipy y practicar.

Figura 14: Abriendo el intérprete que tenemos por defecto de IronPython en nuestro equipo

Es una muy buena manera de ver el resultado inmediatamente y línea a línea.

15 © Structuralia
 Dynamo + Python

5. NODO PYTHON SCRIPT FROM STRING

El otro nodo del que habíamos hablado, que disponemos para Python, es Python Script From
String. La idea es que transforma un texto o cadena de caracteres, en código para que luego le
incorporemos los inputs que necesitemos. Por ejemplo voy a hacer un pequeño código que
salude en función del nombre que le demos. Así que hago con por ejemplo un code block una
línea de código similar a las que hemos visto pero entrecomillada para que sea un string. Hay
que fijarse como detalle que he incorporado comillas simples para que no entren en colisión
con las generales. Nos debería quedar como en la Figura 15.

Figura 15: Creamos código a través de un texto de un bloque de código.

Para poner otro ejemplo, vamos a hacer lo mismo que veíamos con anterioridad, es decir,
vamos a utilizar la función list() para que nos saque una lista de una cadena de caracteres,
como podemos ver en la Figura 16.

© Structuralia 16
 Introducción a Dynamo con Python

Figura 16: Otro ejemplo de uso del nodo Python Script From String

Todo esto no está mal, sin embargo lo veo más como una opción de pasar código desde un
editor de texto a Dynamo. Por ejemplo el mismo código que he hecho en bloque de código, lo
puedo hacer desde un editor de texto tipo Sublime o Visual Studio Code. Así que para este
caso, lo voy a hacer desde Sublime y lo voy a guardar con extensión .py que es el de Python
en una carpeta cualquiera por ejemplo Mis Documentos. Así que el nombre puede ser
“Prueba.py”. (Figura 17)

Figura 17: El mismo código creado en un editor de texto como Sublime, guardado como Prueba.py

17 © Structuralia
 Dynamo + Python

Hecho todo esto vamos a utilizar dos nodos extras para traernos dicho código. Por un lado File
Path, para obtener la ruta de este archivo y FileSystem.ReadText, para que pueda leer ese
archivo, obteniendo así de nuevo una cadena de caracteres que podemos incorporar al nodo
Python Script From String. (Figura 18).

Ya nos podemos imaginar que es una buena manera de trabajar desde editores de texto, ya
que tienen todo el tema de autocompletado y de gestión de archivos que es verdaderamente
muy útil, así que sin duda es una muy buena manera de incorporar ese código a nuestro
Dynamo.

Figura 18: Incorporamos ese código a nuestro nodo de Python Script From String

© Structuralia 18