594751_de-DE

liliconcom

So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Hallo zusammen,

 

Ich habe eine ziemlich einfache Frage, kann aber im Forum keine genaue Antwort finden. Hier ist meine Beispieldatentabelle:

 

Im Grunde hat es 4 Spalten, und ich muss jedes der aus „Gruppe 1“ und „Gruppe 2“ generierten Kombinationselemente durchlaufen, aber genau dann, wenn „Element“ # unterschiedlich ist, dann öffne den gesamten Dateipfad in der Spalte „Pfad“. . Zum Beispiel haben wir in den ersten beiden Zeilen die Kombination „aA“ und weil die Elemente auch unterschiedlich sind, muss das Skript sowohl Dateipfad 1 als auch 2 öffnen.

Datenmischung und -bereinigungBetreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Ja, das war tatsächlich sehr nützlich. Die Variable „file_list“ war verwirrend, da sie zum Öffnen der Dateien nicht unbedingt erforderlich ist (aber ich gehe davon aus, dass sie später beispielsweise beim erneuten Schließen aller Dateien (?) oder bei einer anderen Manipulation nützlich ist). Ich muss zugeben, dass ich auch einige Zeit gebraucht habe, um mich mit der Variable „file_path“ vertraut zu machen, die bei jeder Iteration einem anderen Dateipfad zugewiesen wird, und dass es keine Rolle spielt, wie sie heißt. (In meinem Kopf interpretiere ich es jetzt einfach als ein Vehikel, das einen Dateipfad nach dem anderen aus der Liste „filepaths_to_open“ auswählt und den Benutzer „etwas“ damit machen lässt.)

 

Danke schön! Jede Woche ist ein winziger Wissenszuwachs besser als gar keiner.

 

Ps: Das Folgende konnte ich nur schreiben, weil ich Ihre Erklärungen verstanden habe. Wieder sehr nützlich.

 

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 ) );

 

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Ich denke, diese sind am einfachsten zu verstehen, wenn man ein Demo-Skript schreibt (ich habe „For Each“ ein wenig modifiziert, um idx hinzuzufügen, das macht es vielleicht etwas einfacher, zu verstehen, wie es funktioniert)

 

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);
);

 

• Ich verwende „file_list“, um die Verweise auf die Datentabellen zu sammeln, die geöffnet werden (ich benötige die Dateipfade nicht, da ich sie bereits in „filepaths_to_open“ habe, aber ich habe keine Verweise).
• „Open(file_path)“ gibt einen Verweis auf die geöffnete Datei zurück und „Insert Into“ fügt diesen Verweis dann zur Dateiliste hinzu.
• Der {Dateipfad} kommt von how Für jede Funktion sollte benutzt werden. Grundsätzlich wird eine Schleife über filepaths_to_open durchgeführt und jedes Element (einzeln) in der Variablen file_path zurückgegeben.

 

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")};

Ich hoffe, einige der Fragen beantworten zu können.

 

 

 

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

@jthi Ich möchte nur ein paar Fragen zum letzten Teil des Codes stellen, das heißt, ich verstehe ihn nicht.

 

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

 

 

 

file_list = {};

 

Dies ist eine leere Liste. Die Schleife füllt dies über Insert Into(file_list, Open(file_path)). Warum kann man nicht einfach die Liste verwenden, die bereits in filepaths_to_open enthalten ist? Außerdem verstehe ich nicht, wie Open(file_path) etwas in die Liste einfügt. Ist das nicht nur eine Funktion zum Öffnen einer Datei? Wie kann das Ganze zu einer Liste beitragen?

 

{file_path}

Das verstehe ich auch nicht. Ist das nur ein Platzhalter für die tatsächlichen Dateipfade?

 

Vielleicht haben Sie eine Referenz, die diese Dinge erklärt? Vielen Dank bereits im Voraus.

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Sie müssen die ValidFile-Berechnungen und möglicherweise die Zeilenauswahl ändern, je nachdem, wie Sie die ValidFile-Prüfung erstellen.

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
 );
));

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

