Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculArrière-plan
* Utilisation de Python dans l'environnement de script JMP19.
* Création d'un dataframe (df) à partir de pandas à partir d'une table de données JMP existante (dt).
* Fonction en cours d'exécution qui prend un dataframe en entrée et renvoie un nouveau dataframe en résultat. Appelons-la df_results.
* Transfert des résultats vers la colonne de la table de données JMP.
Cela fonctionne, mais deux choses me font penser que je ne procède pas correctement. Premièrement, j'obtiens un avertissement dans les journaux locaux. Deuxièmement, la première exécution sur un très grand nombre de lignes est très longue. Mon chronomètre indiquait 25 secondes pour 100 000 lignes. Si je relance le programme, la deuxième fois, il ne faut que 3 secondes. J'ai configuré le chronomètre pour obtenir des détails à chaque étape afin de déterminer si une ligne de code est particulièrement gourmande en temps.
Voici la ligne de code qui me pose problème. Le premier remplissage de la colonne (initialement constante ou nulle – j'ai testé les deux) a pris 25 secondes pour 100 000 lignes. Ensuite, le traitement a été presque 10 fois plus rapide à chaque exécution suivante.
dt[ColumnName] = df_results[ColumnName]
Voici le message d'avertissement dans le journal intégré
FutureWarning : La méthode Series.__getitem__ qui traite les clés comme des positions est obsolète. Dans une version ultérieure, les clés entières seront toujours traitées comme des étiquettes (conformément au comportement des DataFrames). Pour accéder à une valeur par sa position, utilisez `ser.iloc[pos]`.
J'ai également effectué ce test sur quatre colonnes différentes issues de deux dataframes distincts. Le comportement (et l'avertissement) était identique pour toutes : un premier essai lent, puis une accélération constante. La différence entre les colonnes 1, 2, 3 et 4 était négligeable.
Il ne s'agit que d'un sous-ensemble d'une grande table contenant 1,3 million de lignes. Par conséquent, 25 secondes x 4 colonnes deviendront plus de 250 secondes x 4 colonnes si je ne parviens pas à obtenir des performances plus rapides dès le premier essai.
Merci
Automatisation et scriptageRe : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculDans JMP 18, il était nécessaire de construire une table de données colonne par colonne à partir d'un data frame. JMP 19 prend en charge le protocole des data frames portables ; il suffit donc d'une seule ligne de code pour passer d'un dt à un df, et d'une seule ligne de code pour convertir un df en dt en mémoire.
Il est également important de noter que lors de la première exécution d'un script Python dans JMP, Python lui-même doit être initialisé. De même, lors de la première importation d'un package, celui-ci doit être chargé, ce qui peut inclure les bibliothèques partagées ou la compilation du bytecode des fichiers .py.
L'avertissement provient du package pandas. Pour le supprimer, exécutez la commande `ser.iloc[pos]`. La table de données JMP `dt` peut être indexée par index de colonne (à partir de 0) ou par nom de colonne. L'indexation est plus rapide car elle évite les comparaisons de chaînes de caractères.
Aide -> Index de scripts, catégorie « Python », jmp.from_dataframe. Exemple « JMP vers Pandas ».
import jmp
import jmputils
try:
if not jmputils.is_installed('pandas'):
jmputils.jpip('install', 'pandas', echo=False)
except Exception as e:
print(f'Install failed with exception: {e}')
import pandas as pd
dt = jmp.open(jmp.SAMPLE_DATA + "Big Class.jmp")
pandas_df = (pd.api.interchange.from_dataframe(dt))
print(pandas_df)
...
# new dt_result data table from dataframe df_result
dt_result = jmp.from_dataframe( df_result )
# or continue to do the loop on columns if you need to update the original data table from the resulting dataframe.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculEt quelle est la méthode la plus rapide pour remplir une seule colonne JMP avec de nouvelles valeurs provenant de Python ?
par exemple pour un tableau de données contenant 100 000 lignes ?
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculMerci Paul, je vais utiliser jmp.from_dataframe pour revenir à datatables et éviter l'erreur.
L'autre partie de ma question portait sur l'origine de cette différence de vitesse considérable. Pour y répondre, je devais m'assurer de pouvoir reproduire de manière fiable la lenteur du calcul. Au début, c'était impossible. Tous les tests, même le premier après l'ouverture de JMP et le chargement de Python, étaient parfaitement rapides. J'ai alors compris qu'il y avait peut-être une différence cruciale : si j'ajoute une nouvelle colonne (manuellement, je ne l'avais pas encore intégrée au code) et que j'exécute le code, la mise à jour de cette nouvelle colonne est lente, et ce, uniquement lors de la première exécution.
Pour tester, j'ai mis à jour quatre colonnes : trois préexistantes et une nouvelle. La mise à jour de 100 000 lignes de la colonne 1 a pris une seconde, celle de la colonne 2 une autre seconde, celle de la colonne 3 une autre seconde encore, et enfin celle de la colonne 4 a pris 19 secondes.
J'ai créé un autre tableau et une nouvelle quatrième colonne. Si j'enregistre et ferme le tableau contenant cette nouvelle colonne, puis que je le rouvre et exécute le code, la quatrième colonne se met à jour en environ une seconde, aussi rapidement que les colonnes 1, 2 et 3. En revanche, si je me contente d'enregistrer sans fermer ni rouvrir le tableau, puis que j'exécute le code, la mise à jour de la quatrième colonne prendra toujours environ 19 secondes.
Cela me laisse penser que la vitesse est liée à une particularité de la gestion de la mémoire de JMP.
Je ne sais pas si ce problème peut/doit être résolu, et il se peut qu'il ne se manifeste que si je n'utilise pas l'étape « from_dataframe ». C'est un comportement très étrange que je suis content d'avoir pu reproduire. Je peux maintenant essayer une meilleure version du code et voir si le problème persiste.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculUn de mes collègues a fait remarquer qu'en JSL, il existe les fonctions Start Data Update et End Data Update, donc...
jmp.run_jsl( 'dt << Begin Data Update;' )
# your python code filling new column
...
jmp.run_jsl( 'dt << End Data Update;' )
Il est fort probable que nous souhaitions implémenter cette fonctionnalité depuis Python. Nous utiliserons probablement un bloc `with` pour suspendre les mises à jour de l'interface utilisateur du tableau lors du remplissage ou de la mise à jour d'un grand nombre de lignes.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculIl s'agirait de définir la colonne entière à l'aide de dt[index] encapsulé dans JSL. Début de la mise à jour des données
jmp.run_jsl( 'dt << Begin Data Update;' )
dt[ index ] = list_like_object # numpy array, list, dataframe column,...
jmp.run_jsl( 'dt << End Data Update;' )
Ou en rendant le tableau de données invisible jusqu'à ce que vous l'ayez rempli, puis en le rendant visible.
import jmp
dt = jmp.DataTable('Powered By Python', 40, visibility='Invisible')
...
# fill table
...
jmp.globals['jdt'] = dt # set jdt in JSL to reference dt
jmp.run_jsl('::jdt << Show Window(1);')
Le paramètre de visibilité optionnel peut être JMP 19 ou supérieur. La fonction jmp.globals[ ] est une fonctionnalité de la version 19.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculLa fonction `jmp.run_jsl( 'dt << Begin Data Update;' )` suppose que `dt` est la variable JSL de la table, aussi bien côté JSL que côté Python. Cela peut se produire suite à un appel à `Send(dt);` depuis JSL, mais pas nécessairement si la table a été créée directement depuis Python.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculMerci beaucoup pour cette explication.
Voici donc le code :
dt[ index ] = list_like_object
En Python, la colonne se remplit-elle étape par étape ? Qu'est-ce qui cause le problème de vitesse ?
Cela ressemble à
dt[ 0, columnname] = [values ...]
En JSL , la colonne est remplie en une seule étape et il n'est pas nécessaire d'utiliser ` dt << Début/Fin de la mise à jour des données`.
Bon à savoir. Où puis-je trouver plus de détails sur le sujet ?
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculJe ne sais pas combien d'utilisateurs savent à quel point c'est essentiel
dt << Begin Data Update;
c'est pour écrire du bon code. Mais je suis sûr que beaucoup d'utilisateurs l'ignorent.
Souhait connexe de @bswedlove pour for each row() :
pour chaque ligne (mise à jour des données=1, ...)
Excellente idée que d' institutionnaliser une solution – pour faire disparaître le problème pour l'utilisateur (la solution est toujours là).
Valable pour JSL et Python.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calcul« La table de données JMP dt peut être indexée par index de colonne à partir de 0 ou par nom de colonne. L'indexation serait plus rapide car elle éviterait les comparaisons de chaînes de caractères. »
J'essaie de réécrire du code en utilisant des indices, mais je ne trouve pas la syntaxe équivalente pour déterminer l'index d'une colonne de table de données à partir du nom que j'ai pour les dataframes.
dfColumnIndex = df.get_loc['NomDeLaColonneDuDataFrame']
dtColumnIndex = ???
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calcul@jthi , comment s'appelait le fait d'« ajouter du code pour corriger un problème qui n'existe pas » ?
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculSi `df` a été créé à partir de `dt`, on suppose qu'ils ont le même index. Si vous avez ajouté des colonnes au dataframe ou si l'un n'est pas à l'origine de l'autre, utiliser `dt['col_name'] =` est probablement votre seule solution. Cela ne devrait pas être beaucoup plus coûteux qu'un index, mais il s'agit d'une comparaison de chaînes de caractères et non d'un index numérique direct.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculTout ceci se déroule grâce à la magie des Protocol Buffers de Python, où les données sont mappées en mémoire entre les blocs de mémoire pris en charge. L'utilisation de `Begin | End Data Update` n'est peut-être pas nécessaire, mais si le mappage de la colonne entière est impossible en une seule fois, le système itérera sur les valeurs. L'utilisation de ces instructions `Data Update` constitue donc une bonne sécurité.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculJ'ai effectué de nombreux tests et utilisé différentes méthodes. Certaines ont généré des avertissements, d'autres non. La méthode la plus simple semblait consister à créer un objet `dt` à partir du dataframe `df`, puis à utiliser cet objet `dt` pour transférer les données. Cette méthode n'a jamais généré d'erreur.
Concernant le problème de vitesse… le SEUL facteur ayant une incidence était le fait que je tentais d'écrire des valeurs dans une colonne nouvellement créée ou dans une colonne existante lors de l'ouverture (ou de la création) de la table de données. Les colonnes nouvellement créées se mettaient à jour extrêmement lentement, tandis que les colonnes existantes se mettaient à jour très rapidement.
Résultats de la dernière analyse de texte sur 100 000 lignes. Quatre paramètres existaient déjà et cinq nouvelles colonnes ont été ajoutées avant l'exécution de ce code. Au total, neuf colonnes ont été mises à jour.
Ces transferts ont tous utilisé la syntaxe dt['colname'] = dt_results['colname']. Aucun DataFrame n'a été utilisé après la création de dt_results par DF.
Temps de création de l'étape df_results : 0,3434 seconde
Étape Param 1 Temps de transfert : 0,1795 seconde
Étape Param 2 temps de transfert : 0,1758 seconde
Temps de création de l'étape df_results : 0,0231 seconde #Il s'agit d'un nouvel ensemble de résultats de retour de différentes fonctions df.
Étape Param 3 temps de transfert : 0,1838 seconde
Étape Param 4 temps de transfert : 0,1890 seconde
#Le code ici était : dt['NewCol1Test'] = df_results[stringnameofcolumn]
FutureWarning : L’utilisation de `Series.__getitem__` pour traiter les clés comme des positions est obsolète. Dans une version ultérieure, les clés entières seront toujours traitées comme des étiquettes (conformément au comportement des DataFrames). Pour accéder à une valeur par sa position, utilisez `ser.iloc[pos]`.
Transfert de df vers dt avec noms : 15,8251 secondes
#Le code ici était : dt['NewCol2Test'] = df_results.iloc[:,dfColumnIndex]
FutureWarning : La méthode Series.__getitem__ qui traite les clés comme des positions est obsolète. Dans une version ultérieure, les clés entières seront toujours traitées comme des étiquettes (conformément au comportement des DataFrames). Pour accéder à une valeur par sa position, utilisez `ser.iloc[pos]`.
Je ne comprends pas pourquoi cet avertissement s'affichait encore lorsque j'utilisais iloc.
Temps de transfert de df à dt avec iloc : 16,0874 secondes
#Le code ici était : dt['NewCol3Test'] = dt_results[dfColumnIndex]
Temps de transfert de l'index dt vers le nom dt : 14,5659 secondes
#Le code ici était : dt[NewColumnIndex] = dt_results[dfColumnIndex]
Temps de transfert de l'index dt à l'index dt : 14,4699 secondes
#Le code ici était :
jmp.run_jsl('dt << Début de la mise à jour des données ;')
dt['NewCol5Test'] = dt_results[dfColumnIndex]
jmp.run_jsl('dt << Fin de la mise à jour des données ;')
#Résultat d'avertissement/d'erreur :
"Nom non résolu : dt lors de l'accès ou de l'évaluation de 'dt', dt/*###*/
à la ligne 1
Nom non résolu : dt lors de l'accès ou de l'évaluation de 'dt', dt/*###*/
à la ligne 1"
#Cette impression se trouvait en fait sur la même ligne que le deuxième message d'erreur « à la ligne 1 ».
Transfert dt vers dt avec indices enveloppés dans une mise à jour de début/fin : 14,3627 secondes
#Résumé final du temps d'exécution sur 100 000 lignes.
Durée totale d'exécution : 77,0904 secondes
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculenregistrez vos données (*) avant d'exécuter ce code une seconde fois (**) - ou activez la mise à jour des données de début/fin !
import jmp
import numpy as np
dt = jmp.open(jmp.SAMPLE_DATA + "Wafer Stacked.jmp")
jmp.globals['jdt'] = dt
jmp.run_jsl('Graph Builder( Variables( Y( :defects ) ), Elements( Bar( Y, Label( "Label by Value" ) ) ))');
# jmp.run_jsl('jdt << Begin Data Update;')
dt[ 5 ] = [np.random.randint(1000)]*177875
# jmp.run_jsl('jdt << End Data Update;')
(*) Je plaisante, vous ne perdrez pas vos données - prenez un café et attendez que JMP ait terminé.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calcul
@hogi a écrit :
... une deuxième fois (**)
(**) TS - 00251136
@Dahlia_Watkins a remarqué que parfois, il faut exécuter le code deux fois pour que le problème de vitesse se manifeste.
Il semblerait qu'il s'agisse d'un problème de synchronisation.
Peut-être : lors de la première exécution du code, le graphique n’est pas créé tant que Python n’a pas terminé la mise à jour des données ligne par ligne.
modifier:
En réalité, le graphique n'est pas nécessaire en tant qu'élément interactif pour ralentir la mise à jour des données Python.
D'autres exemples sans éléments interactifs sont disponibles dans les articles ci-dessous.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculJ'ai ajouté le sujet à la section Attention : Endroits où Jmp fait quelque chose d'inattendu
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculConcernant le problème initial : « accès lent aux données s’il y a une nouvelle colonne »
Voici un exemple illustratif :
import jmp
dt = jmp.DataTable('dt_new', 50000)
col = dt.new_column("newCol")
# --------- cut here to make it slow - why? -------------
dt[ 0 ] = [1]*50000
Découpée en 2 étapes, la mise à jour des 50 000 entrées prendra plusieurs secondes à JMP.
déroutant:
Lorsque les deux blocs sont exécutés en une seule fois, JMP ne rencontre aucun problème.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculOutre les solutions de contournement mentionnées dans le message de @Paul_Nelson , je pensais qu'il en existait d'autres, comme :
- Utilisez JSL pour créer la colonne / le tableau de données
- Utilisez JSL pour remplir la colonne avec des valeurs fictives.
- Utilisez JSL pour enregistrer le tableau de données, fermez-le et rouvrez-le.
Beaucoup d'entre elles paraissent attrayantes au premier abord, mais c'est trompeur.
La vitesse élevée s'explique simplement par le fait que les mêmes valeurs sont réécrites dans la colonne et que JMP ne déclenche pas d'« alerte de mise à jour des données » :
par exemple
jmp.globals['jdt'] = dt
jmp.run_jsl('''
nc = n cols(jdt);
Column(jdt,nc) << set each value(1)
''');
nc = dt.ncols
data = [1]*50000
dt[ nc - 1 ] =data
Le même miracle via Python :
# 1st: slow
nc = dt.ncols
dt[ nc - 1 ] = range(50000)
# fast ! (same values!)
dt[ nc - 1 ] = range(50000)
# new values: slow again
dt[ nc - 1 ] = [5]*50000
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculIl est possible de configurer un déclencheur pour recevoir une notification lorsque JMP détecte une mise à jour des données.
import jmp
dt = jmp.open(jmp.SAMPLE_DATA + "Big Class.jmp")
jmp.run_jsl('''
New Column( "trigger",
Formula(
If( Row() == 1,
Try( Caption( Char( ::i=::i+1 ) ), ::i = 1 )
);
:age;i
)
)
''')
dt[ 1 ] = range(40)
dt[ 1 ] = range(40) # no data update !
dt[ 1 ] = [2]*40
# for loop without begin/end data update -> finished before JMP notices the data update
jmp.run_jsl('''
for each row(:age = row());
wait(5);
''')
# for loop without begin/end data update - and some delay to give JMP the time to notice:
jmp.run_jsl('''
for each row(:age = 2*row();wait(0))
''')
Il n'y a donc effectivement pas de « mise à jour des données » lorsque les valeurs d'origine et les nouvelles valeurs sont identiques.
Mise en place pour lutter contre les boucles infinies ? Génial !
Intéressant,
import jmp
dt = jmp.open(jmp.SAMPLE_DATA + "Wafer Stacked.jmp")
jmp.run_jsl('''
delete symbols(::i)
New Column( "trigger",
Formula(
If( Row() == 1,
Try( Caption( Char( ::i=::i+1 ) ), ::i = 1 )
);
:Y_Die;i
)
)
''')
nr = dt.nrows
dt[ 4 ] = range(nr)
Cela prend plus d'une minute - Et je compte jusqu'à 2.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calcul
@Paul_Nelson wrote:
...
Most likely we will want to do support this from Python. Probably using a with block to suspend the UI updates of the table when filling / updating large number of rows.
Excellente idée !
Veuillez veiller à réactiver l'interactivité même si Python génère une erreur dans le bloc « with ».
Autre solution :
Veuillez ajouter un indicateur à la grille de données pour signaler quand l'interactivité est désactivée en raison d'un problème.
commencer la mise à jour des données sans terminer la mise à jour des données .
Indicateur : l’interactivité est désactivée pour ce tableau de données
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculRésultats des articles précédents - résumés en :
import jmp
# open data table and wait for the "Interactivity Manager" to get active
jmp.run_jsl('''
dt = new table("test", add rows(100000), new column ("col"));
Python send(dt);
wait(0) // disable the delay to make it fast
'''
);
nr=dt.nrows
# Python data update: slow!
dt[ 0 ] = range(nr)
# --- run step by step: -----
# same values: fast
dt[ 0 ] = range(nr)
#new values: slow
dt[ 0 ] = [1]*nr
La mise à jour d'une colonne JSL via Python est très lente.
Exceptions :
- accès en écriture immédiatement après la création/l'ouverture de la table de données (avant l'activation d'un quelconque « gestionnaire d'interactivité »)
- Aucune mise à jour (les valeurs restent inchangées).
et les solutions de contournement mentionnées dans le message de @Paul_Nelson :
- tables de données privées
- Mise à jour des données Python encadrée par Mise à jour des données de début/fin JSL()
Accès rapide aux données Python - grâce au support de JSL ; )
Je suppose que ces problèmes sont suffisamment importants pour être résolus dans la prochaine version « .x »…
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculDans le second cas, il faut impérativement une table privée (visibility='Private'). Une table « invisible » possède toujours une interface graphique, même masquée, et reste donc lente à s'afficher car les mises à jour de l'interface ont lieu à chaque modification de cellule.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculOui, c'est important. Nous travaillons effectivement à une solution. Nous souhaitons que les performances sous Python soient telles que les utilisateurs préfèrent exécuter leurs programmes depuis Python sans avoir recours à des méthodes détournées pour obtenir de meilleures performances.
Je suis surpris que cela n'ait pas été détecté dans JMP 18 ni lors des tests EA de JMP 19. L'objet `jmp.DataTable` est en réalité la table de données JSL. L'objet Python n'est qu'une référence à la table de données JMP sous-jacente, et nous appelons les méthodes internes de cette table. C'est pourquoi `run_jsl('dt << Begin Data Update')` est important. L'objectif de `jmp.run_jsl(''' code '''')` était de permettre l'appel de JSL depuis Python pour des fonctionnalités non encore implémentées, ou, comme ici, de corriger un oubli concernant les performances de mise à jour des colonnes.
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculC'est formidable d'apprendre que le problème est résolu.
Pourquoi cela n'a-t-il pas été détecté plus tôt ?
Je suppose que de nombreux utilisateurs se servent de Python pour l'importation et la gestion des données avant de les transférer vers JMP, où ils n'y accèdent pas directement via Python. S'ils utilisent les fonctions `get(dt)` [JSL] ou `from_dataframe()` [Python], ils ne rencontreront pas ce problème.
Avertissement : transfert colonne par colonne comme dans « Premiers pas avec l’intégration Python dans JMP 18 ».
Cela dépend ici de la taille du tableau de données. Si le tableau est suffisamment petit, les nouvelles colonnes sont ajoutées avant l'activation du « Gestionnaire d'interactivité ».
Lorsque nous avons détecté le problème de notre côté, nous avons eu accès à JMP19EA et avons été heureux de constater que nous pouvions accélérer la génération du tableau via from_dataframe() - avec l'avantage supplémentaire d'un code beaucoup plus simple.
En revanche : le problème se manifeste lorsque Python est utilisé pour mettre à jour des colonnes individuelles d'une table de données JMP existante, comme dans JMPyFacade : Bridging JMP and Python for Seamless Engaging Analysis . En tant que spécialiste JSL, @jthi a sans aucun doute ajouté les données de fusion de table privée nécessaires ; une solution de contournement efficace sans trop se poser de questions ; )
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculInformations partagées aujourd'hui dans le Scripters Club :
le problème de vitesse avec
dt[ index ] = list_like_object
Ce problème sera corrigé dans JMP 19.0.3 
Re : Python dans JMP : conversion d’une colonne de dataframe en colonne de datatable : bonnes pratiques et implications sur la vitesse de calculDisponible dès maintenant :
