Nous allons maintenant tracer le cours d’ouverture en plus du cours de clôture. Nous enrichirons le programme du chapitre précédent : nous demanderons une donnée supplémentaire à la bibliothèque et ajouterons un appel de tracé.

Avant de le modifier, parcourons ses lignes pour comprendre le rôle de chacune.

Le code est une description précise

Dans un programme, vous donnez des instructions à l’ordinateur. Par exemple : « Utilise le cours de clôture de la bougie et affiche-le avec une ligne bleue. » Pour cela, l’ordinateur attend des noms et une ponctuation précis.

En Pyne code, nous écrivons ces instructions avec la syntaxe Python. Les parenthèses des appels de fonctions, les deux-points et l’indentation des lignes en font partie. Les sections suivantes expliquent leur rôle.

Ouvrez le fichier first_chart.py créé au deuxième chapitre. Si vous y avez renommé l’indicateur, cela ne change rien à l’explication.

Le marqueur Pyne au début du fichier

Les trois premières lignes du fichier :

"""
@pyne edge
"""

Les triples guillemets délimitent un bloc de texte. Au début du fichier, ce bloc peut aussi accueillir une description du programme. Python l’appelle une docstring.

PyneCore y lit le marqueur @pyne. Celui-ci lui indique que le fichier contient du Pyne code et qu’il doit appliquer des règles différentes du fonctionnement ordinaire de Python. Avant l’exécution, PyneCore transforme le code pour permettre, par exemple, l’accès aux valeurs des bougies précédentes et la conservation d’une variable pour la bougie suivante. Des chapitres leur seront consacrés.

Le marqueur @pyne seul est également valide. Un fichier Pyne code peut commencer ainsi :

"""
@pyne
"""

Que signifie le mot edge qui l’accompagne ?

edge indique que le programme utilise un sous-ensemble défini et limité de Pyne code. @pyne active le fonctionnement bougie par bougie ; edge détermine les éléments du langage et les fonctions que nous pouvons utiliser. PyneIDE signale les dépassements de ce cadre.

Les programmes marqués @pyne peuvent aussi utiliser d’autres possibilités et bibliothèques de Python. Les programmes @pyne edge s’appuient sur les outils autorisés par Pyne et n’importent pas de bibliothèques Python arbitraires. Cela permet aussi leur traitement par des environnements d’exécution dépourvus d’un environnement Python généraliste.

Tous les programmes complets du livre conservent le marqueur @pyne edge et respectent ce cadre.

Choisir les outils

La ligne suivante :

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

La construction from … import … rend les noms énumérés accessibles dans le programme. Dans cet exemple, nous demandons quatre outils à la bibliothèque pynecore.lib :

  • close : le cours de clôture de la bougie actuelle ;
  • color : les couleurs disponibles ;
  • plot : l’affichage d’une valeur sur le graphique ;
  • script : la définition du type du programme et de ses paramètres de base.

La virgule sépare les noms. Les majuscules et minuscules comptent : close et Close sont deux noms différents.

Les lignes vides structurent le code. Elles aident à reconnaître la fin de la liste des outils et le début du programme.

Le nom et l’affichage du programme 

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

Cette ligne indique que nous créons un indicateur. Un indicateur effectue des calculs à partir des données et affiche quelque chose. Ici, nous traçons le cours de clôture.

Les parenthèses contiennent les paramètres de l’indicateur :

  • Le texte "My First Chart", entre guillemets, est le nom de l’indicateur.
  • overlay=True demande de tracer sur le même graphique que les bougies.

True signifie vrai. Son contraire est False. Avec overlay réglé sur False, l’indicateur apparaît dans un panneau séparé. Nous l’utiliserons dans le chapitre consacré à vos propres calculs.

Où se fait le calcul ? 

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

def marque le début d’une fonction. Une fonction est une suite d’opérations portant un nom. Ici, ce nom est main.

PyneCore exécute le corps de main() sur les bougies des données. C’est le point d’entrée de notre programme. Les parenthèses sont suivies de deux-points ; la ligne décalée en dessous appartient au corps de la fonction.

