Python est un langage d'interprétation open source facile à apprendre, pour lequel de nombreuses bibliothèques sont disponibles dans des domaines tels que l'intelligence artificielle, les statistiques, le numérique et bien d'autres encore. Cette documentation n'a pas pour objectif de présenter le langage de programmation Python. Vous trouverez des informations à ce sujet par exemple sur https://www.python.org/doc/.
Python est très flexible et évolutif, ce qui a permis une intégration élégante dans FlexPro. Les types de données Array nécessaires au traitement des données de mesure sont fournis par la bibliothèque Python bien connue NumPy. Celles-ci constituent la base de l'échange de données avec FlexPro, raison pour laquelle NumPy est également installé lors de l'installation de FlexPro. Vous trouverez des informations sur NumPy sur https://numpy.org/doc/stable/.
Le module flexpro
Lors de l'initialisation de Python dans FlexPro, le module Python flexpro est enregistré et représente l'interface avec FlexPro.
Les classes Python flexpro.DataObject et flexpro.Object représentent des objets de données FlexPro et d'autres objets FlexPro, ce qui vous permet d'accéder à leurs propriétés. Vous créez des objets de ces classes à l'aide de la fonction flexpro.object(), à laquelle vous transmettez comme argument le chemin et le nom dans la base de données d'objets de l'objet auquel vous souhaitez accéder.
o = flexpro.object(r'\Data\Dataset1') crée un DataObject qui représente l'ensemble de données "\Data\Dataset1".
La variable this est déjà initialisée dans chaque formule Python et contient le DataObject qui représente la formule Python elle-même.
this.name renvoie le nom de la formule Python sous forme de chaîne de caractères.
this.data = np.linspace(0, 10, 100) renvoie une série de données linéaires comme résultat de la formule.
Remarque Dans FPScript, chaque instruction fournit un résultat qui est automatiquement attribué à la formule comme résultat. Ce n'est pas le cas en Python, où vous devez utiliser une affectation explicite this.data = ... . Cela vaut également pour les résultats intermédiaires que vous souhaitez voir s'afficher dans la fenêtre d’espion à l'issue de la recherche d'erreurs à l'aide du débogueur.
Les données FlexPro diffèrent des données Python ou NumPy en ce sens qu'elles peuvent être unitaires et comporter des structures de données composées avec des composantes Y, X et Z. Il existe également des listes en Python, mais celles-ci ne prennent pas en charge les éléments nommés. C'est pourquoi le module flexpro met à disposition le type flexpro.Data, qui peut représenter les données FlexPro avec toutes leurs propriétés.
Vous créez un objet flexpro.Data avec des données FlexPro simples ou composées à l'aide du constructeur flexpro.Data().
flexpro.Data(80.3, "dB") crée une valeur scalaire en virgule flottante avec l'unité "dB".
Cet exemple crée un signal sinusoïdal avec des composantes Y et X unitaires et renvoie le résultat sous forme de formule :
x = np.linspace(0, 10, 100)
y = np.sin(x)
this.data = flexpro.Data( y, "V", x, "s")
Si vous souhaitez omettre les unités, par exemple parce que vous les avez déjà saisies dans la boîte de dialogue Propriétés de la formule, vous devez nommer les arguments :
this.data = flexpro.Data( value_y = y, value_x = x)
Pour créer une liste FlexPro avec deux éléments nommés, procédez comme suit :
list = flexpro.named_list("Signal1", s1, "Signal2", s2)
La concaténation à une telle liste est également prise en charge :
list += flexpro.named_list("Signal3", s3)
Vous pouvez créer des listes sans nom d'élément soit avec l'opérateur Python [ ... ], soit avec la fonction flexpro.list(). Cette dernière option est légèrement plus efficace, car elle ne nécessite aucune conversion au format de données FlexPro lors du transfert vers FlexPro.
La propriété data de la classe flexpro.DataObject fournit les données de l'objet de données en tant qu'objet flexpro.Data.
data = flexpro.object(r'\Data Set').data
Si vous souhaitez accéder directement aux données, utilisez la fonction call:
data = flexpro.call(r'\Data Set')
Vous pouvez appeler une fonction FPScript ou Python en tapant call suivi des arguments :
data = flexpro.call(r'\MyFunction', flexpro.call(r'\Data Set'), flexpro.Data(5, 'V'))
La classe flexPro.Data dispose des propriétés value et unit. value fournit les données numériques comme type de données Python ou NumPy Array et unit l'unité comme chaîne de caractères.
flexpro.Data(1.3, "V").value renvoie 1.3 sous forme de nombre à virgule flottante.
flexpro.Data(1.3, "V").unit renvoie "V" sous forme de chaîne de caractères.
Dans le cas d'une structure de données composée, vous sélectionnez d'abord la composante :
signal = flexpro.call(r'\Data\Signal1')
signal.y renvoie un objet flexpro.Data qui représente la composante Y avec l'unité.
signal.y.value renvoie les données du composant Y sous forme de tableau NumPy.
signal.y.unit renvoie "V" comme chaîne de caractères.
Si une liste est disponible, commencez par sélectionner l'élément :
list["Signal1"] renvoie un objet flexpro.Data qui représente les données de l'élément de liste "Signal1".
Pour les listes sans nom ou les noms non uniques, vous devez utiliser un index numérique :
list[0]
A un objet flexpro.Data qui provient d'un objet de données, FlexPro attache les informations d'en-tête de cet objet de données. Il s'agit essentiellement des propriétés que vous pouvez indiquer dans l'onglet Général de l'objet de données.
Vous pouvez accéder à ces propriétés en lecture et en écriture :
data = flexpro.call(r'\Signal')
data.unit_y renvoie l'unité Y de l'objet de données dont provient la valeur, c'est-à-dire de "Signal".
data.comments_x = "heure" Affecte un commentaire X aux données. L'accès en écriture ne se fait toutefois pas sur l'objet de données "Signal" dont provient data, mais sur une copie locale de cet attribut affectée à l'objet Data.
Voir aussi