Ahora dibujaremos el precio de apertura junto al de cierre. Para ello ampliaremos el programa del capítulo anterior: pediremos otro dato a la biblioteca y añadiremos una llamada de dibujo al código.

Antes de modificarlo, repasaremos sus líneas para entender la función de cada una.

El código es una descripción precisa

En un programa das instrucciones al ordenador. Por ejemplo: «Usa el cierre de la vela y muéstralo con una línea azul». El ordenador necesita nombres y signos exactos para hacerlo.

En Pyne code escribimos estas instrucciones con la sintaxis de Python. Los paréntesis de las llamadas a funciones, los dos puntos y la sangría de las líneas forman parte de ella. En las siguientes secciones conocerás su papel.

Abre first_chart.py, creado en el segundo capítulo. Si cambiaste el nombre del indicador, eso no afecta a la explicación que sigue.

La marca Pyne al principio del archivo

Las tres primeras líneas del archivo:

"""
@pyne edge
"""

Las comillas triples indican el principio y el final de un bloque de texto. Al comienzo del archivo, este bloque también puede contener la descripción del programa. Python lo llama docstring.

PyneCore lee de él la marca @pyne. Esta le indica que el archivo contiene Pyne code y que debe aplicar reglas distintas del funcionamiento habitual de Python. Antes de ejecutarlo, PyneCore transforma el código para permitir, por ejemplo, acceder a valores de velas anteriores o conservar el valor de una variable para la siguiente vela. Veremos estas posibilidades en capítulos separados.

La marca @pyne también es válida por sí sola. Un archivo de Pyne code puede empezar así:

"""
@pyne
"""

¿Qué significa edge a su lado?

edge indica que el programa utiliza un subconjunto definido y limitado de Pyne code. @pyne activa el funcionamiento vela a vela; edge determina qué elementos del lenguaje y qué funciones podemos utilizar. PyneIDE avisa si salimos de esos límites.

Los programas con la marca @pyne también pueden usar otras posibilidades y bibliotecas de Python. Los programas @pyne edge se basan en las herramientas permitidas por Pyne y no importan bibliotecas arbitrarias de Python. Esto permite procesarlos en entornos que no proporcionan un Python de propósito general.

En todos los programas completos del libro mantendremos @pyne edge y trabajaremos dentro de este subconjunto del lenguaje.

Elige las herramientas

La siguiente línea:

from pynecore.lib import close, color, plot, script

La estructura from … import … permite utilizar en el programa los nombres enumerados. En este ejemplo pedimos cuatro herramientas a pynecore.lib:

  • close: el cierre de la vela actual;
  • color: los colores disponibles;
  • plot: representar un valor en el gráfico;
  • script: definir el tipo de programa y sus ajustes básicos.

Las comas separan los nombres. Las mayúsculas y minúsculas importan: close y Close son nombres distintos.

Las líneas vacías ayudan a organizar el código. Facilitan reconocer dónde termina la lista de herramientas y dónde empieza el programa.

El nombre y la presentación del programa 

@script.indicator("My First Chart", overlay=True)

Esta línea indica que creamos un indicador. Un indicador calcula y representa algo a partir de los datos. En este ejemplo dibujamos el cierre.

Entre paréntesis definimos sus ajustes:

  • El texto "My First Chart", entre comillas, es el nombre del indicador.
  • overlay=True solicita que el dibujo aparezca en el mismo gráfico que las velas.

True significa verdadero. Su opuesto es False. Si cambias overlay a False, el indicador aparece en un panel separado. También lo utilizaremos en el capítulo sobre cálculos propios.

Dónde se realiza el cálculo 

def main():
    plot(close, "Close", color=color.blue, linewidth=2)

def indica el comienzo de una función. Una función es una secuencia de operaciones con un nombre. Aquí se llama main.

PyneCore ejecuta el cuerpo de main() sobre las velas de los datos. Es el punto de entrada del programa. Después de los paréntesis van dos puntos, y la línea de debajo, con sangría, pertenece al cuerpo de la función.

La sangría indica qué líneas forman un bloque. Usamos cuatro espacios por nivel. Pulsa Tab al principio de una línea: con la configuración predeterminada de PyneIDE añade cuatro espacios de sangría en un paso. Shift + Tab retrocede un nivel. Visual Studio Code suele aplicar la sangría automáticamente al pulsar Enter después de una línea terminada en dos puntos.