@jthi , ordentlich, wie immer. Gutes Lernen, danke.

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Ich schaffe es, eine zu finden, indem ich eine weitere Spalte „Einzigartig“ erstelle:

 

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);

 

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Danke jthi! Eine letzte Frage: Wie soll ich die Formel weiter ändern, um sie zu ignorieren, wenn die Spalten g1, g2 und i nur eine Kombination gültiger Dateien haben?

 

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Ich habe meine Nachricht bearbeitet, um die alte Variable umzubenennen. Wir addieren keine Zeichenspalten, sondern verwenden sie aus der Gruppierung (). Und wir verwenden 1, sodass wir etwas haben, das sich für jede Zeile in der Gruppe um 1 erhöht. Es kann eine gute Idee sein, mithilfe dieser Funktionen verschiedene Arten von Formeln zu erstellen, um deren Funktionsweise leichter zu verstehen. Der Skriptindex bietet auch einige Beispiele.

Col Sum(name,)

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Hallo jthi,

 

Vielen Dank für eine so tolle Antwort mit 3 verschiedenen Optionen. Eine Randbemerkung ist, dass ich „1“ aus der Variablen rows_to_open1 entfernen muss, damit der Code ausgeführt werden kann. Wenn Sie diesen Tippfehler zum späteren Nachschlagen korrigieren könnten, wäre das großartig!

 

Ansonsten habe ich eine Frage zu Ihrer Antwort. Welchen Zweck hat der Wert „1“ in Col Sum, Col Cumulative Sum und Col Max(Col Sum)? Und ich verstehe nicht, warum wir den Zeichenwert aus den Spalten g1 und g2 summieren können?

 

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Hallo Ressel,

 

Ich habe Ihre Lösung ausprobiert, tatsächlich wurde sie gedruckt „Dateipfad6“ zweimal, wie Sie erwähnt haben. Ein weiteres Problem, das ich gesehen habe, ist, dass die letzte Zeile („Dateipfad 6“) gedruckt wird, wenn ich absichtlich den Elementwert der Zeile 5 von 5 auf 7 ändere, um zwei identische Zeilen zu haben. Gibt es eine Möglichkeit, das zu vermeiden? Ich sehe eine alternative for-Schleife von jthi, die ebenfalls das gleiche Problem hat.

 

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

@Ressel

Ich denke, es wäre am einfachsten, die Schleifenstruktur zu überdenken, aber Sie könnten die aktuelle Struktur auch so gestalten, wie Sie es möchten, ohne doppeltes Drucken: Führen Sie eine Liste dessen, was gedruckt wurde, oder finden Sie eine zusätzliche Logik, um dies zu verhindern vom Geschehen. Ich denke, die folgende Idee sollte funktionieren:

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 );
);

Hier würden Sie zum Beispiel nicht den letzten Wert durchlaufen, sondern prüfen, ob der nächste Wert der letzte wäre. Wenn ja, dann drucken Sie ihn auch aus (wenn Sie die aktuellen Zeilen gedruckt haben).

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Ich bin mir nicht ganz sicher, ob ich das Problem richtig verstehe, aber unten sind drei verschiedene Optionen aufgeführt: Col Sum/Col Cumulative Sum und 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));
);

Die Idee ist, dass wir die Zeilen auswählen, in denen ValidFile 1 ist, und diese Dateien dann öffnen. Dieses Bild zeigt die Berechnungen für die drei verschiedenen Formeln.

 

Bearbeiten:

Alte Referenz korrigiert rows_to_open1 Zu rows_to_open

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Bitte untersuchen Sie NHooseK Matrix() und prüfen Sie, ob es für Sie geeignet ist.Im Skriptindex wird es wie folgt beschrieben: Erstellt eine Matrix aus nChooseK(n,k) Zeilen und K Spalten, die alle Kombinationen von k ganzen Zahlen von 1 bis n bilden.

 

Ich frage mich, ob es geändert werden kann, um mit Zeichendatentypen zu arbeiten.

 

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]

Betreff: So durchlaufen Sie Zeilen aus Gruppen, die aus zwei Spalten bestehen

Hallo, das Folgende beginnt zumindest damit, was Sie tun möchten. Sie müssen nur das „ Print( dtTemp:path[j], dtTemp:path[j + 1] )" Teil mit der Funktion zum Öffnen einer Datei.

Leider gibt dieses Skript jedoch so, wie ich es geschrieben habe, „Dateipfad 6“ zweimal im Protokoll aus, sodass es bei entsprechender Änderung auch „Dateipfad6“ zweimal öffnet. Ich bin mir sicher, dass es eine Möglichkeit gibt, das zu umgehen (z. B. zu prüfen, ob ein Dateipfad bereits geöffnet wurde), aber hier wird es langsam spät. Wie auch immer, wenn ich herausgefunden habe, wie ich auch den Rest erledigen kann, lasse ich es Sie wissen. Feedback ist willkommen!

 

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 );
);