238418_es-ES

liliconcom

Importación de tabla JSL: selección de la fila correcta como encabezados cuando el número de fila deseado es variable

Tengo un script que usa una lista de entrada para extraer archivos de un directorio.El formato del archivo es inusual, por lo que requiere cierta manipulación y cada archivo tiene un tamaño del orden de 60 MB, por lo que las importaciones pueden llevar más tiempo del que quisiera.Mi problema es que la mayoría de los archivos tienen la fila de encabezado deseada en la fila 15, pero aproximadamente el 10% de los archivos tienen un encabezado que podría estar entre las filas 10 y 14 y no hay forma de saberlo hasta que abra el archivo.

 

Mi solución actual es hacer que el script abra las primeras 20 filas, busque la fila que contiene los encabezados y asigne ese número de fila a una variable, cierre ese dt, luego vuelva a abrir pero usando la variable como encabezado y la variable + 1 como primera linea.Funciona, pero significa que estoy abriendo estos archivos dos veces, aunque una es solo una vista previa limitada.  

 

1) ¿Existe una mejor manera de hacer esto?

2) Y mientras pregunto, ¿hay alguna manera de importar una tabla pero solo importar las columnas que quiero, según el nombre?Mis archivos tienen alrededor de 1000 columnas y solo necesito unas 15 de ellas.

Re: Importación de tabla JSL: seleccionar la fila correcta como encabezados cuando el número de fila deseado es variable

Creo que tienes razón; es posible que necesites usar parse() para convertir la cadena en una expresión.

Aquí hay otro enfoque que puede adoptar para evitar cadenas y manipular las expresiones directamente:

// 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 table

También podrías hacer algo similar manipulando texto, en lugar de expresiones, y luego

eval(parse( " the text you built ") )

Utilice la técnica con la que se sienta más cómodo; Habrá una pequeña mejora en la velocidad al manipular las expresiones, pero insignificante en comparación con la lectura de un archivo desde el disco.

Tenga en cuenta que la declaración final anterior aún depende del valor de X para elegir un archivo para abrir, por lo que no es necesario reconstruir la expresión.

Re: Importación de tabla JSL: seleccionar la fila correcta como encabezados cuando el número de fila deseado es variable

@Craige_Hales

Estoy buscando una manera de acortar el código para la importación de estos archivos tipo .csv.Tengo una importación que ahora tiene alrededor de 1000 columnas y otra con alrededor de 360, y esto recorre cientos de archivos ahora en una lista llamada "FileList".Solo quiero importar la columna 1 por los motivos indicados anteriormente.Mi código actual se ve así:

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

Pero estaba tratando de descubrir cómo usar una expresión de tipo eval() pero no lo estoy haciendo correctamente.Probé la expresión eval() en varios lugares pero parece que no puedo conseguirla.Soy nuevo en eval().Estoy pensando que tal vez mi problema es que mi variable "Omitir" termina siendo una cadena pero entre comillas.

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

   

Re: Importación de tabla JSL: seleccionar la fila correcta como encabezados cuando el número de fila deseado es variable

Me alegro de que pueda ayudar, parece un elemento digno de la lista de deseos.

Re: Importación de tabla JSL: seleccionar la fila correcta como encabezados cuando el número de fila deseado es variableGracias Craige. Para la importación inicial para obtener la fila con los encabezados de las columnas, utilicé su consejo y usé la columna de omisión para las columnas 2 a 1000, por lo que solo importo la columna 1 con 20 filas, tomo lo que necesito y luego la cerro. Luego vuelvo a abrir el archivo pero usando la información de la primera parte del bucle para seleccionar correctamente la fila del encabezado de la columna.

Desearía que hubiera una mejor manera de importar columnas específicas para la segunda parte del ciclo. En mi situación, es probable que las columnas de mi archivo de entrada sin formato cambien de orden y cantidad con el tiempo sin que yo lo sepa. Sería genial si JMP tuviera la capacidad de especificar por nombre solo las columnas que desea importar.Re: Importación de tabla JSL: seleccionar la fila correcta como encabezados cuando el número de fila deseado es variable

1) Creo que dos importaciones es probablemente la forma más fácil y se puede realizar más rápido...

2) Necesitará especificar algo más que las columnas a importar, pero la aceleración valdrá la pena...

 

use the text import wizard to mark the unwanted columnsuse the text import wizard to mark the unwanted columnsuse el asistente de importación de texto para marcar las columnas no deseadas

 

 

Grab the source script, it has the JSL to omit columnsGrab the source script, it has the JSL to omit columnsTome el script fuente, tiene el JSL para omitir columnas.

(para 1000 columnas omitidas, podría ser más fácil editar el JSL que excluirlo con la GUI).

 

Ahora puedes modificar el script fuente. Debajo se leen las primeras 100 líneas. Es rápido porque (1) se especifica todo lo relacionado con las columnas y (2) se detiene después de 100 líneas. Para estos datos debería haber especificado Labels(0) y 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" )
 )
)

Si sus archivos siempre tienen el mismo orden de columnas, especificar el formato explícitamente (arriba) significará que JMP no necesita estudiar el archivo antes de importarlo. Creo que JMP todavía estudia el completo archivo incluso si se detiene en 100 líneas, por lo que esto podría reducir mucho el tiempo de procesamiento.

 

Si los archivos no siempre tienen el mismo número de columnas o el mismo orden de columnas, esto no funcionará. Es posible que pueda importar la tabla, corregir los nombres de las columnas y los tipos de datos, eliminar filas que no desee... usando una sola importación.