référence de colonne robusteAprès quelques minutes de codage avec JSL, les utilisateurs s'interrogent sur des objets étranges comme :sexe dans
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
x = :sex
Les utilisateurs experts ont une certaine expérience avec de telles références de colonnes et les utilisent tout le temps.
Mais qu'est-ce que :sex ? Dt:sex est-il plus robuste ? Où puis-je trouver une documentation ?
Collectons et partageons quelques idées. N'hésitez pas à partager vos réflexions et à corriger mes publications si vous trouvez des erreurs…
mes 5 centimes:
Automatisation et scriptsRe: référence de colonne robusteEn JSL, une même référence de colonne :sexe (ou dt:sexe ) peut être utilisée de deux manières :
1) en référence à une colonne
:sex << get name;
Data Table( "Big Class Families" ) << Distribution( Nominal Distribution( Column( :sex ) ));
... et n° 2
pour récupérer l'entrée de la ligne actuelle dans cette colonne, comme dans :
[modifier] : non !
"À utiliser dans les formules de colonnes - et peut généralement être considéré comme la 'valeur de la ligne actuelle'.
Mais il existe de nombreux autres cas qui nécessitent également ce type de :sexe
</CODE></PRE>
<BR />
<P>Remarque : dans les formules de colonnes, les approches suivantes sont équivalentes</P>
<PRE><CODE class=" language-jsl">new column("s", formula (:sex));
new column("s", formula (:sex[]));
new column("s", formula (:sex[row()]))
row()=5;
s=:sex; // value of the current row
// other cases:
lag(:sex,1); // value of the previous row
Col Mean(:height, :age)); // mean :height of rows with same :age
Pour créer un tel objet à partir d'une chaîne de caractères, on a deux options :
column name = "sex";
col= Column (column name); // for the first one (accessing the column)
val = As Column (column name) // for the second one (accessing the column in formulas)
En fait, il existe une troisième option très intéressante, que j'ai découverte grâce à @jthi :
the universal column reference = Name Expr(As Column(column name))
Il peut être utilisé comme :sexe pour les deux approches : référencer la colonne et accéder à l’entrée de la ligne actuelle.
Column() vs As Column() vs datable:column vs dt:As name("column")
Re : référence de colonne robuste:sexe semble fragile - que se passe-t-il lorsque l'utilisateur modifie le nom de la colonne ?
Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
x = Name Expr(As column("name"));
Show(Name Expr(x)); // : name
:name << set name("The name");
Show(Name Expr(x)); // :The name
Waouh, génial ! Pas fragile du tout !
Re : référence de colonne robusteEt quand l'utilisateur modifie la table de données ?
Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
x = Name Expr(As column("name"));
Show(Name Expr(x));
x[1] = "Marker";
:name << set name("The name");
dt = Open( "$SAMPLE_DATA/Big Class Families.jmp" );
Show(Name Expr(x));
Show(x[1])
L'innocent :sexe sait même à quelle table de données il appartient. Merveilleux !
Re : référence de colonne robustePassons maintenant d'une colonne à deux colonnes :
myList1 = {:name,:sex,:age};
Une manière très compliquée et inutile de créer cette liste est :
myList2 = Eval List({Name Expr(As column(:name)),Name Expr(As column(:sex)),Name Expr(As column(:age))});
Re : référence de colonne robusteinutile?
vous remarquez déjà la grande différence lorsque vous essayez d'exécuter le code ci-dessus sans
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
La première ligne ne tient pas compte de l'absence de table de données ouverte. À l'exécution de la deuxième ligne, JMP affichera un message d'erreur :
Encore mieux : lorsque la liste est créée avec la deuxième approche, les références de colonnes sont très robustes.
Indépendamment de la table de données actuelle, JMP ira à dt et utilisera les colonnes à partir de là :
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
myList1 = {:name,:sex,:age};
myList2 = Eval List({Name Expr(As column(:name)),Name Expr(As column(:sex)),Name Expr(As column(:age))});
dt2= Open( "$SAMPLE_DATA/Big Class Families.jmp" );
dt << Select Rows( [1] ) << Delete Rows; // now dt starts with Louise - there is no Katie anymore!
Show(Eval List(myList1), // Katie? why Katie!!!
Eval List(myList2)); // Louise -> works!
Comment ça marche ?
Show(Type(myList1[1]), Type(myList2[1]))
fournit plus d'informations :
La liste simple ( maListe1 ) contient " N ames " , *)
la liste compliquée ( maListe2 ) contient des « colonnes » **)
*) Lorsqu'un nom est évalué, JMP suit une règle spécifique pour déterminer ce que signifie ce nom :
https://www.jmp.com/support/help/en/19.0/#page/jmp/rules-for-resolving-names.shtml
Parmi les rôles, JMP recherchera une colonne dans la table de données actuelle ( dt2 ).
**) Pour une colonne , JMP doit simplement aller dans LA table de données (« dt ») et accéder à la colonne.
Très robuste !
Re : référence de colonne robusteName Expr(As column(:col))
c'est tellement cool!
Re : référence de colonne robusteLa fonction Column() fonctionne dans de nombreuses situations et est assez flexible en ce qui concerne le format du nom de la colonne.
Distribution(
Continuous Distribution( Column( :Random Normal )),
Continuous Distribution( Column( "Random Normal" )),
Continuous Distribution( Column( :"Random Normal"n )),
Continuous Distribution( Column( "Random Normal"n )),
Process Capability( 0 ) )
Re : référence de colonne robusteintéressant : lorsqu'on leur demande des listes de colonnes, les fonctions JSL renvoient des listes de noms , pas des listes de colonnes !
Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
colList = Eval List({Name Expr(As column("sex"))});
write(Name Expr(colList[1]), " is a ", // :sex
Type(Name Expr(colList[1])), "\!n"); // Column -> universal & robust
selectedCols = dt << select columns (:sex) << get selected columns;
write(Name Expr(selectedCols[1])," is a ", // : sex
Type(Name Expr(selectedCols[1])), "\!n"); // Name -> fragile
dt << Group Columns(Item Range( :sex, :height ),"myColGroup");
colsFromColumnGroup = dt << get column group("myColGroup");
Write(Name Expr(colsFromColumnGroup[1]), " is a ", // :sex
Type(Name Expr(colsFromColumnGroup[1])), "\!n"); // Name -> fragile
La différence entre Obtenir les noms des colonnes() et Obtenir les références de colonne() :
ColNames = dt << get column names; // default setting: returns names, not Strings
Write(Name Expr(ColNames[3]), " is a ", // sex (more or less the same as :sex)
Type(Name Expr(ColNames[3])), "\!n"); // Name -> fragile
ColRefs = dt << get column references;
Write(Name Expr(ColRefs[3]), " is a ", // Column("sex"
Type(Name Expr(ColRefs[3])), "\!n"); // Column -> robust, but not :sex, see below
et maintenant jouons avec la colonne puis demandons la valeur de :sexe dans la ligne 1 :
//hide the column
:sex << set name("hidden");
// who finds it?
row()=1;
Try(Show(Eval(ColList[1])), print(exception_msg));
Try(Show(Eval(colsFromColumnGroup[1])), print(exception_msg));
Try(Show(Eval(selectedCols[1])), print(exception_msg));
Try(Show(Eval(ColNames[3])), print(exception_msg));
Try(Show(Eval(ColRefs[3])), print(exception_msg));
Re : référence de colonne robusteMessage à retenir :
Avec l'apprentissage de
myList2 = Eval List({Name Expr(As column(:name)),Name Expr(As column(:sex)),Name Expr(As column(:age))});
nous pouvons convertir n'importe quelle liste fournie par JMP en une liste robuste de colonnes via
ColNames = dt << get column names;
colList = Transform Each({col}, ColNames, Name Expr(As Column (col)));
Re : référence de colonne robuste
@Byron_JMP wrote:
La fonction Column() fonctionne dans de nombreuses situations et est assez flexible en ce qui concerne le format du nom de la colonne.
Distribution(
Continuous Distribution( Column( :Random Normal )),
Continuous Distribution( Column( "Random Normal" )),
Continuous Distribution( Column( :"Random Normal"n )),
Continuous Distribution( Column( "Random Normal"n )),
Process Capability( 0 ) )
Salut @Byron_JMP , on peut s'amuser beaucoup avec Colonne() dans distribution()
Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
Distribution(Continuous Distribution( Column( :height )) );
Distribution(Continuous Distribution( Column( "height")) );
Une référence de colonne, un nom, voire une chaîne ! Tout fonctionne.
... jusqu'à ce que vous essayiez d'utiliser une colonne définie en dehors de la commande Distribution :
col = Column("height");
Show(col); // shows: it's a column
Distribution(Continuous Distribution(col));
Distribution(Continuous Distribution(Eval(col)));
Distribution(Continuous Distribution(Name Expr(col)));
On peut essayer toutes ces astuces ésotériques de gestion des expressions du type « Essayons-les toutes, l'une d'entre elles devrait fonctionner », mais aucune ne fonctionne !
Toujours le même indice, mais qu'est-ce que ça veut dire ?!?
La solution est très simple, mais elle peut prendre des heures si vous la cherchez au mauvais endroit.
Trouvez la solution par vous-même avant d'ouvrir 
:mano_con_el_dedo_índice_apuntando_hacia_abajo:
Voir plus...
Column( :height ) inside
Distribution continue()
apparence like
Colonne("hauteur") in
col = Colonne("hauteur");
But it is a
argument nommé - like
Formule() in
Nouvelle colonne (Formule(...)).
So the "obvious" solution is: keep the name of the named argument and place the column inside:
Distribution(Continuous Distribution(Column(col)));
Re : référence de colonne robusteMon approche est beaucoup plus simple. Je veille à construire ma liste de colonnes en fonction de l'objectif précis que je vise. Il m'arrive d'avoir plusieurs listes de colonnes dans différents formats.
Names Default To Here( 1 );
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
text = dt << Get Column Names();
quote = dt << Get Column Names( String );
colformat = dt << get column reference();
quote = dt << Get Column Names( String );
show(text, quote, colformat);
qui renvoie :
texte = {nom, âge, sexe, taille, poids};
quote = {"nom", "âge", "sexe", "taille", "poids"};
colformat = {Colonne("nom"), Colonne("âge"), Colonne("sexe"), Colonne("taille"), Colonne("poids")};
l'un des trois fonctionne généralement, même si je dois recourir à eval(parse())
Re : référence de colonne robusteEn gros, je suis d'accord. Avec quelques précautions, les noms ne sont pas très dangereux :
On peut se demander s'il est judicieux de renommer une colonne après avoir créé une liste de colonnes, puis se demander/se plaindre que l'ancien nom ne fonctionne plus.
Et lorsque vous travaillez avec deux tables, il faut s'assurer que la table de données correcte est la table de données actuelle().
Même chose avec les noms de colonnes :
On peut supposer que JMP gère correctement les noms de colonnes, même avec des majuscules et des espaces. [trouver le lien]
Ou bien on peut être prudent et suivre certaines règles (pas de collisions de noms, de variables et de noms de colonnes ; attention aux espaces, ...) et vivre la plupart du temps en toute sécurité sans problèmes.
Re : référence de colonne robusteSalut @Byron_JMP , pour être pointilleux...
obtenir les noms des colonnes() renvoie une liste de noms ; )
Re : référence de colonne robusteDécouverte importante – je viens d’éditer l’un des premiers messages !
J'espère que mes pensées sont compréhensibles - du moins pour certains utilisateurs comme @Craige_Hales .
Je suppose que ces utilisateurs partageront également mon étonnement/mon illumination/ma joie et/ou : aideront en confirmant que c'est comme ça, en fournissant une explication ou en apportant des corrections.
Jusqu'à présent, j'ai pensé à En tant que colonne (col) comme un moyen de récupérer la valeur de la ligne actuelle - en particulier par rapport à Colonne (col) pour « l'accès aux colonnes » (vous savez, comme dans Column(col) << obtenir le nom).
Avec l’implication inverse :
Chaque fois que j'utilise :col pour autre chose que la « valeur de la ligne actuelle », puis lorsque je veux la remplacer par une variable, je n'ai pas besoin d'utiliser Comme colonne() , je dois utiliser l'autre à la place , à savoir Colonne(col).
[Je dois admettre que j'ai également été intrigué par le nom :
Comme colonne () - pour la fonction qui fait l'inverse, obtenir non pas la colonne, mais la valeur de la ligne actuelle ? tu plaisantes ?
une autre pensée:
Si En tant que colonne (col) fonctionne dans de tels cas, c'est simplement parce que JMP corrige automatiquement l'erreur de l'utilisateur - ou à cause d'un effet ésotérique que tout le monde utilise mais que personne n'explique - comme dans Nom expr(Comme colonne(col))
Alors, je me sens très à l'aise maintenant après avoir découvert : ....]
Cette interprétation doit être erronée. Elle est déclenchée par un automatisme dans JMP qui pourrait suivre l'idée suivante :
Comme column(col) donne accès à la colonne .
Si la fonction ( Eval(Comme colonne() ...) )i est évaluée , elle est convertie en column(col)[], ou column(col)[row()], qui permet d'accéder à la valeur de la ligne courante. Si elle n'est pas évaluée, mais utilisée dans d'autres fonctions, elle donne accès à la colonne.
Pourquoi je pense que c'est comme ça ?
Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class Families.jmp" );
row()=10;
Lag(:height); // 60
Show(lag(Column ("height"),1)); // Column("height") !!!
Show(lag(As Column ("height"),1)); // 60 !!!
Col Mean(:height); // 6255
Col Mean(:height, :age); // 60.285...
Show(Col Mean(Column ("height"))); // 62.55 (why does it work? another automatism because it is used so often?)
Try(Show(Col Mean(Column ("height"), :age)),Print(exception_msg)); // !!!
Show(Col Mean(As Column ("height"), :age)); // 60.285...
[ déclenché par https://community.jmp.com/t5/Discussions/Using-numeric-objects-in-a-column-equation/mp/903939/highlight/true#M106270 ]
Re : référence de colonne robusteSur la base de cet apprentissage, j’ai une question spécifique :
Existe-t-il un aperçu complet de
- which functions act in the spirit of
Eval(:col), Where(:col=1) and Type(:col) ?
i.e. taking the column :col and l'interprétant comme:col[ligne()] ?
Voir plus...
rw = Row();
Where( :age == Column( "age" )[rw] );
- , et quelles fonctions traitent simplement la colonne comme une colonne - sans « ajouter [ligne] gratuitement » ?
comme Col médian(:col), Lag(:col,1)
Quel groupe a le plus de membres ?
Re : référence de colonne robusteJe ne pense pas que Col Mean fonctionne très bien dans un scénario.
Cependant, « 60,285714286 » est la valeur de la ligne 10, si la formule de colonne, Col Mean(:height,:age) a été appliquée dans une colonne de formule dans la table de données.
Et « 62,55 » est la valeur de la ligne 10 si elle se trouvait dans une colonne de formule avec Col Mean(;height).
Ce serait un très bon moyen d'obscurcir la recherche de valeurs dans une autre table, surtout si la table était privée.
Re : référence de colonne robusteDésolé, je ne suis pas sûr de comprendre.
Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class.jmp" , Private);
col median(dt:height);
vals= dt:height << get values();
vals=dt[0,"height"];
Median(vals);
