trasporre un elenco di elenchi (riepilogare ()) senza un ciclo forQualcuno può pensare a un modo per trasporre un elenco di liste come quello che viene dal seguente script in modo che ogni riga sia raggruppata insieme anziché per colonna.
So che posso farlo con un ciclo for, ma mi chiedo se c'è qualcosa di meglio o di meno brutale.
Names default to here(1);
dt = open("$SAMPLE_DATA\Big Class.jmp");
summarize(dt, d = By(:age, :sex));
rows = nitems(d);
cols = nitems(d[1]);
show(rows, cols);
// rows = 2;
// cols = 12;
Per questo voglio cambiarlo da 2 liste di 12 a 12 liste di 2.
Aggiungendo alcune persone che penso possano piacere a questa sfida o avere già qualcosa.
@pmroz , @Justin_Chilton , @ gzmorgan0 , @msharp , @Signorina
Ri: trasporre una lista di liste (riepilogare ()) senza un ciclo forRipeti: MS la tua soluzione ripetitiva è molto bella. 
Ri: trasporre una lista di liste (riepilogare ()) senza un ciclo forMS, ripetere la sessione è molto bello !!
Ri: trasporre una lista di liste (riepilogare ()) senza un ciclo forNames default to here(1);
dt = open("$SAMPLE_DATA\Big Class.jmp");
//Since column formulas are by row, it uses a built in For Loop this maintains the table values but requires a table....<BR />//This is not a solution for two generic lists<BR />
dt << New Column( "Age,Sex",
Expression,
"None",
Formula( Eval List( {:age[Empty()], :sex[Empty()]} ) ),
Suppress Eval
);
myList= (Associative Array(Column("Age,Sex")) <<GET keys=""></GET>Ri: trasporre una lista di liste (riepilogare ()) senza un ciclo forUsando i nuovi ganci Python in JMP 14 pensavo di poter imbrogliare. Funziona principalmente.
Names Default To Here(1);
dt = Open("$SAMPLE_DATA\Big Class.jmp");
Summarize(dt, d = By(:age, :sex));
Python Init();
ml = Python Execute(
{d},
{x, d},
"\[
import numpy as np
x = np.transpose(d) # matrix product
print('x=', x)
]\"
);
Show( x, d );
Python Term();Ri: trasporre una lista di liste (riepilogare ()) senza un ciclo forEcco un'idea basata su Repeat (). Una funzione che è essenzialmente un ciclo ma restituisce la lista direttamente, senza la necessità di eseguire il ciclo di tutti i compiti.
Nelle versioni precedenti di JMP ho sperimentato che Repeat () era molto più veloce di For () nella creazione di elenchi, ma penso che sia stato "risolto" in JMP 13.
Names Default To Here(1);
dt = Open("$SAMPLE_DATA\Big Class.jmp");
Summarize(dt, d = By(:age, :sex));
transposed_d = Local({i = 0}, Repeat({i++ ; Eval List({d[1][i], d[2][i]})}, N Items(d[1])));
Ri: trasporre una lista di liste (riepilogare ()) senza un ciclo forHo trovato questo modo, ma è più lento. 
Names default to here(1);
dt = open("$SAMPLE_DATA\Big Class.jmp")
summarize(dt, list = By(:age, :sex));
rows = nitems(list[1]);
cols = nitems(list);
list_flat = parse("{"||substitute(char(list), "}", "", "{", "")||"}");
insert into(list_flat, repeat({"@@@"}, rows));
list_sort = list_flat[ shape(1::rows*(cols+1), cols+1)` ];
remove from(list_sort, -1);
t_list = parse("{"||
substitute(char(list_sort),
", \!"@@@\!",", "},{"
)
||"}");
Ri: trasporre una lista di liste (riepilogare ()) senza un ciclo forIl ciclo nested for di PMROZ è probabilmente il migliore. Se stai cercando alternative, posso pensare a due modi aggiuntivi.
Se i tuoi dati sono tutti numerici potresti usare matrici che sarebbero piuttosto lisce. Tuttavia, questo non ha loop, l'elenco di liste restituite da riepiloga restituisce tutti i valori dei caratteri, anche per le colonne numeriche. Il che significa che è necessario un ciclo annidato per convertire tutto in numeri (se tutti i dati sono colonne) in modo che non siano utili per il tuo problema.
La seconda opzione è convertire l'elenco di elenchi in una tabella di dati, trasporre quello, quindi tornare indietro. Ciò richiede due cicli for per le conversioni (non sono a conoscenza di alcun modo lucido per convertire tra liste annidate e tabelle dati). Questo è probabilmente più lento della soluzione di PMROZ poiché si ha il sovraccarico della creazione di una tabella di dati, tuttavia è probabilmente più veloce per i set di dati più grandi. Se in realtà non converti nuovamente in un elenco di elenchi e invece utilizzi la tabella di dati trasposti, potresti anche risparmiare un po 'di tempo.
Names default to here(1);
dt = open("$SAMPLE_DATA\Big Class.jmp");
summarize(dt, d = By(:age, :sex));
rows = nitems(d);
cols = nitems(d[1]);
show(rows, cols);
//Turn List of Lists into DT ()
dtLL = New Table("Lists of Lists");
for(i=1,i<=nitems(d),i++,
dtLL << New Column(char(i), Character, Nominal, Values(d[i]));
);
//Transpose DT
cols = dtLL << Get Column Names;
dtT = dtLL << Transpose(columns(cols));
//Turn back into list of lists
trans_list = {};
for(i=2,i<=ncols(dtT),i++,
trans_list[i] = column(dtT,i) <<GET values=""></GET>Ri: trasporre una lista di liste (riepilogare ()) senza un ciclo forDOH! Suppongo che potresti scrivere i risultati su una tabella, trasporre ciò e creare liste dalla tabella. Potrebbe comunque avere un ciclo for in là. Hmmmm ...
Ri: trasporre una lista di liste (riepilogare ()) senza un ciclo forMi sento come se non avessi letto la parte senza loop for. : P
Ri: trasporre una lista di liste (riepilogare ()) senza un ciclo forNon è un orologio d'oro, ma funziona.
Names default to here(1);
dt = open("$SAMPLE_DATA\Big Class.jmp");
summarize(dt, d = By(:age, :sex));
nrows = nitems(d);
ncols = nitems(d[1]);
show(nrows, ncols);
// nrows = 2;
// ncols = 12;
trans_list = {};
for (i = 1, i <= ncols, i++,
one_list = {};
for (k = 1, k <= nrows, k++,
one_list[k] = d[k][i];
);
trans_list[i] = one_list;
);
show(trans_list);
trans_list = {{"12", "F"}, {"12", "M"}, {"13", "F"}, {"13", "M"}, {"14", "F"}, {"14", "M"}, {"15", "F"}, {"15", "M"}, {"16", "F"}, {"16", "M"}, {"17", "F"}, {"17", "M"}};Ri: traspone l'elenco di elenchi (summarize ()) senza un ciclo forHo avuto la stessa identica domanda @vince_faller . Grazie per avermelo chiesto. Ho inviato una richiesta per l'aggiunta di una funzionalità come questa alla prossima versione di JMP. Vediamo...
https://community.jmp.com/t5/JMP-Wish-List/Transpose-List-of-Lists-without-a-for-loop/idi-p/348968