¿Qué le pedimos a plot?

plot(...) es una llamada a función. Entre paréntesis proporcionamos los valores y ajustes que necesita:

  • close: representar este valor;
  • "Close": usar este nombre para el dibujo;
  • color=color.blue: dibujarlo en azul;
  • linewidth=2: ajustar el grosor de línea a 2.

En los dos primeros valores, el orden determina su papel. color= y linewidth= identifican por nombre el ajuste que pasamos. Los llamamos parámetros.

El punto de color.blue indica que usamos el color blue perteneciente a color. En el código, el punto forma parte del acceso al nombre; no lo sustituyas por una coma.

Dibuja dos líneas

Para el cierre usamos close. Puedes acceder a la apertura mediante open.

Copia el archivo con el nombre two_lines.py en la carpeta scripts. Así conservas también el ejemplo del segundo capítulo. En la copia:

  1. Añade open a las herramientas importadas.
  2. Cambia el nombre del indicador a "Open and Close".
  3. Añade una segunda llamada a plot al cuerpo de main().

El programa completo:

"""
@pyne edge
"""
from pynecore.lib import close, color, open, plot, script


@script.indicator("Open and Close", overlay=True)
def main():
    plot(close, "Close", color=color.blue, linewidth=2)
    plot(open, "Open", color=color.orange, linewidth=2)

Antes de ejecutarlo, intenta predecir dónde se encontrarán las líneas con las velas. Guarda el archivo y haz clic en Run Pyne code. Usa los mismos datos de ejemplo que antes.

Junto al código de two_lines.py, el gráfico de precios DEMO muestra líneas separadas Close y Open.
Dos llamadas a plot, dos líneas: Close muestra el cierre y Open muestra la apertura en el mismo gráfico.

¿Qué debes observar?

La línea azul conecta los cierres; la naranja, las aperturas. Los dibujos tienen nombres: Close y Open. El nombre ayuda a identificarlos aunque cambies los colores más adelante.

Las dos llamadas a plot tienen la misma sangría de cuatro espacios porque pertenecen a la misma función main().

Si aparece un error debajo de open, comprueba que lo añadiste a la importación. Para usar una nueva herramienta, su nombre debe estar disponible.

Comentarios en el código

Una línea que empieza por un solo # es un comentario:

    # Show the opening price of each candle.
    plot(open, "Open", color=color.orange, linewidth=2)

El comentario no ejecuta ninguna operación. Sirve para explicar el propósito de un paso a ti mismo o a quien lea el código más adelante. Escribimos los comentarios de los ejemplos en inglés; las explicaciones del libro están en español.

También puedes escribir un comentario al final de una instrucción:

    plot(open, "Open", color=color.orange, linewidth=2)  # Show the opening price.

La llamada plot(...) se ejecuta. El texto desde el # que la sigue hasta el final de la línea es un comentario y el entorno de ejecución lo ignora. Dejamos dos espacios entre el código y # para facilitar la lectura.

Pruébalo por tu cuenta

Crea una tercera línea que muestre el máximo de las velas. Su nombre es high. El dibujo debe llamarse "High" y utilizar color.green.

Piensa en los dos lugares donde debes ampliar el programa. Antes de ejecutarlo, predice: ¿puede High quedar por debajo de la apertura o del cierre de su propia vela?

Solución del ejercicio

También hay que añadir high a la importación:

from pynecore.lib import close, color, high, open, plot, script

Añade esta línea al cuerpo de main() con la misma sangría que las otras dos llamadas:

    plot(high, "High", color=color.green, linewidth=2)

El máximo de una vela es al menos tan alto como su apertura y su cierre. Por eso el punto High no puede quedar por debajo de ninguno de ellos en esa vela. Interpreta siempre los segmentos que unen los puntos en la posición de la vela correspondiente.

Comprueba tus cambios

Repasa el programa de tres líneas. ¿Encuentras los datos importados, el nombre del indicador y las llamadas de dibujo? Comprueba que cada nuevo dato utilizado aparece en la importación y que las tres llamadas tienen la misma sangría.

Antes de realizar nuestros propios cálculos con los precios, veremos cómo te ayuda PyneIDE a utilizar las funciones.