L’indentation indique quelles lignes vont ensemble. Nous utilisons quatre espaces par niveau. En début de ligne, appuyez sur Tab : avec les réglages par défaut de PyneIDE, cela ajoute une indentation de quatre espaces en une seule fois. Shift + Tab retire un niveau. Visual Studio Code indente généralement aussi la nouvelle ligne automatiquement lorsque vous appuyez sur Enter après une ligne terminée par deux-points.

Que demandons-nous à plot ?

plot(...) est un appel de fonction. Les parenthèses contiennent les valeurs et les paramètres nécessaires :

  • close : la valeur à afficher ;
  • "Close" : le nom du tracé ;
  • color=color.blue : la couleur bleue ;
  • linewidth=2 : une épaisseur de ligne réglée à 2.

Pour les deux premières valeurs, l’ordre détermine le rôle. color= et linewidth= précisent par leur nom le réglage transmis. Nous les appelons des paramètres.

Le point de color.blue signifie que nous utilisons la couleur blue associée au nom color. Dans le code, ce point fait partie de l’accès au nom ; ne le remplacez pas par une virgule.

Tracer deux lignes

Nous avons utilisé close pour le cours de clôture. Le cours d’ouverture est accessible par open.

Copiez le fichier sous le nom two_lines.py dans le dossier scripts. Vous conserverez ainsi l’exemple du deuxième chapitre. Dans la copie :

  1. Ajoutez open aux outils importés.
  2. Renommez l’indicateur "Open and Close".
  3. Ajoutez un deuxième appel à plot dans le corps de main().

Le programme complet :

"""
@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)

Avant l’exécution, essayez de prévoir où les deux lignes rencontreront les bougies. Enregistrez le fichier et cliquez sur Run Pyne code. Utilisez les mêmes données d’exemple qu’auparavant.

À côté du code de two_lines.py, le graphique de cours DEMO affiche deux lignes distinctes, Close et Open.
Deux appels à plot, deux lignes : Close affiche la clôture et Open l’ouverture sur le même graphique.

Que faut-il observer ?

La ligne bleue relie les cours de clôture ; la ligne orange, les cours d’ouverture. Les tracés portent aussi les noms Close et Open. Ceux-ci permettent de les reconnaître même si vous changez ensuite les couleurs.

Les deux appels à plot ont la même indentation de quatre espaces, car ils appartiennent à la même fonction main().

Si une erreur apparaît sous open, vérifiez que vous l’avez ajouté à l’import. Pour utiliser un nouvel outil, son nom doit être accessible.

Les commentaires dans le code

Une ligne commençant par un seul # est un commentaire :

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

Un commentaire n’exécute aucune opération. Vous pouvez l’utiliser pour expliquer le but d’une étape à vous-même ou à une personne qui lira le code plus tard. Les commentaires des exemples sont en anglais ; les explications du livre sont en français.

Vous pouvez aussi placer un commentaire à la fin d’une instruction :

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

L’appel plot(...) s’exécute alors normalement. Le texte qui suit # jusqu’à la fin de la ligne est un commentaire ; l’environnement d’exécution l’ignore. Nous laissons deux espaces entre le code et # pour faciliter la lecture.

À vous de jouer

Créez une troisième ligne montrant le cours le plus haut de chaque bougie, accessible par high. Le tracé doit s’appeler "High" et utiliser color.green.

Réfléchissez aux deux endroits du programme à compléter. Avant l’exécution, faites une prévision : la valeur High peut-elle être inférieure à l’ouverture ou à la clôture de sa propre bougie ?

Solution de l’exercice

Il faut aussi ajouter high à l’import :

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

Ajoutez cette ligne au corps de main(), avec la même indentation que les deux autres appels :

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

Le plus haut d’une bougie est au moins égal à ses cours d’ouverture et de clôture. Le point High ne peut donc être inférieur à aucun des deux à cette bougie. Interprétez toujours les segments reliant les points à l’emplacement de la bougie concernée.

Vérifier votre modification

Relisez le programme à trois lignes. Y retrouvez-vous les données importées, le nom de l’indicateur et les appels de tracé ? Vérifiez que chaque donnée nouvellement utilisée figure dans l’import et que les trois appels ont la même indentation.

Avant d’effectuer nos propres calculs sur les prix, nous verrons comment PyneIDE vous aide à utiliser les fonctions.