240795_es-ES

liliconcom

Clasificación de listas

Problema

Tiene datos en una o más listas o vectores de matriz que necesita ordenar.

Solución

Usar Lista Ordenada() o Ordenar lista en () , Rango() , o coloque las listas y los vectores en una tabla de datos y ordénelos.

 

// Sort List example (makes new list)
names = {"fred", "Andy", "Rory", "bess", "susy", "perl"};
sname = Sort List( names );
Show( names, sname );

nombres = {"fred", "Andy", "Rory", "bess", "susy", "perl"}; // sin cambios

nombre = {"Andy", "bess", "fred", "perl", "Rory", "susy"}; // ordenado

// Sort List Into example (in-place sort)
names = {"fred", "Andy", "Rory", "bess", "susy", "perl"};
Sort List Into( names );
Show( names );

nombres = {"Andy", "bess", "fred", "perl", "Rory", "susy"}; // ordenado en el lugar

Ambos ejemplos anteriores operan en una sola lista. Si hay una segunda lista de números de teléfono, no se apegan a los nombres.

Para hacer que varias listas tengan el mismo tipo, puede usar la función Rank(). Las listas deben tener el mismo número de elementos y no deben faltar valores en la lista de claves de ordenación.

names = {"fred", "Andy", "Rory", "bess", "susy", "perl"};
phone = {"x321", "x322", "x323", "x324", "x325", "x326"};
rooms = {"1003", "1001", "1005", "1002", "1006", "1004"};

rnk = Rank( names ); // [2, 4, 1, 6, 3, 5]

// use the rnk vector to make sorted lists from the old lists
snames = names[rnk];
sphone = phone[rnk];
srooms = rooms[rnk];

Show( snames, sphone, srooms );

nombres = {"Andy", "bess", "fred", "perl", "Rory", "susy"};
teléfono = {"x322", "x324", "x321", "x326", "x323", "x325"};
cuartos = {"1001", "1002", "1003", "1004", "1005", "1006"};

 

Arriba, las nuevas listas con el prefijo s están ordenadas por nombre.

 

Si tiene varias listas, de la misma longitud, pero emparejadas en las listas, quizás una tabla de datos sería una mejor estructura de datos. Puede que le resulte más fácil usar una tabla porque puede verla, guardarla, crear subconjuntos, ...Pero si ya tiene las listas, puede crear una tabla a partir de ellas. Aquí hay una función de usuario reutilizable que hace eso:

// the zip function, named after a Python function that, like a zipper, zips two lists together
zip = Function( {variableNameList}, // a list of variable names
 {iVarName, dt, data}, // local variables
 dt = New Table( "zip", "invisible" ); // a hidden table, returned at end of this function
 For( iVarName = 1, iVarName <= N Items( variableNameList ), iVarName += 1,
  data = Eval( variableNameList[iVarName] ); // makes a copy of the data from the name
  If( Is Matrix( data ) | Is Number( data[1] ), // handle lists of numbers same as a matrix
   dt << New Column( Char( variableNameList[iVarName] ), "numeric", values( data ),
    setProperty( "wasMatrix", eval(Is Matrix( data ) ) ) ) // remember how to convert back, could be list
  , // else a list of strings
   dt << New Column( Char( variableNameList[iVarName] ), "character", values( data ),
    setProperty( "wasString", eval( Is String( data[1] ) ) ) ) // remember how to convert back, could be names
  );
 );
 dt << New Column( "_original order_", values( 1 :: N Rows( dt ) ) ); // this extra column is not required, but might be useful
 dt << setdirty( 0 ); // not required but avoids a "save?" prompt
 dt; // return
);

ejemplo:

cars = {chevy, volkswagon, honda, ford, toyota}; // list of unquoted names
doors = [4, 2, 2, 5, 2]; // matrix of numbers
miles = {30000, 20000, 40000, 10000, 50000}; // list of numbers
owner = {"fred", "susan", "ralph", "penelope", "terry"}; // list of quoted strings

zippedDt = zip( {cars, doors, miles, owner} );
zippedDt << sort( by( miles ), replacetable( 1 ) );

zippedDt << show Window; // table hidden by default

Lists are in table's columns, sorted by milesLists are in table's columns, sorted by milesLas listas están en las columnas de la tabla, ordenadas por millas

Si está trabajando con listas, es posible que desee recuperar todas las listas. Aquí hay una función de descompresión:

// unzip, similar to Python's unzip
unzip = Function( {dt}, // data table previously returned from zip (above)
 {result, cols, iCol, col, names, iRow}, // local variables
 cols = dt << getcolumnnames; // below, the _original order_ col gets skipped
 result = {}; // assemble all of the lists and matrices here, return at bottom
 For( iCol = 1, iCol < N Items( cols )/*skip last one*/, iCol += 1,
  col = Column( dt, cols[icol] ); // the Ith col in the table
  If( col << getdatatype( "English" ) == "Numeric", //
   // return the same type of object, list or matrix, supplied originally
   If( col << getproperty( "wasMatrix" ), // by checking the property we set above
    Insert Into( result, col << getValues ); // append a matrix
   , // else append a list of numbers
    result[N Items( result ) + 1] = As List( dt[0, iCol] )
   )
  , // else character column
   // return same type, list of names or list of strings...
   If( col << getproperty( "wasString" ), // check character col prop set above
    result[N Items( result ) + 1] = (dt[0, iCol]) // list of strings
   , // else turn the strings into names again
    result[N Items( result ) + 1] = As Name( dt[0, iCol] ) // list of names
   )
  );
 );
 result; // return
);

ejemplo:

{cars, doors, miles, owner} = unzip( zippedDt );

Lista (4 elementos) asignada.

coches:{ford, volkswagon, chevy, honda, toyota}
puertas:[5, 2, 4, 2, 2]
millas:{10000, 20000, 30000, 40000, 50000}
propietario:{"penélope", "susan", "fred", "ralph", "terry"}

Finalmente

// Important! delete the invisible table!
Close( zippedDt, nosave );

Discusión

Asegúrese de limpiar la tabla invisible si usa las funciones de comprimir/descomprimir. (No están relacionados con la función de compresión para archivos .zip. JMP tiene soporte para eso en el objeto de archivo zip).

La tabla de datos es una gran herramienta para estructuras de datos complicadas. Puede crear tablas ocultas o privadas para administrar datos sin usar las funciones de contenedor anteriores. Las listas pueden ser más eficientes que las tablas de datos si necesita agregar y eliminar muchos elementos (las colas y las pilas pueden ser lentas si se implementan como agregar y eliminar filas de una tabla). La función zip (arriba) espera una lista de nombres . A nombre (sin comillas) no es lo mismo que un cadena (usa comillas) . Pasar una lista de nombres reduce el número de veces que se copian los datos.

Ver también

https://www.jmp.com/support/help/14-2/list-functions.shtml