Importazione di tabelle JSL: selezione della riga corretta come intestazioni quando il numero di riga desiderato è variabileHo uno script che utilizza un elenco di input per estrarre file da una directory.Il formato del file è insolito, quindi richiede un po' di manipolazione e ogni file è dell'ordine di 60 Mb, quindi le importazioni possono richiedere più tempo di quanto vorrei.Il mio problema è che la maggior parte dei file ha la riga di intestazione desiderata sulla riga 15, ma circa il 10% dei file ha un'intestazione che potrebbe trovarsi ovunque tra le righe 10 e 14 e non c'è modo di saperlo finché non apro il file.
La mia soluzione attuale è fare in modo che lo script apra le prime 20 righe, cerchi la riga che contiene le intestazioni e assegni quel numero di riga a una variabile, chiuda quel dt, quindi riapra ma utilizzando la variabile come intestazione e la variabile + 1 come prima linea.Funziona ma significa che apro questi file due volte, anche se uno è solo un'anteprima limitata.
1) Esiste un modo migliore per farlo?
2) E mentre lo chiedo, c'è un modo per importare una tabella ma importare solo le colonne che desidero, in base al nome?I miei file hanno circa 1000 colonne e me ne servono solo circa 15.
Oggetto: Importazione di tabelle JSL: selezione della riga corretta come intestazioni quando il numero di riga desiderato è variabilePenso che tu abbia ragione; potrebbe essere necessario utilizzare parse() per convertire la stringa in un'espressione.
Ecco un altro approccio che puoi adottare che evita le stringhe e manipola direttamente le espressioni:
// testing data (I modified your end of field with a tab, below)
filelist = {"$sample_data\..\Import Data\bigclass.txt"};
x = 1;
// build an expression with a placeholder COLUMNSEXPR
openstmt = Expr(
Open(
FileList[x],
COLUMNSEXPR, // << placeholder for columns(...)
Import Settings( End Of Line( CRLF, CR, LF ), End Of Field( tab, CSV( 0 ) ),
Strip Quotes( 1 ), Column Names Start( 1 ), Data Starts( 1 ) )
)
);
// if you run the openstmt function now, it will import all the columns
//
// eval(openstmt);
// build a list using {} to make it easy to manipulate
COLUMNSLIST = {};
// insert the column you want to keep
Insert Into( COLUMNSLIST, Expr( New Column( "Col1", Character, "Nominal" ) ) );
// insert 5 omit columns...
For( i = 1, i < 5, i += 1,
Insert Into( COLUMNSLIST, Expr( Omitted Column( . ) ) )
);
// COLUMNSLIST looks like this:
//{New Column( "Col1", Character, "Nominal" ), Omitted Column( . ),
//Omitted Column( . ), Omitted Column( . ), Omitted Column( . )}
// convert the {...} to columns(...)
Substitute Into( COLUMNSLIST, Expr( {} ), Expr( columns ) );
//show(nameexpr(COLUMNSLIST)); shows this:
//columns(New Column("Col1", Character, "Nominal"),
//Omitted Column(.), Omitted Column(.),
//Omitted Column(.), Omitted Column(.))
//
// if you leave out the nameexpr() it will (try to) evaluate rather than
// retrieving the expression for display. columns() is not a function in
// JSL, so evaluating makes an error message.
// nameexpr(openstmt) still show COLUMNSEXPR. replace it:
Substitute Into( openstmt, Expr( COLUMNSEXPR ), Name Expr( COLUMNSLIST ) );
// nameexpr(openstmt) is now
//Open(
// FileList[x],
// columns(
// New Column( "Col1", Character, "Nominal" ),
// Omitted Column( . ),
// Omitted Column( . ),
// Omitted Column( . ),
// Omitted Column( . )
// ),
// Import Settings(
// End Of Line( CRLF, CR, LF ),
// End Of Field( tab, CSV( 0 ) ),
// Strip Quotes( 1 ),
// Column Names Start( 1 ),
// Data Starts( 1 )
// )
//)
Eval( openstmt ); // reads just the first column of the tablePotresti anche fare qualcosa di simile manipolando il testo, anziché le espressioni, e poi
eval(parse( " the text you built ") )
Usa la tecnica con cui ti senti più a tuo agio; ci sarà un piccolo miglioramento nella velocità di manipolazione delle espressioni, ma insignificante rispetto alla lettura di un file da disco.
Si noti che l'istruzione finale sopra dipende ancora dal valore di X per scegliere un file da aprire, quindi non è necessario ricostruire l'espressione.
Oggetto: Importazione di tabelle JSL: selezione della riga corretta come intestazioni quando il numero di riga desiderato è variabile@Craige_Hales
Sto cercando un modo per abbreviare il codice per l'importazione di questi file simili a .csv.Ho un'importazione che ora ha circa 1000 colonne e un'altra con circa 360, e questa scorre ora tra centinaia di file in un elenco chiamato "FileList".Voglio importare solo la colonna 1 per i motivi sopra indicati.Il mio codice attuale è simile a questo:
For( x = 1, x <= N Items( FileList ), x++,
dt = Open(
FileList[x],
eval(columns(
New Column( "Col1", Character, "Nominal" ),
Omitted Column( . ),
Omitted Column( . ),
Omitted Column( . ), <FONT color="#FF0000">(repeated 400 times!)</FONT>
),
Import Settings(
End Of Line( CRLF, CR, LF ),
End Of Field( Spaces, Space, CSV( 0 ) ),
Strip Quotes( 1 ),
Column Names Start( 1 ),
Data Starts( 1 ),
),
//invisible
);Ma stavo cercando di capire come utilizzare un'espressione di tipo eval() ma non lo faccio correttamente.Ho provato l'espressione eval() in vari posti ma non riesco a capirla.Sono nuovo a eval().Sto pensando che forse il mio problema è che la mia variabile "Omit" finisce per essere una stringa ma racchiusa tra virgolette??
<FONT color="#339966"> Omit</FONT> = repeat("Omitted Column( . ),",400)||"Omitted Column( . )";
For( x = 1, x <= N Items( FileList ), x++,
dt = Open(
FileList[x],
<FONT color="#FF0000">eval(</FONT>columns(
New Column( "Col1", Character, "Nominal" ),
<FONT color="#339966">Omit</FONT><FONT color="#FF0000">);</FONT>
),
Import Settings(
End Of Line( CRLF, CR, LF ),
End Of Field( Spaces, Space, CSV( 0 ) ),
Strip Quotes( 1 ),
Column Names Start( 1 ),
Data Starts( 1 ),
),
);
Oggetto: Importazione di tabelle JSL: selezione della riga corretta come intestazioni quando il numero di riga desiderato è variabilefelice che possa essere d'aiuto, sembra un degno elemento della lista dei desideri.
Oggetto: Importazione di tabelle JSL: selezione della riga corretta come intestazioni quando il numero di riga desiderato è variabileGrazie Craige. Per l'importazione iniziale per ottenere la riga con le intestazioni delle colonne ho usato il tuo consiglio e ho usato la colonna di omissione per le colonne da 2 a 1000, quindi importo solo la colonna 1 con 20 righe, prendo ciò che mi serve e poi la chiudo. Quindi riapro il file ma utilizzando le informazioni della prima parte del ciclo per selezionare correttamente la riga di intestazione della colonna.
Vorrei che ci fosse un modo migliore per importare colonne specifiche per la seconda parte del ciclo. Nella mia situazione è probabile che le colonne del mio file di input non elaborato cambino l'ordine e la quantità nel tempo senza che io lo sappia. Sarebbe bello se JMP avesse la possibilità di specificare per nome solo le colonne che desideri importare.Oggetto: Importazione di tabelle JSL: selezione della riga corretta come intestazioni quando il numero di riga desiderato è variabile1) Penso che due importazioni siano probabilmente il modo più semplice e possano essere effettuate più velocemente...
2) Dovrai specificare più delle semplici colonne da importare, ma ne varrà la pena...
use the text import wizard to mark the unwanted columnsuse the text import wizard to mark the unwanted columnsutilizzare la procedura guidata di importazione del testo per contrassegnare le colonne indesiderate
Grab the source script, it has the JSL to omit columnsGrab the source script, it has the JSL to omit columnsPrendi lo script sorgente, ha il JSL per omettere le colonne
(per 1000 colonne omesse potrebbe essere più semplice modificare il JSL piuttosto che escluderlo con la GUI.)
Ora puoi modificare lo script sorgente. Di seguito si leggono le prime 100 righe. È veloce perché (1) è specificato tutto ciò che riguarda le colonne e (2) si ferma dopo 100 righe. Per questi dati avrei dovuto specificare Labels(0) e DataStarts(1).
Open(
"f:\logOriginalAntenna.txt",// 100MB file takes about 2 seconds to load 100 lines
columns(
Omitted Column( . ),// use the import wizard to
Omitted Column( . ),// get a source script with
Omitted Column( . ),// omitted columns
New Column( "c000004",
Numeric,
"Continuous",
Format( "yyyy-mm-ddThh:mm:ss", 23, 3 ),
Input Format( "yyyy-mm-ddThh:mm:ss", 3 )
),
New Column( "c000005", Character, "Nominal" )
),
Import Settings(
End Of Line( CRLF, CR, LF ),
End Of Field( Tab, Comma, CSV( 1 ) ),
Strip Quotes( 1 ),
Use Apostrophe as Quotation Mark( 0 ),
Use Regional Settings( 0 ),
Scan Whole File( 1 ),
Treat empty columns as numeric( 0 ),
CompressNumericColumns( 0 ),
CompressCharacterColumns( 0 ),
CompressAllowListCheck( 0 ),
Labels( 1 ),
Column Names Start( 1 ),
Data Starts( 2 ),
Lines To Read( 100 ),// specify the number of rows
Year Rule( "20xx" )
)
)
Se i file hanno sempre lo stesso ordinamento delle colonne, specificare esplicitamente il formato (sopra) significa che JMP non avrà bisogno di studiare il file prima di importarlo. Penso che JMP studi ancora il intero file anche se ti fermi a 100 righe, quindi questo potrebbe ridurre molto il tempo di elaborazione.
Se i file non hanno sempre lo stesso numero di colonne o ordine di colonne, questo non funzionerà. Potresti essere in grado di importare la tabella, correggere i nomi delle colonne e i tipi di dati, eliminare le righe che non desideri... utilizzando un'unica importazione.
