594751_fr-FR

liliconcom

Comment parcourir les lignes des groupes créés par 2 colonnes

Salut tout le monde,

 

J'ai une question assez simple mais je n'ai pas trouvé de réponse exacte sur le forum. Voici mon exemple de tableau de données :

 

Fondamentalement, il a 4 colonnes, et j'ai besoin de parcourir chacun des éléments combinés générés à partir de "groupe 1" et "groupe 2", mais si et seulement lorsque "élément" # est différent, ouvrez le chemin de tous les fichiers dans la colonne "chemin" . Par exemple, sur les 2 premières lignes, nous avons la combinaison "aA", et parce que les éléments sont également différents, le script doit ouvrir les chemins de fichier 1 et 2.

Fusion et nettoyage des donnéesRe : Comment parcourir les lignes des groupes créés par 2 colonnes

Oui, c'était en fait très utile. La variable file_list était déroutante, car elle n'est pas strictement nécessaire pour ouvrir les fichiers (mais; je suppose; qu'elle est utile plus tard lors de la fermeture de tous les fichiers (?), Par exemple, ou d'une autre manipulation). Je dois admettre qu'il m'a également fallu un certain temps pour comprendre la variable "file_path", qui est affectée à un chemin de fichier différent à chaque itération, et que peu importe son nom. (Dans ma tête, je l'interprète maintenant comme un véhicule qui sélectionne un chemin de fichier après l'autre dans la liste filepaths_to_open et permet à l'utilisateur de faire "quelque chose" avec.)

 

Merci! Chaque semaine, une petite augmentation de connaissances vaut mieux que rien du tout.

 

Ps : Je n'ai pu écrire ce qui suit que sur la base de ma compréhension de vos explications. Encore une fois, très utile.

 

Names Default To Here( 1 );

filepaths_to_open = {"$SAMPLE_DATA/Big Class.jmp", "$SAMPLE_DATA/Probe.jmp", "$SAMPLE_DATA/Iris.jmp"};

For Each( {file_path}, filepaths_to_open, Open( file_path ) );

 

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

Je pense que ceux-ci sont plus faciles à comprendre en écrivant un script de démonstration (j'ai un peu modifié For Each pour ajouter idx, cela pourrait faciliter un peu la compréhension de son fonctionnement)

 

Names Default To Here(1);

filepaths_to_open = {"$SAMPLE_DATA/Big Class.jmp", "$SAMPLE_DATA/Probe.jmp", "$SAMPLE_DATA/Iris.jmp"};
show(filepaths_to_open);
file_list = {};
show(file_list);
For Each({file_path, idx}, filepaths_to_open,
 show(idx, file_path);
 Insert Into(file_list, Open(file_path));
 show(file_list);
);

 

• J'utilise file_list pour collecter les références aux tables de données qui sont ouvertes (je n'ai pas besoin des chemins de fichiers car je les ai déjà dans le filepaths_to_open, mais je n'ai pas de références)
• Open(file_path) renverra une référence au fichier ouvert et Insert Into ajoutera ensuite cette référence à file_list.
• Le {filepath} vient de comment Pour chaque fonction Devrait être utilisé. Fondamentalement, il bouclera sur filepaths_to_open et renverra chaque élément (un par un) dans la variable file_path.

 

filepaths_to_open = {"$SAMPLE_DATA/Big Class.jmp", "$SAMPLE_DATA/Probe.jmp", "$SAMPLE_DATA/Iris.jmp"};
file_list = {};
idx = 1;
file_path = "$SAMPLE_DATA/Big Class.jmp";
file_list = {DataTable("Big Class")};
idx = 2;
file_path = "$SAMPLE_DATA/Probe.jmp";
file_list = {DataTable("Big Class"), DataTable("Probe")};
idx = 3;
file_path = "$SAMPLE_DATA/Iris.jmp";
file_list = {DataTable("Big Class"), DataTable("Probe"), DataTable("Iris")};

Espérons répondre à certaines des questions.

 

 

 

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

@jthi , je veux juste poser quelques questions concernant la dernière partie du code, c'est-à-dire que je ne le comprends pas.

 

file_list = {};
For Each({file_path}, filepaths_to_open,
 Insert Into(file_list, Open(file_path));
);

 

 

 

file_list = {};

 

Ceci est une liste vide. La boucle le remplira via Insert Into(file_list, Open(file_path)). Pourquoi ne peut-on pas simplement utiliser la liste déjà contenue dans filepaths_to_open ? De plus, je ne comprends pas comment Open(file_path) va insérer quelque chose dans la liste. N'est-ce pas juste une fonction pour ouvrir un fichier ? Comment tout cela peut-il contribuer à une liste ?

 

{file_path}

Ça, je ne comprends pas non plus. Est-ce juste un espace réservé pour les chemins de fichiers réels ?

 

Peut-être avez-vous une référence expliquant ces choses? Merci beaucoup déjà d'avance.

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

Vous devrez modifier les calculs ValidFile et éventuellement la sélection de lignes en fonction de la manière dont vous construisez la vérification ValidFile.

new_col = dt << New Column("ValidFile", Numeric, Continuous, << Set Each Value(
 If(Col Sum(1, :g1, :g2, :i) == 1 & Col Number(:i, :g1, :g2) > 1,
  1
 ,
  0
 );
));

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

@jthi , soigné, comme toujours. Bon apprentissage, merci.

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

Je parviens à en trouver un en créant une autre colonne, "Unique":

 

new_col = dt << New Column("Unique", Numeric, Continuous, << Set Each Value(
 Col Sum(1, :g1, :g2); 
));



rows_to_open = dt << Get Rows Where(:ValidFile == 1 & :Unique != 1);

 

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

Merci jti ! Une dernière question, comment suis-je censé modifier davantage la formule pour ignorer si ces colonnes g1, g2 et i n'ont qu'une seule combinaison de fichiers valides ?

 

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

J'ai édité mon message pour renommer l'ancienne variable. Nous n'ajoutons pas de colonnes de caractères, nous les utilisons à partir du regroupement (). Et nous utilisons 1 donc nous avons quelque chose qui augmentera de 1 pour chaque ligne du groupe. Il peut être judicieux de créer différents types de formules en utilisant ces fonctions pour faciliter la compréhension de leur fonctionnement. L'index de script fournit également quelques exemples.

Col Somme(nom,)

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

Salut jti,

 

Merci pour cette excellente réponse avec 3 options différentes. L'une des notes latérales est que je dois supprimer "1" de la variable rows_to_open1 afin de faire fonctionner le code. Si vous pouviez corriger cette faute de frappe pour référence future, ce serait formidable !

 

Autre que cela, j'ai une question liée à votre réponse. Quel est le but de la valeur "1" dans chacun des Col Sum, Col Cumulative Sum et Col Max(Col Sum ? Et je ne comprends pas pourquoi nous pouvons additionner la valeur des caractères des colonnes g1 et g2 ?

 

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

Bonjour Ressel,

 

J'ai essayé votre solution, en effet elle a imprimé "file path6" deux fois comme vous l'avez mentionné. Un autre problème que j'ai vu est que lorsque j'ai délibérément changé la valeur de l'élément de la ligne 5 de 5 à 7 afin d'avoir 2 lignes identiques, la dernière ligne est imprimée ("chemin du fichier 6"). Existe-t-il un moyen d'éviter cela? Je vois une alternative pour la boucle de jthi qui a également le même problème.

 

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

@Ressel

Je pense qu'il serait plus facile de repenser la structure en boucle, mais vous pouvez faire en sorte que la structure actuelle fonctionne également comme vous le souhaitez sans double impression : conservez une liste de ce qui a été imprimé ou trouvez une sorte de logique supplémentaire pour éviter cela. de se produire. Je pense que l'idée ci-dessous devrait fonctionner:

For( i = 1, i <= N Items( PairedGroupList ), i++,
 dt << Select Where( :PairedGroup == PairedGroupList[i] );
 dtTemp = dt << Subset( Invisible, Selected Rows );
 For( j = 1, j < N Rows( dtTemp ), j++,
  If( dtTemp:item[j] != dtTemp:item[j + 1],
   Print(dtTemp:path[j]);
   If(j + 1 == N Rows( dtTemp ),
    Print(dtTemp:path[j + 1]);
   )
  )
 );
 Close( dtTemp, no save );
);

Par exemple, ici, vous ne boucleriez pas sur la dernière valeur, mais vérifiez si la valeur suivante serait la dernière, si elle le serait, imprimez-la également (si vous avez imprimé celle des lignes actuelles).

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

Je ne suis pas exactement sûr de bien comprendre le problème, mais vous trouverez ci-dessous trois options différentes utilisant Col Sum/Col Cumulative Sum et Col Max(ColSum())

Names Default To Here(1);

dt = New Table("Untitled",
 Add Rows(8),
 Compress File When Saved(1),
 New Column("g1", Character, "Nominal", Set Values({"a", "a", "a", "a", "a", "c", "c", "c"})),
 New Column("g2", Character, "Nominal", Set Values({"A", "A", "B", "B", "B", "A", "A", "A"})),
 New Column("i", Numeric, "Continuous", Format("Best", 12), Set Values([1, 3, 2, 4, 4, 5, 7, 9])),
 New Column("p",
  Character,
  "Nominal",
  Set Values({"filepath1", "filepath2", "filepath3", "filepath4", "filepath4.1", "filepath5", "filepath6", "filepath7"})
 )
);

// depending how we handle duplicated g1+g2+i we would use different formulas
// if we won't open any
new_col = dt << New Column("ValidFile", Numeric, Continuous, << Set Each Value(
 Col Sum(1, :g1, :g2, :i); 
));

/*
// if we open the first one
new_col = dt << New Column("ValidFile", Numeric, Continuous, << Set Each Value(
 Col Cumulative Sum(1, :g1, :g2, :i); 
));
*/

/*
// if we don't open g1+g2 at all
new_col = dt << New Column("ValidFile", Numeric, Continuous, << Set Each Value(
 Col Max(Col Sum(1, :g1, :g2, :i), :g1, :g2)
));
*/

rows_to_open = dt << Get Rows Where(:ValidFile == 1);
filepaths_to_open = dt[rows_to_open, "p"];
show(filepaths_to_open);
// dt << Delete Column(new_col);

// To open files loop over filepaths_to_open
stop();
file_list = {};
For Each({file_path}, filepaths_to_open,
 Insert Into(file_list, Open(file_path));
);

L'idée est que nous sélectionnons les lignes où ValidFile est 1, puis ouvrons ces fichiers. Cette image montre les calculs pour les trois formules différentes.

 

Modifier:

Correction de l'ancienne référence rows_to_open1 à lignes_à_ouvrir

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

Veuillez enquêter sur NChooseK Matrix() et voir si cela vous convient.Dans l'index de script, il est décrit comme suit : Crée une matrice de nChooseK(n,k) lignes et K colonnes formant toutes les combinaisons de k entiers de 1 à n.

 

Je me demande s'il peut être modifié pour fonctionner avec des types de données de caractères ?

 

Names Default To Here( 1 );
Print( NChooseK Matrix( 5, 3 ) );

__________________________
Prints:
[ 1 2 3, 
 1 2 4, 
 1 2 5, 
 1 3 4, 
 1 3 5, 
 1 4 5, 
 2 3 4, 
 2 3 5, 
 2 4 5, 
 3 4 5]

Re : Comment parcourir les lignes des groupes créés par 2 colonnes

Salut, le ci-dessous commence au moins ce que vous voulez faire. Vous n'aurez qu'à changer le " Print( dtTemp:path[j], dtTemp:path[j + 1] )" partie avec la fonction pour ouvrir un fichier.

Malheureusement, cependant, la façon dont je l'ai écrit, ce script imprime deux fois "chemin de fichier 6" dans le journal, il ouvrira donc également "chemin de fichier 6" deux fois s'il est modifié en conséquence. Je suis sûr qu'il existe un moyen de contourner cela (comme vérifier si un chemin de fichier a déjà été ouvert peut-être), mais il se fait tard ici. Quoi qu'il en soit, si je trouve également comment faire le reste, je vous le ferai savoir. Les commentaires sont appréciés !

 

dt = New Table( "today's challenge",
 Add Rows( 7 ),
 New Column( "group1",
  Character,
  "Nominal",
  Set Values( {"a", "a", "a", "a", "c", "c", "c"} )
 ),
 New Column( "group2",
  Character,
  "Nominal",
  Set Values( {"A", "A", "B", "B", "A", "A", "A"} ),
  Set Display Width( 70 )
 ),
 New Column( "item",
  Numeric,
  "Continuous",
  Format( "Best", 12 ),
  Set Values( [1, 3, 2, 4, 5, 7, 9] )
 ),
 New Column( "path",
  Character,
  "Nominal",
  Set Selected,
  Set Values(
   {"file path 1", "file path 2", "file path 3", "file path 4",
   "file path 5", "file path 6", "file path 7"}
  )
 )
);

dt << New Column( "PairedGroup", formula( :group1 || :group2 ) );

PairedGroupList = Associative Array( dt:PairedGroup ) << Get Keys;

dt << Clear Column Selection;

For( i = 1, i <= N Items( PairedGroupList ), i++,
 dt << Select Where( :PairedGroup == PairedGroupList[i] );
 dtTemp = dt << Subset( Invisible, Selected Rows );
 For( j = 1, j <= N Rows( dtTemp ), j++,
  If( dtTemp:item[j] != dtTemp:item[j + 1],
   Print( dtTemp:path[j], dtTemp:path[j + 1] )
  )
 );
 Close( dtTemp, no save );
);