| Oratore |
Trascrizione |
| Jordan Hiller |
Ciao a tutti. Sono Jordan Hiller e questo talk si intitola "Ruba questo codice!". Tre potenziamenti per gli script ottenuti dal registro migliorato. |
| |
Ed ecco l'ispirazione per questo intervento. È un libro di Abbie Hoffman, una provocatrice e attivista. Sì, ha intitolato il suo libro "Ruba questo libro", che è un titolo fantastico. Non sono sicuro che sia un buon business plan chiamare così il tuo libro, ma comunque è molto accattivante. |
| |
Allora perché rubare questo codice? JMP vuole che tu rubi il codice. L'idea è che tu punti, clicchi e faccia la tua analisi in JMP, |
| |
e il codice alla base del tuo punta e clicca viene salvato. Viene salvato nel registro avanzato e puoi recuperarlo e riutilizzarlo. |
| |
E questo è circa il 90% del tuo script di produzione. Lo prenderai e lo riutilizzerai in modo da poter |
| |
Automatizzare le attività comuni e farle con un clic, invece di una sequenza di puntamenti e clic. Quindi questo è l'obiettivo principale: risparmiare |
| |
script dal registro migliorato e questa è l'ossatura, lo scheletro del tuo script di produzione. |
| |
Rimane circa il 10% del materiale che dovrai scrivere tu stesso, ed è questo il nostro obiettivo per questa conferenza. Parleremo di quel tessuto connettivo che tiene insieme le sceneggiature di produzione. |
| |
Quindi in questo discorso mi concentrerò con voi, sapete, non tanto sui dettagli della sintassi, |
| |
Molto di più sul quadro generale, e questo è in linea con quello che ritengo sia un buon modo per imparare la programmazione JSL. È molto meglio prendere codice esistente e imparare dagli esempi. Usa quel codice. |
| |
Trova lo snippet che fa quello che vuoi. Lo troverai nella community degli utenti JMP o magari nella guida allo scripting. |
| |
Basta copiarlo e adattarlo al tuo utilizzo. Non devi conoscere tutte le complessità della sintassi. In questo modo andrai molto lontano. L'apprendimento della sintassi avviene con l'esperienza. |
| |
Parleremo quindi di tre casi di studio su come migliorare il codice grazie al log migliorato, ma prima diamo un'occhiata a JSL. Forse per alcuni di voi sarà un'introduzione alle basi di JSL. |
| |
Quindi la cosa importante che devi sapere su JSL se stai iniziando è che tutto è un oggetto. Tutto ciò che |
| |
si vuole fare qualcosa per un oggetto, quindi include tabelle di dati e colonne in tabelle di dati e piattaforme, come la piattaforma di distribuzione, il generatore di grafici, Fit Y by X, |
| |
e i report che provengono da quelle piattaforme. Quindi, quando si hanno degli oggetti, il modo in cui si interagisce con essi è inviare loro dei messaggi. Quindi gli oggetti ricevono messaggi. Ecco un esempio molto semplice che ho copiato dal registro avanzato. |
| |
Apri la tabella dati Big Class nella directory dei dati di esempio ed esegui una semplice analisi della distribuzione, giusto? Ecco come appare il codice, appena copiato dal log. |
| |
Ora. |
| |
Quello che vogliamo fare, la prima cosa che vogliamo fare è dare un nome alla tabella dati. Dagli un nome, e per questo ho preso il codice dalla riga cinque qui e l'ho migliorato. Io |
| |
Ho aggiunto questo bctable= prima del resto, prima della parte aperta dell'istruzione, ok. E questo fa sì che, quando apriamo quella tabella dati, creiamo questo nome, bctable. Sai, ho scelto bctable, vedrai dt nella documentazione. Usa quello che vuoi, questo è assegnato da te. |
| |
Quindi eseguiamolo evidenziandolo e cliccando sul pulsante Esegui, aprendo Big Class e assegnando contemporaneamente il nome bctable. Ora, il vantaggio di fare ciò, perché è importante, è perché ora ho questo |
| |
handle. È un hook che posso usare nel codice in seguito, bctable. Ogni volta che dico bctable, mi riferisco a Big Class. |
| |
COSÌ |
| |
Ecco la riga successiva, ma comando di distribuzione, e ho modificato anche quello. E sapete, prima di questo, dal log, questo è un comando di distribuzione nudo e crudo. Non ha... |
| |
non punta a una tabella dati. Quando lo esegui in questo modo, JMP lo eseguirà solo sulla tabella dati che ha il focus, |
| |
La tabella dati corrente, che è una classe grande, perché l'hai aperta poco prima, ok? Ma è sempre bene essere espliciti. È una buona idea indicare esplicitamente su quale tabella dati si desidera operare, quindi la eseguiremo in questo modo. |
| |
bctable, poi le doppie frecce e infine i comandi di distribuzione. Ecco cosa abbiamo aggiunto: bctable con le doppie frecce. |
| |
Questa è la sintassi per inviare un messaggio. Stiamo inviando il messaggio di distribuzione a destra alla tabella dati da cui prende il nome bctable, a sinistra. E potete vedere che si tratta di Big Class quando passate il mouse su bctable. Quindi, eseguendo il tutto, |
| |
otteniamo il rapporto di distribuzione |
| |
che volevamo. |
| |
Ora ecco... possiamo fare un ulteriore passo avanti e, spesso, è necessario farlo. Creeremo un nome per la piattaforma mentre la eseguiamo, quindi |
| |
Ecco una riga che incorpora sia la doppia freccia che il segno di uguale, ok. Quindi, uh... leggiamolo da destra a sinistra. Prenderemo quel messaggio di distribuzione e lo invieremo alla tabella bctable. |
| |
E il risultato di tutto ciò, che è la piattaforma, lo salveremo in questa variabile che chiamerò distplat. |
| |
Facciamolo. |
| |
Va bene, sembra lo stesso, ma la differenza è che ora ho questa variabile JSL distplat che posso usare più avanti nel mio codice. |
| |
Per cosa lo useresti? Potresti usarlo per aggiungere opzioni di triangoli rossi all'output, quindi ecco... |
| |
Portiamo quel rapporto di distribuzione dove puoi vederlo. |
| |
E prenderemo quell'oggetto distplat, che è la...questa è la piattaforma di distribuzione. |
| |
Guarda, passaci sopra con il mouse e tracciamo questa linea. Attiva il normale grafico quintile nella piattaforma di distribuzione. Ecco qua. |
| |
Va bene. |
| |
L'ultimo passo è prendere la piattaforma, prendere questo oggetto qui e |
| |
Ottenere un report da esso, un oggetto report. Questa è la riga. Invia il messaggio di report all'oggetto piattaforma e ora otteniamo un oggetto report. |
| |
E dobbiamo farlo se vuoi accedere a questi valori nel tuo codice (numeri, grafici o elementi grafici nel report): avrai bisogno di questo, okay. Questo oggetto rdistplat. Quindi eseguiamolo ancora una volta, rdistplat. |
| |
L'ho eseguito e non si vede nulla di visibile, ma quello che è successo è che ora ho questo oggetto, rdistplat. Dice di essere una casella di visualizzazione, e più avanti parleremo di come puoi usarla per accedere ai numeri qui nel report. |
| |
Ok, pulisco il mio registro |
| |
e iniziamo con il nostro |
| |
casi di studio. |
| |
Quindi la prima tecnica che impareremo è ripetere lo stesso comando più e più volte su colonne diverse nella tabella dati, iterando sulle colonne con cicli utilizzando il comando for each. Quindi |
| |
Si tratta di un'esigenza molto comune, a volte si tratta semplicemente di qualcosa di semplice che devi fare, come cambiare il formato o il tipo di modellazione di una colonna. |
| |
Potrebbe essere molto complesso come |
| |
Prendendo... prendendo una trasformata della colonna ed eseguendo una carta di controllo e facendo qualcosa con quella carta di controllo. Quindi sì, è scalabile; questa tecnica è scalabile. |
| |
Ecco come raggiungeremo questo obiettivo nel codice JSL. Per prima cosa, indicheremo e cliccheremo, giusto, e faremo ciò che vogliamo. Lo faremo per una singola colonna, e poi prenderemo quel codice usando il log avanzato, |
| |
E questo è lo scheletro del nostro script. Lo modificheremo per eseguire un ciclo su tutte le colonne su cui vogliamo eseguire quell'azione. |
| |
Il metodo che utilizzeremo per il ciclo for, per l'iterazione, è for each, ed è stato introdotto in JMP 16, quindi questa tecnica non funzionerà nelle versioni precedenti di JMP. |
| |
In questo caso si utilizza anche un concetto chiamato elenchi JSL, quindi parleremo un po' anche di questo. |
| |
Ok, comincerò |
| |
in JMP, partiamo dalla finestra iniziale. |
| |
E ora... lasciami controllare il registro, assicurarmi che sia pulito. No, devo rimuovere una cosa, cancellare il registro. Ok, quindi puntiamo e clicchiamo su ciò che vogliamo fare. Aprirò una tabella dati chiamata sc20. |
| |
Questa tabella dati è disponibile nei materiali di presentazione che troverete online. |
| |
E guardando questa tabella dati, ha una colonna ID e poi ha circa 20 |
| |
colonne di dati. Hanno moltissime cifre decimali, troppa precisione e voglio troncarle a due cifre decimali. Quindi modifichiamo il formato in modo da mostrare solo le prime due cifre decimali dei dati. |
| |
Si tratta di una semplice operazione punta e clicca. Fai clic con il tasto destro, vai alle informazioni della colonna, |
| |
e cambieremo il formato di visualizzazione dal migliore predefinito al decimale fisso con due cifre. |
| |
Bene, e ora che lo abbiamo fatto per NPN1, ci sono altre 19 colonne per cui vorremmo farlo. |
| |
Esaminiamo quindi il registro migliorato. |
| |
Ed ecco fatto, questo è il codice che ci serve per modificare il formato di una colonna, NPN1, giusto. E poi, per riutilizzarlo, andate sul triangolo rosso e potete salvare lo script negli appunti o anche in una nuova finestra di script. |
| |
Passerò a un altro file, dove ho già lavorato un po' e così potremo approfondire un po' di più la questione. |
| |
Va bene. |
| |
Quindi le prime due righe qui... tre righe, questo è il codice del log. Bene, la prima cosa che facciamo è aprire la tabella dati. |
| |
E potresti aver notato che ho apportato qualche modifica, ho eliminato il mio lungo percorso, il lungo percorso della directory di questo file. |
| |
Se lo esegui in questo modo, |
| |
Funzionerà finché la tabella dati JMP, sc20, si trova nella stessa directory di questo file JSL. Quindi è come un percorso locale per la stessa directory in cui ti trovi attualmente. |
| |
Comunque, dal registro stiamo semplicemente aprendo la tabella dati e poi siamo qui, applicando quella modifica al formato, decimale fisso 10 caratteri due decimali. |
| |
La tabella... il riferimento di colonna qui a sinistra è un modo per indirizzare una colonna. Ci sono diversi modi, ma questo è molto comune e si usa il simbolo dei due punti. Riferimento tabella... riferimento... riferimento sul lato sinistro dei due punti e il nome della colonna sul lato destro dei due punti. |
| |
Quindi anche questo è tratto direttamente dal registro. |
| |
JMP usa questo metodo nel log per indirizzare la tabella dati. Penso che sia meglio fare quello di cui abbiamo parlato, ovvero specificare il nome JSL all'apertura e poi utilizzare quel nome JSL in seguito. Quindi, invece di usare questo passaggio prima dei due punti, l'ho modificato in dt. |
| |
Ecco lo stesso codice, solo... solo un po' corretto, e quando lo eseguo, sì, ha l'effetto giusto. Apre la tabella dati e... |
| |
cambia il formato a due cifre decimali. Ok, quindi sì, ora che lo abbiamo, è una cosa abbastanza facile da |
| |
cambia tutte le altre 19 colonne, giusto. Ecco... ecco NPN1, e poi posso semplicemente copiare quella riga, modificare tutti e scriverla altre 19 volte. |
| |
Sì, certo, è inefficiente, e uno dei grandi vantaggi della programmazione è che... non devi fare la stessa cosa più di una volta, giusto? Quindi diventa più facile da gestire se... se lo scrivessimo una volta sola, invece di scriverlo 19 o 20 volte. |
| |
Ecco come procedere. La prima cosa che facciamo è ottenere un elenco di tutte le colonne su cui vogliamo operare. |
| |
E quando parlo di lista, non intendo semplicemente un tipo generico di lista. Parlo di una lista JSL, di una particolare struttura dati che si usa quando si programma in JSL. |
| |
Un elenco è semplicemente un paio di oggetti contenuti in un contenitore, ed è così che lo usiamo. Ecco tre modi per creare un elenco di oggetti colonna. |
| |
Il primo modo è farlo manualmente, digitando semplicemente tutto. Quindi, se dovessi eseguire questo, |
| |
tre riferimenti di tabella...tre riferimenti di colonna, NPN1, PNP1, PNP2. |
| |
Notate le parentesi graffe sia nel mio codice che quando passo il mouse sulla variabile CNames. Quando vedete quelle parentesi graffe, sapete che avete a che fare con la lista in JSL. |
| |
Bene, questo è un modo per ottenere un elenco. Parliamo di un paio di altri modi. Questo è quello che useremo per questo esempio, in definitiva. Questo è |
| |
dicendo, ehi, prendi tutte le colonne continue nella mia tabella dati corrente, beh nella tabella dati che chiamo qui, dt. Quindi oggetto messaggio, crea un nuovo elenco. |
| |
Allora, proviamo a farlo. |
| |
E ora se passo il mouse su CNames, vedrai che è proprio quello che ci serve. È l'elenco di tutti i 20 nomi su cui vogliamo operare. |
| |
Bene, l'ultimo modo per farlo è lasciare che sia l'utente a selezionare le colonne nella tabella dati. Ecco come appare. Ne selezionerò solo due. Selezioniamo IVP e PNP4, due colonne selezionate. |
| |
E se lo faccio funzionare, |
| |
otteniamo un elenco con solo le due colonne selezionate dalla tabella dati. |
| |
Bene, quindi, comunque si ottenga quell'elenco, il lavoro successivo è applicare quella riga di formattazione a ciascuno degli elementi nell'elenco, e questo si chiama ciclo o iterazione. |
| |
Ecco il vecchio metodo. Si usa il comando for in JMP. Era quello che si faceva prima di JMP 16 e lo riporto qui, per riferimento nel caso in cui si utilizzi ancora JMP 15. Ma, |
| |
Sai, è un po' complicato e impedisce di cercare nuovi utenti, quindi c'è una cosa molto più compatta e leggibile che puoi fare se stai usando un elenco in JMP 16. Se voglio ripetere un'azione su ogni elemento di un elenco, posso usare questo per ogni comando. |
| |
Bene, diamo un'occhiata e vediamo cosa fa. Accetta tre argomenti, separati da virgole, e li sposteremo da destra a sinistra. |
| |
L'ultimo argomento è il comando format, giusto, applicando il formato, e invece di farlo per dt NPN1, invece di farlo per una colonna, ho inserito un segnaposto qui e ho scelto l'elemento dell'elenco; tu scegli quello che vuoi. |
| |
Giusto, questa è solo una parola, un nome di variabile, tu lo scegli. Io ho scelto "elemento elenco". Quindi questo è il nostro segnaposto, e questo è il comando che vogliamo eseguire su ogni elemento dell'elenco. Quale elenco? Questo elenco, ok. Quindi questo è il nostro elenco, questo è il secondo. |
| |
argomento. E poi il primo argomento è il segnaposto, giusto. Ci dice che stiamo usando quel segnaposto per contenere i valori degli elementi nell'elenco. |
| |
È racchiuso tra parentesi graffe, quindi assicurati di utilizzarlo se riutilizzi questo codice. |
| |
Quindi ecco come appare il tutto, invece di più di 20 righe di codice, ho solo, beh, tre righe di codice, e questo include l'apertura della tabella dati, |
| |
Ottenere un elenco di nomi di colonne e poi ripeterlo... ripetere l'azione per tutte le 20 colonne continue. Per eseguire il tutto, ecco come appare. |
| |
Ed eccolo qui. Ora ciascuna di queste colonne |
| |
ha due cifre decimali visualizzate nel formato. |
| |
Okay, quindi questo è stato un esempio molto semplice di come usare for each per fare qualcosa di molto semplice su |
| |
su una colonna. |
| |
Vorrei mostrarvi un esempio un po' più interessante. |
| |
Ecco un esempio in cui, per lo stesso set di dati, per sc20, |
| |
Farò un grafico di controllo per ogni colonna, aggiungerò quei grafici di controllo a un giornale e salverò il tutto in formato PDF, okay. Quindi |
| |
Usa lo stesso codice per ciascuno, e ha gli stessi primi due argomenti, sai, l'elemento della lista è il primo, un nome di lista per il secondo. Ma ora ho un sacco di codice come terzo elemento... come terzo argomento in "for each". |
| |
Quindi eccoci qui. Eseguiamo l'intero script. |
| |
Apro, eseguo un sacco di carte di controllo, le metto insieme in un diario. E ora, se guardo sul mio desktop, ho creato questa cosa, il mio report.pdf, che contiene tutte quelle carte di controllo, pagina uno, e le loro interruzioni di pagina per separarle. Quindi pagina uno, pagina due, pagina tre. |
| |
Quindi potete dare un'occhiata anche a questo esempio quando volete. È incluso nel materiale della presentazione. |
| |
Bene, questa è la prima tecnica di cui parleremo. Svuotiamo il registro per la prossima. |
| |
Ok, estrarre un valore da un report. Succede spesso in JSL. Si esegue una sorta di analisi, magari una distribuzione, magari una regressione, bisogna... |
| |
Prendi qualcosa, raccogli qualcosa da lì. Forse è una media o una mediana. Forse è un coefficiente di pendenza della regressione o un valore P. |
| |
Questo è il nostro lavoro, e la parte difficile è che i report hanno una struttura gerarchica, altamente annidata, e può essere un po' complicato spostarsi lungo questa gerarchia, percorrere quell'albero per trovare esattamente ciò che vogliamo. Quindi vi insegnerò un trucco. |
| |
Il trucco è che, come al solito, dobbiamo puntare e cliccare lungo l'analisi, e poi la cosa che vogliamo catturare, |
| |
Cambierò il colore del testo in rosso, solo una piccola modifica di formattazione. E poi, quando salveremo lo script nel registro, lo useremo per imparare come gestire quell'elemento rosso. |
| |
in JSL. Quindi analizziamolo insieme. |
| |
Di nuovo su JMP. |
| |
Ora apro Big Class, il caro vecchio Big Class, e proviamo a eseguire una distribuzione sulla colonna altezza. |
| |
Bene, ecco il mio report di distribuzione da cui voglio estrarre qualcosa. Diciamo che è la mediana, in questo caso la mediana è 63, e la inserirò in una variabile JSL in modo da poterla riutilizzare in seguito, e sai, scriverci sopra o fare qualche calcolo matematico o qualcosa del genere. |
| |
Ecco il trucco per scoprire come...affrontare il numero 63. |
| |
Cambiare il colore o, sai, il font o qualsiasi altra cosa di questa cosa che voglio catturare. Quindi, se non l'avete mai visto, vale la pena saperlo. |
| |
Sulla barra degli strumenti c'è un pulsante per le proprietà, credo sia un nuovo pulsante in JMP 16. |
| |
Quindi, se attivi le proprietà per questo report. |
| |
Possiamo percorrere questo albero e trovare ciò di cui abbiamo bisogno. Guardate questo. |
| |
casella numero colonna, a destra. E nota che quando clicco su diverse parti del report, il corrispondente |
| |
elemento, il tipo di casella di visualizzazione di cui si tratta, è evidenziato nel pannello delle proprietà. |
| |
Ok, quindi possiamo vedere che questa cosa che ha tutti questi risultati è una casella di testo con tutti questi numeri al suo interno e, tipo, ti ho detto che prenderemo questa cosa e cambieremo il colore del testo in rosso. |
| |
Proprio così. |
| |
Ora chiuderò il pannello delle proprietà. |
| |
Ecco il report, e inviamo questo script al registro avanzato. |
| |
Triangolo rosso, salva lo script nel registro. |
| |
E ora sto visualizzando quel registro. |
| |
Questa è la parte che ci interessa. Contiene, sapete, il comando di distribuzione con la parte che cambia il colore del testo della mediana e delle altre statistiche in rosso. Ora diamo un'occhiata più nel dettaglio. |
| |
Ok, ecco il codice... lo stesso codice del registro avanzato. L'ho semplicemente copiato qui e l'ho formattato un po', così possiamo parlare meglio di ciò di cui abbiamo bisogno. |
| |
Quindi il motivo per cui abbiamo fatto questo era ottenere questa parte, che ora interpreteremo, ok. Utilizza send per segnalare e, all'interno di questo, dispatch. |
| |
E qui ci concentreremo sui quattro argomenti per la distribuzione. Ci servono i primi tre, il quarto argomento è cambiare il colore, ma non è questo che ci interessa. Ci interessa occuparci del display box, l'elemento che vogliamo, ok? Quindi |
| |
Questo primo argomento è la navigazione. Ci dice di andare verso il basso per visualizzare le caselle, queste sono in realtà caselle con contorno, andare verso il basso per visualizzare le caselle con contorno |
| |
Ecco. Diamo un'occhiata a quel report. Di nuovo, sono sicuro che avrai notato che in JMP ci sono questi livelli di annidamento in un report, giusto? E io ho solo... |
| |
una distribuzione della casella di contorno esterna. All'interno di questa c'è un'altezza della casella di contorno e, all'interno di questa, un quantile della casella di contorno, e all'interno di questi quantili c'è il materiale che devo estrarre. |
| |
Ecco cosa mi sta dicendo. Mi sta dicendo di scendere da quell'albero. Mi servivano solo l'altezza e i quantili, e questo ci aiuterà a identificarlo. |
| |
Bene. I due argomenti successivi ci dicono qualcosa su questo... questo elemento che stiamo provando, che abbiamo trasformato in rosso. Ci dice... il terzo ci dice di cosa si tratta, è una casella di testo numerica, lo abbiamo visto nelle proprietà. |
| |
E il secondo argomento ci dice il titolo |
| |
di quella casella di testo. Questa è vuota. Questa non ha un titolo e va bene così. Possiamo... possiamo comunque usare queste informazioni per ottenere quei dati, quindi a volte vedrai un titolo qui, a volte no. |
| |
Bene, ora che abbiamo questo, prenderemo queste informazioni e le useremo |
| |
per estrarre la mediana. |
| |
Ecco il codice che lo fa. Inizia qui, alla riga 23, e arriva fino alla riga 29. |
| |
Stiamo riaprendo la tabella dati, |
| |
denominazione della distribuzione, esecuzione della distribuzione continua. |
| |
Noterete che non abbiamo nessuna di queste istruzioni di spedizione e invio a rapporto, perché non abbiamo bisogno di renderle rosse nel nostro script di produzione. |
| |
Quindi sì, esegui l'analisi della distribuzione e dai un nome alla piattaforma. |
| |
Questo è importante, devi... stai accedendo al livello del report. Lo stai estraendo con questa riga, quindi stai creando rdist, questo oggetto report. |
| |
E poi, questa è la linea in cui avviene la magia. È qui che prendiamo quella |
| |
quel valore mediano, assegnandolo alla variabile JSL, mdn, e per questo, lo scriveremo nel log. Quindi vi spiegherò un po' di più su questo, ma prima eseguiamolo una volta sola, così vedete cosa fa. |
| |
Ora eseguo la riga 23, ops, facciamo così. Eseguiamo la riga... le righe dalla 23 alla 29. |
| |
Abbiamo eseguito la distribuzione. Non è rosso e abbiamo estratto la mediana, che ora è memorizzata in mdn. Come puoi vedere, il valore per quella variabile è 63. |
| |
la mediana è 63. Perfetto. |
| |
Bene. |
| |
Quindi ecco quella linea in cui stiamo estraendo il |
| |
il valore mediano, ovvero il numero 63 del rapporto. |
| |
Diamo un'occhiata a questo. Lo chiamerò qui in modo che possiamo |
| |
fare riferimento a questo, come noi, come lo facciamo. |
| |
Ecco la riga. È di nuovo organizzata, in modo che possiamo esaminare ogni elemento separatamente. |
| |
63, il valore mediano del rapporto. |
| |
Ecco come ci arriviamo. |
| |
Questo si chiama subscript...subscripting. Quando vedi le parentesi quadre nel codice JSL, significa che stai sottoscrivendo un oggetto. Quell'oggetto è un contenitore di qualche tipo, che può essere un riquadro di visualizzazione, |
| |
Spesso un elenco. È possibile anche aggiungere un indice agli elenchi in questo modo. Quindi, quello che stiamo facendo è, sì, estrarre elementi annidati in questo oggetto report. |
| |
La prima cosa che faremo è il riquadro del contorno dell'altezza. Ricordatelo, e poi da lì passeremo al riquadro dei quantili, ricordatelo. |
| |
E ora siamo nel posto giusto. Dobbiamo solo prendere quello che vogliamo, quello che vogliamo è la casella con i numeri, giusto, e perché non aveva |
| |
Un titolo che potremmo usare (quello era quello qui sopra, nessun titolo), ma ci riferiamo ad esso tramite un numero. È la prima colonna numerica nella casella del contorno dei quantili. |
| |
Quindi potresti guardare questo e dire a te stesso, aspetta un attimo, ci sono dei numeri qui. Anche questa è una casella di testo con numeri, vero? No, in realtà non lo è. È una casella di testo con stringhe, e ricorda, puoi spuntare tutte quelle cose se vuoi. Anche questo è dalle proprietà. |
| |
E se clicco qui, |
| |
casella colonna numero, casella colonna stringa, casella colonna stringa. Li vedi qui? Stringa... numero stringa, quindi è la prima casella colonna numero. |
| |
E questo conquisterà tutti questi numeri. |
| |
Bene, l'ultima cosa che dobbiamo fare è questo indice. In questo modo, diciamo: "Dammi il sesto elemento... 1, 2, 3, 4, 5, 6". Questa è la mediana; è 63. E quando eseguiamo questa riga, che indicizza il report, prende quella mediana, in modo che possiamo riutilizzarla in seguito. |
| |
Ecco come estrarre qualcosa da un report. Ho un altro esempio che condividerò nei materiali della presentazione che conterrà |
| |
un elemento che ha un titolo e che puoi vedere, puoi usare come modello per svolgere il tuo lavoro, se ti trovi in quella situazione. |
| |
Bene, l'ultima cosa di cui parleremo è come ottenere input dal tuo utente, la persona che esegue lo script. |
| |
E lascia che scelgano quale file analizzare o anche quale colonna nella tabella dati analizzare. Quindi questa è forse la soluzione più comune. |
| |
Cosa che gli sceneggiatori principianti vogliono fare. Sai, ho impostato il mio script in modo che faccia qualcosa su una colonna e voglio dare qualcosa ad altre persone nella mia organizzazione. |
| |
per consentire loro di farlo da soli su dati diversi, giusto. Quindi se... se generalizzi i tuoi script in questo modo per consentire agli utenti di scegliere un file o una colonna, o entrambi, |
| |
Stai generalizzando il tuo script e ne stai aumentando notevolmente il valore. Lo condividerai con altre persone nella tua organizzazione. Potranno replicare il tuo lavoro e farlo rapidamente, senza dover passare attraverso tutti i clic. |
| |
Bene, in questa sezione, si tratterà più di una lista di cose da fare che di un caso di studio. Vi mostrerò tre metodi con cui potete consentire ai vostri utenti di scegliere i file e due metodi con cui potete consentire loro di scegliere le colonne. |
| |
E inizieremo con i metodi per selezionare i file. Come al solito, inizieremo facendo qualcosa nel log e poi copiandolo. Ecco... ecco cosa appare quando apri Big Class, ottieni questo nel log, apri Big Class. |
| |
dt. In questo caso sto usando dt, quindi, quando apro Big Class, |
| |
Ora...dt punta a Big Class, okay. E poi andrei avanti con la mia sceneggiatura, giusto. |
| |
Il punto è che per consentire all'utente di scegliere quale file desidera, tutto ciò che dobbiamo fare è trovare un modo per far sì che dt punti a qualcos'altro. |
| |
Scrivi il resto dello script, usa dt e poi all'inizio puoi modificarlo. dt non punta più solo a Big Class; punterà a qualcos'altro. |
| |
Bene, e questa è un'altra cosa che viene determinata dall'utente, |
| |
La persona che esegue lo script. Ok, la cosa più semplice che puoi fare, credo, è usare questa riga invece di aprire una tabella dati. Se la usi all'inizio dello script per assegnare dt, |
| |
ciò significa che JMP eseguirà questo script e fornirà quel dt |
| |
nome a qualsiasi tabella dati si trovi davanti. |
| |
Quindi dal punto di vista dell'utente, quello che fanno è aprire una tabella dati, aprirò sc20 qui e creerò sc20 |
| |
La mia tabella dati attuale. La vedi qui sopra? Quella elencata in questa finestra è la tabella dati attuale. |
| |
Quindi, se l'utente apre una tabella dati, esegue lo script e incontra questa riga, dt punterà a sc20. |
| |
Quindi è un metodo piuttosto potente. Il problema è che... richiede che l'utente sappia esattamente cosa fare. Deve sapere che deve prima aprire il file di dati e poi eseguire lo script. |
| |
Possiamo fare qualcosa di un po' più robusto. Possiamo mostrare loro un selettore di file quando eseguono lo script, in modo che possano navigare nella struttura delle directory e trovare il file giusto da aprire. |
| |
A quanto pare, è semplicissimo. Basta eliminare tutto il resto, eliminare il riferimento a "Big Class" e dire semplicemente "apri" senza alcuna argomentazione. |
| |
E quando JSL prova... quando JMP prova a interpretare questa riga, dice, ok, l'utente vuole aprire qualcosa, ma non ho cosa... non ho idea di cosa. Mostriamogli un selettore di file così possono decidere. |
| |
Quindi...eseguiamo questo. dt = open. |
| |
Esegui lo script. Ecco il tuo selettore di file generico e dal mio desktop aprirò Iris. |
| |
Iris è aperto e, naturalmente, ha il nome dt. |
| |
Tutti i file JMP, tutti i file, giusto. Potrebbero esserci un sacco di cose qui dentro. |
| |
Quindi se hai bisogno di più controllo, oops, se hai bisogno di più controllo su |
| |
le scelte che l'utente farà, invece di usare open, useremo qualcosa chiamato pick file. |
| |
Pick file è un comando che offre diverse opzioni. Io ne uso solo tre. |
| |
Esaminiamo questo esempio. Quindi i primi tre argomenti per pick file sono un titolo che vedrai nella finestra di selezione, |
| |
Una directory da cui verrà avviato il selettore e un filtro che indica quali file è possibile aprire da quel selettore, giusto? Quindi eseguiamo questa... questa riga, questa sezione di codice, il comando pick file, salvando il risultato in PF. |
| |
Eseguilo. |
| |
Ok, nota che questo è l'argomento qui, seleziona file Excel. Questo è ciò che vediamo qui sopra nel titolo della finestra. |
| |
La cartella, il percorso nel secondo argomento, è da lì che inizia. |
| |
E il terzo bit, il filtro file che dice, ehi, mostra all'utente solo i file Excel da aprire, è qui sotto. Non mi è permesso modificare le impostazioni per uscire dai file Excel. Sono limitato ai file Excel. |
| |
Quindi diciamo panini e clicchiamo su Apri. |
| |
Aspetta un attimo, perché non si è aperto? |
| |
Bene, controlliamo. PF equivale a pick file. Cos'è PF? Ah, PF è il percorso verso l'oggetto che vogliamo aprire. Non abbiamo ancora eseguito il comando open. Pick file non apre un file, lo seleziona e basta. |
| |
Quindi, per chiudere il cerchio, ecco cosa dobbiamo fare. Creiamo il nostro riferimento alla tabella aprendo il |
| |
Variabile PF, che punta al file che vogliamo, il file Excel che vogliamo. |
| |
Ecco fatto. Si apre la tabella dati dei sandwich e ora ho il mio dt e sono pronto per continuare con il mio script, proprio come volevo. |
| |
Vorrei fermarmi qui per mostrarvi una cosa importante. Scegliete il file, se vi imbattete in qualcosa di simile e non conoscete tutti gli argomenti e volete saperne di più, ecco un paio di cose. Prima di tutto, vi darò un piccolo |
| |
hover help, un piccolo pop-up che contiene informazioni sulla sintassi. Ecco un'opzione migliore. Fai clic destro nella finestra dello script, |
| |
e puoi cercarlo nell'indice degli script. L'indice degli script è uno strumento molto importante per qualsiasi programmatore JSL e |
| |
Contiene il comando che stai cercando. Contiene l'elenco degli argomenti, un po' di testo esplicativo e, cosa molto importante, un paio di esempi che puoi analizzare per vedere cosa fa. Quindi, se eseguo questo esempio qui, mi darà un file di selezione. |
| |
Beh, mi ha portato in un posto dove non voglio andare. |
| |
Chiudiamola e basta. |
| |
Bene, allora possiamo sperimentare e prendere questo codice, rubarlo e usarlo nel nostro...nel nostro script se vogliamo. |
| |
Ok, questo è l'indice degli script. È disponibile anche dal menu Aiuto. Menu Scripting... cerca lì sopra. |
| |
tabella dati corrente, un file aperto nudo o un file di selezione. Ci sono anche altri metodi, ma questi sono tre buoni modi per iniziare. |
| |
Ora parliamo di come consentire agli utenti di scegliere su quale colonna vogliono operare. |
| |
Eccomi qui...ho copiato qualcosa dal registro. Ho aperto una tabella dati chiamata "prezzi" e ho creato un grafico che mostra l'andamento del prezzo delle mele nel tempo. |
| |
Non vi mostrerò la parte "punta e clicca", eseguirò solo lo script. Credo che sappiate già come estrarre lo script dal registro avanzato, quindi vediamo cosa fa lo script. Apre i prezzi ed ecco il mio grafico, mele in funzione della data, prezzo delle mele nel tempo. |
| |
Quindi guarda questa tabella dati, i prezzi, sì, ci sono le mele, ma ho anche tutti questi tizi, giusto? E se volessi lasciare che sia l'utente a dirmi quale grafico vuole vedere, quale colonna vuole vedere rappresentata graficamente? |
| |
Ecco di cosa tratta questa sezione: lasciare che siano i tuoi utenti a scegliere. |
| |
Va bene. |
| |
Quindi parleremo di due metodi. Ecco il primo. |
| |
Funziona sulle colonne selezionate dall'utente. |
| |
E l'abbiamo già visto, abbiamo visto questa sintassi prima, credo, nel nostro secondo caso di studio. Sì, è così che creiamo una lista. |
| |
che contiene le colonne selezionate nella tabella dati. Torniamo quindi a quella tabella dati. |
| |
Selezionerò, forse tre colonne e |
| |
corriamo |
| |
questo. In realtà penso che dovrei eseguire dt. Eseguiamo entrambi. |
| |
pollo, caffè e uova. |
| |
Va bene. |
| |
COSÌ. |
| |
Su quale voglio operare? Beh, sai come operare, come iterare su una lista usando un ciclo, ma non lo faremo. Userò solo una scorciatoia. Dirò: guarda, |
| |
Se il mio utente ne ha selezionato più di uno, gli ho semplicemente mostrato il grafico del primo. Quindi il mio utente ha selezionato pollo, caffè e uova prima di eseguire lo script. Voglio solo mostrargli il grafico del pollo. |
| |
Bene, questa è la riga successiva. Ecco il nostro indicizzazione. Stiamo indicizzando l'elenco CNames per ottenere il primo elemento. |
| |
Quindi lo faremo. |
| |
Ora ho quella bella variabile, la mia colonna, |
| |
che ha il primo elemento dell'elenco, pollo, il riferimento di colonna con i due punti. |
| |
E ora possiamo usare il nostro generatore di grafici. Ora possiamo continuare con la nostra vita, l'unica differenza è che abbiamo sostituito le mele qui sopra, |
| |
questo è ora il mio colore. Questa è l'unica modifica che abbiamo apportato e quindi, eseguendo questo, otterremo un grafico del prezzo del pollo. |
| |
Bene. |
| |
Bene, questo è un modo, ma ripeto, come abbiamo detto prima, questo richiede che l'utente sappia cosa deve fare. Questo richiede... |
| |
Il metodo richiede che l'utente sappia che deve aprire la tabella dati, selezionarla e quindi eseguire lo script, e questo è un po' complicato. Quindi |
| |
Invece, è un po' più robusto mostrare all'utente una finestra di dialogo per la selezione delle colonne in fase di esecuzione. Ecco come appare. La sintassi è un po' complessa. Non entrerò nei dettagli, ne parlerò in dettaglio. Stiamo aprendo la tabella dati esattamente come prima. |
| |
Stiamo utilizzando questo comando chiamato dialogo colonna |
| |
per mostrare all'utente un selettore...selettore di colonne. |
| |
Di nuovo, ha molti argomenti. Ne sto usando solo un paio. Quello che sto facendo è dire, ehi, dammi un pulsante che dice "scegli prodotto", e l'utente può scegliere una colonna al massimo e deve sceglierne almeno una. |
| |
Quindi, eseguiamo questo script a partire dalla riga 60. |
| |
Prezzo di apertura, ecco il mio dialogo e guardate che dialogo ricco ho ottenuto con pochissimo codice. Questo è il vantaggio del dialogo a colonna che stiamo usando. Quindi sceglierò il caffè e cliccherò su OK. |
| |
Bene. Torniamo alla sceneggiatura, abbiamo appena ripetuto questa battuta. |
| |
E il risultato della nostra scelta è memorizzato in dlg. Diamo un'occhiata. |
| |
Va bene, è un po' complicato. Dice che dlg è un elenco, vedi le parentesi graffe, e ho delle parentesi graffe annidate, quindi è come se fossero elenchi annidati. |
| |
Ecco l'indicizzazione che ti porta lì. Non spenderò molto tempo a spiegarlo, ma puoi copiare questo codice se... se ne hai bisogno. Quindi, per passare dal dialogo alla parte che dice "caffè", un riferimento di colonna al caffè lì, |
| |
ecco l'indicizzazione per creare il mio col, quindi esegui questa riga. |
| |
E ora, la mia colonna contiene solo quel riferimento alla colonna del caffè, ed è identica a prima. Eseguiamo il generatore di grafici usando |
| |
il mio col, sostituendolo con le mele e così otteniamo un caffè o qualsiasi altra cosa l'utente abbia scelto. |
| |
Bene, questo è tutto ciò che volevo condividere con voi. Vorrei solo concludere con un piccolo consiglio per chiunque si avvicini alla programmazione JSL in questo modo. |
| |
Il consiglio è, sai, lasciare che JMP corregga il codice, il più possibile. Ed è a questo che serve il registro avanzato: ruba quel codice dal registro. Quella è la maggior parte del tuo script, |
| |
E poi devi solo scrivere il tessuto connettivo, le parti che tengono insieme le cose e le trasformano in uno script di produzione utilizzabile. Puoi anche rubare quel codice. Lo ruberai dall'indice degli script, puoi sicuramente rubare da questa presentazione. |
| |
Tutto il materiale è incluso in questa presentazione e puoi anche trarre spunto dal ricettario JSL nella JMP User Community, una fantastica risorsa che presenta molte attività JSL comuni e ti fornisce il codice necessario per realizzarle. |
| |
E ancora una volta, ci tengo a sottolineare, non preoccupatevi troppo della sintassi. È più facile prendere il codice e sostituirlo con quello che vi serve. Non rovinerete nulla e imparerete le sottigliezze di questa sintassi con l'esperienza. |
| |
Grazie mille per l'attenzione. |
