Con l'evoluzione della tecnologia, sono emersi nuovi strumenti e framework per la creazione di applicazioni web che visualizzano statistiche, mappe e grafici in tempo reale. Poiché queste funzionalità richiedono un'elevata elaborazione e sincronizzazione, i linguaggi di programmazione vengono utilizzati per ridurre il tempo di caricamento del server. In questo tutorial di R Shiny, spiegherò come utilizzare al meglio R su applicazioni web dinamiche.
Tratteremo e comprenderemo i seguenti argomenti:
Cos'è R Shiny?
Shiny è un pacchetto R che consente agli utenti di creare app Web interattive. Questo strumento crea un'app Web equivalente in HTML dal codice Shiny. Integriamo codice HTML e CSS nativo con le funzioni R Shiny per rendere presentabile l'applicazione. Shiny combina la potenza di calcolo di R con l'interattività del web moderno.Shiny crea app web che vengono distribuite sul web utilizzando il tuo server o i servizi di hosting di R Shiny.
Caratteristiche di R Shiny:
- Crea applicazioni facili con una conoscenza di base o nessuna conoscenza degli strumenti web
- Integra Shiny con strumenti web nativi per migliorare flessibilità e produttività
- I / O predefiniti e funzioni di rendering
- Rendering semplice del contenuto dell'applicazione senza ricariche multiple
- Funzionalità per aggiungere output calcolati (o elaborati) da script R.
- Aggiungi report e visualizzazioni in tempo reale.
Questo ci porta alla domanda:
In che modo Shiny è diverso dalle applicazioni tradizionali?
Facciamo un esempio di un'applicazione meteo, ogni volta che l'utente aggiorna / carica la pagina o modifica qualsiasi input, dovrebbe aggiornare l'intera pagina o parte della pagina utilizzando JS. Ciò aggiunge carico al lato server per l'elaborazione. Shiny consente all'utente di isolare o eseguire il rendering (o ricaricare) elementi nell'app, riducendo il carico del server. Scorrere le pagine era facile nelle applicazioni web tradizionali, ma era difficile con le app Shiny. La struttura del codice gioca il ruolo principale nella comprensione e nel debug del codice. Questa funzione è fondamentale per le app brillanti rispetto ad altre applicazioni.
Passiamo all'argomento successivo nel tutorial di R Shiny, l'installazione del pacchetto R Shiny.
Installazione di R Shiny
Installare Shiny è come installare qualsiasi altro pacchetto in R. Vai a Console R. ed esegui il comando seguente per installare il pacchetto Shiny.
come impostare il percorso java in Windows
install.packages ('brillante') 
Una volta installato, carica il pacchetto Shiny per creare app Shiny.
libreria (brillante)
Prima di andare oltre in questo brillante tutorial di R, vediamo e comprendiamo la struttura di un'applicazione Shiny.
Struttura di un'app Shiny
Shiny è composto da 3 componenti:
uno.Funzione dell'interfaccia utente
Interfaccia utente La funzione (UI) definisce il layout e l'aspetto dell'app. Puoi aggiungere tag CSS e HTML all'interno dell'app per renderla più presentabile. La funzione contiene tutti gli ingressi e le uscite da visualizzare nell'app. Ogni elemento (divisione o tabulazione o menu) all'interno dell'app è definito utilizzando le funzioni. A questi si accede utilizzando un ID univoco, come gli elementi HTML.Impariamo ulteriormente su varifunzioni utilizzate nell'app.
Funzioni di layout brillanti
headerPanel ()aggiungi un'intestazione all'app. titlePanel () definisce il sottotitolo dell'app. Guarda l'immagine sotto per una migliore comprensione di headerPanel e titlePanel .
SidebarLayout ()definisce il layout da tenere sidebarPanel e mainPanel elementi. Il layout divide la schermata dell'app nel pannello della barra laterale e nel pannello principale. Ad esempio, nell'immagine sottostante, il rettangolo rosso è il file mainPanel l'area e l'area del rettangolo nero verticalmente è sidebarPanel la zona.
wellPanel ()definisce un contenitore che contiene più oggetti app input / output oggetti nella stessa griglia.tabsetPanel ()crea un contenitore per contenere le schede. tabPanel () aggiunge la scheda all'app definendo elementi e componenti della scheda. Nell'immagine sotto, il neroil rettangolo è tabsetPanel oggetto e il rettangolo rosso è il tabPanel oggetto.navlistPanel ()fornisce un menu laterale con collegamenti a diversi pannelli a schede simili a tabsetPanel () come un elenco verticale sul lato sinistro dello schermo. Nell'immagine sotto, il rettangolo nero è navlistPanel oggetto e il rettangolo rosso è il tabPanel oggetto.
Oltre alle funzioni di layout Shiny, puoi anche aggiungere CSS in linea a ciascun widget di input nell'app.L'app Shiny incorpora caratteristiche delle tecnologie web insieme a caratteristiche e funzioni R brillanti per arricchire l'app. Usa i tag HTML all'interno dell'app Shiny usando tag $.
Il tuo layout è pronto, è ora di aggiungere widget nell'app. Shiny fornisce vari elementi di input e output dell'utente per l'interazione dell'utente. Parliamo di alcune funzioni di input e output.
Funzioni di input brillanti
Ogni widget di input ha un'etichetta, un ID, altri parametri come scelta, valore, selezionato, minimo, massimo, ecc.
selectInput ()- crea un elemento HTML a discesa.
selectInput ('select', h3 ('Select box'), choice = list ('Choice 1' = 1, 'Choice 2' = 2, 'Choice 3' = 3), selected = 1)numericInput ()- area di immissione per digitare un numero o un testo.
dateInput ('num', 'Date input', value = '2014-01-01') numericInput ('num', 'Numeric input', value = 1) textInput ('num', 'Numeric input', value = ' Inserire il testo...')tasti della radio()- creare pulsanti di opzione per l'input dell'utente.
radioButtons ('radio', h3 ('Radio buttons'), choice = list ('Choice 1' = 1, 'Choice 2' = 2, 'Choice 3' = 3), selected = 1)Funzioni Shiny Output
Shiny fornisce varie funzioni di output che vengono visualizzate R output come grafici, immagini, tabelle, ecc. che visualizzano corrispondenti R oggetto.
plotOutput ()- visualizza l'oggetto grafico R.
plotOutput'top_batsman ')
-
tableOutput ()- visualizza l'output come tabella.
tableOutput'player_table ')
2. Funzione server
server funzione ddefinisce la logica lato server dell'app Shiny. Implica la creazione di funzioni e output che utilizzano input per produrre vari tipi di output. Ogni client (browser web) chiama la funzione server quando carica per la prima volta l'app Shiny. Ogni output memorizza il valore restituito dalle funzioni di rendering.
Queste funzioni catturano un'espressione R ed eseguono calcoli e pre-elaborazione sull'espressione. Usa la funzione render * che corrisponde all'output che stai definendo. Accediamo ai widget di inpututilizzando input $ [widget-id] . Queste variabili di ingresso sono valori reattivi. Qualsiasi variabile intermedia creata utilizzando variabili di input deve essere resa reattiva utilizzando reattivo ({}) . Accedi alle variabili usando ().
render * le funzioni eseguono il calcolo all'interno della funzione server e memorizzano nelle variabili di output. L'output deve essere salvato con output $ [nome della variabile di output] . Ogni render * la funzione accetta un singolo argomento, ovvero un'espressione R racchiusa tra parentesi graffe, {}.
3. Funzione ShinyApp
shinyApp ()la funzione è il cuore dil'app che chiama CIPOLLA e server funzioni per creare un'app brillante.
L'immagine sotto mostra il contorno dell'app Shiny.
Passiamo al segmento successivo del tutorial R Shiny per creare la prima app R Shiny.
Crea un progetto web Shiny
Vai a File e crea un file Nuovo progetto in qualsiasi directory -> Applicazione web brillante -> [Nome della directory dell'applicazione Shiny]. Immettere il nome della directory e fare clic ok .
tipo di dati per la data in sql
Ogni nuovo progetto di app Shiny conterrà un esempio di istogramma per comprendere le basi di un'app brillante. L'app istogramma contiene un dispositivo di scorrimento seguito da un istogramma che aggiorna l'output per una modifica nel dispositivo di scorrimento. Di seguito è riportato l'output dell'app istogramma.
Per eseguire l'app Shiny, fare clic su Esegui l'app nell'angolo in alto a destra del riquadro delle sorgenti. L'app Shiny mostra un widget di scorrimento che prende il numero di contenitori come input e rende l'istogramma in base all'input.
Ora che hai capito la struttura e come eseguire un'app Shiny. Passiamo alla creazione della nostra prima app brillante.
Crea la prima app Shiny
Puoi creare un nuovo progetto o continuare nella stessa directory di lavoro. In questo tutorial R Shiny, creeremo una semplice app Shiny per mostrare le statistiche IPL. Il set di dati utilizzato nell'app può essere scaricato Qui . Il set di dati comprende 2 file, deliveries.csv contiene le consegne di punteggio per ogni palla (in over) battitore, bombetta, dettagli delle piste e match.csv Il file contiene i dettagli della partita come la posizione della partita, il lancio, la sede e i dettagli del gioco. L'app seguente richiede una conoscenza di base di dplyr e per capire il seguente tutorial.
Segui i passaggi seguenti per creare la tua prima app brillante.
Passo 1 : Crea lo schema di un'app Shiny.
Cancella il codice esistente ad eccezione delle definizioni di funzione nel file app . R file.
Passo 2 : Carica librerie e dati.
In questo passaggio, carichiamo i pacchetti e i dati richiesti. Quindi, pulire e trasformare i dati estratti nel formato richiesto. Aggiungi il codice seguente prima CIPOLLA e server funzione.
Codice:
library (shiny) library (tidyverse) # Caricamento dataset --------------------------------------- ---------------- deliveries = read.csv ('C: UsersCherukuri_SindhuDownloadsdeliveries.csv', stringsAsFactors = FALSE) corrisponde a read.csv ('C: UsersCherukuri_SindhuDownloadsmatches.csv', stringsAsFactors = FALSE) # Set di dati di pulizia --------------------------------------------- --------- nomi (corrispondenze) [1] = IPL 'match_id' = dplyr :: inner_join (corrispondenze, consegne)Spiegazione :
Le prime 2 righe vengono caricate tidyverse e Lucente pacchetto. Le 2 righe successive caricano le consegne e le corrispondenze dei set di dati e le memorizzano nelle variabiliconsegneepartite. Le ultime 2 righe aggiornano il nome della colonna del filepartiteset di dati per eseguire un join interno con il fileconsegnetavolo. Memorizziamo il risultato del join nel fileIPLvariabile.
Passaggio 3 : Crea il layout dell'app Shiny .
tutorial di informatica powercenter per principianti
Come discusso prima, il CIPOLLA funzione definisce l'aspetto, i widget e gli oggetti dell'app nell'app Shiny.Discutiamo lo stesso in dettaglio.
Codice
cipolla<- fluidPage( headerPanel('IPL - Indian Premier League'), tabsetPanel( tabPanel(title = 'Season', mainPanel(width = 12,align = 'center', selectInput('season_year','Select Season',choices=unique(sort(matches$season, decreasing=TRUE)), selected = 2019), submitButton('Go'), tags$h3('Players table'), div(style = 'border:1px black solidwidth:50%',tableOutput('player_table')) )), tabPanel( title = 'Team Wins & Points', mainPanel(width = 12,align = 'center', tags$h3('Team Wins & Points'), div(style = 'float:leftwidth:36%',plotOutput('wins_bar_plot')), div(style = 'float:rightwidth:64%',plotOutput('points_bar_plot')) ) )))Il CIPOLLA funzione contiene un file headerPanel () o titlePanel () e seguito da tabsetPanel per definire più schede nell'app. tabPanel () definisce gli oggetti per ciascuna scheda, rispettivamente. Ogni tabPanel () è composto da titolo e mainPanel (). mainPanel () crea un contenitore di larghezza 12 cioè finestra intera e allinea gli oggetti di input e output al centro.
Spiegazione
L'app è composta da 2 schede: Stagione e Vincite e punti della squadra.
Stagione la scheda è composta da selectInput ( ) , invia pulsante e una tabella. season_year viene utilizzato per leggere l'input da lè di valori. tableOutput () visualizza l'output della tabella calcolato sulla funzione server.La tabella player_table è visualizzata sotto il pulsante definito nella funzione server che sarà discussa nel passaggio successivo. Vincite e punti della squadra La scheda mostra la vittoria in base alla squadra e i punti nei rispettivi grafici a barre. plotOutput () mostra gli output restituiti dal rendering * funzioni. Tutto l'output, le funzioni di input sono racchiuse all'interno di un tag div per aggiungere uno stile in linea.
Ora che abbiamo familiarità con la funzione ui, andiamo avanti con la comprensione e l'utilizzo della funzione server nel nostro tutorial R Shiny.
Passaggio 4: aggiungere le istruzioni della funzione server
Il server funzione implica la creazione di funzioni e output che utilizzano gli input dell'utente per produrre vari tipi di output. Illa funzione server viene spiegata passo dopo passo di seguito.
match_anno = reattivo ({corrispondenze%>% filtro (stagione == input $ stagione_anno)}) playoff = reattivo ({nth (sort (match_year () $ match_id, decrescente = TRUE), 4)}) match_played = reattivo ({match_year ()%>% filter (match_id% group_by (team1)%>% summarize (count = n ())}) t2 = reattivo ({match_played ()%>% group_by (team2)%>% summarize (count = n ( ))}) wl = reattivo ({match_played ()%>% filter (winner! = '')%>% group_by (winner)%>% summarize (no_of_wins = n ())}) wl1 = reattivo ({match_played ( )%>% group_by (winner)%>% summarize (no_of_wins = n ())}) tied = reattivo ({match_played ()%>% filter (winner == '')%>% select (team1, team2)} ) playertable = reattivo ({data.frame (Teams = t1 () $ team1, Played = t1 () $ count + t2 () $ count, Wins = wl () $ no_of_wins, Points = wl () $ no_of_wins * 2) })Il filtro del codice precedente corrisponde a quello giocato prima dei playoff ogni anno e memorizza il risultato nella variabile match_played.player_tablela tabella contiene le statistiche delle partite a livello di squadra, ovvero giocate, vittorie e punti. Variabilimatch_played,player_table,t1,legato, ecc sono tutti intermedi valori reattivi . È necessario accedere a queste variabili utilizzando () come mostrato nel codice sopra.player_tableviene visualizzato utilizzando la funzione renderTable. Successivamente, crea la variabile di output per memorizzare playertable.
output $ player_table = renderTable ({playertable ()})Ora creiamo grafici a barre per mostrare vittorie e punti segnati da ogni squadra nella stagione. Il codice seguente mostra i grafici a barre utilizzando ggplot. renderPlot () recupera l'oggetto ggplot e memorizza il risultato in variabilewins_bar_plotIl codice ggplot è autoesplicativo, coinvolge grafici di base e funzioni di mappatura per modificare legenda, etichette e trama.
output $ wins_bar_plot = renderPlot ({ggplot (wl1 () [2: 9,], aes (winner, no_of_wins, fill = winner)) + geom_bar (stat = 'identity') + theme_classic () + xlab ('Teams') + ylab ('Number Of Wins') + theme (axis.text.x = element_text (color = 'white'), legend.position = 'none', axis.title = element_text (size = 14), plot.background = element_rect (color = 'white')) + geom_text (aes (x = winner, (no_of_wins + 0.6), label = no_of_wins, size = 7))}) output $ points_bar_plot = renderPlot ({ggplot (playertable (), aes ( Teams, Points, fill = Teams)) + geom_bar (stat = 'identity', size = 3) + theme_classic () + theme (axis.text.x = element_text (color = 'white'), legend.text = element_text ( size = 14), axis.title = element_text (size = 14)) + geom_text (aes (Teams, (Points + 1), label = Points, size = 7))})Passaggio 5: esegui l'app Shiny.
Fare clic su Esegui app. Con una corsa riuscita, la tua app Shiny apparirà come di seguito. Qualsiasi errore o avvertenzas relativi all'app, li visualizzerà in R Console.
Tab1 - Stagione
Tab2 - Vincite e punti della squadra
Vediamo comeimpostareAccount Shinyapps.io per distribuire le tue app Shiny.
Imposta un account Shinyapps.io
Vai a Shinyapps.io e accedi con le tue informazioni, quindi dai un nome account univoco per la pagina e salvalo. Dopo aver salvato correttamente, vedrai una procedura dettagliata per distribuire le app da R Console. Segui la procedura seguente per configurare il tuo account in Rstudio.
Passo 1. Installa rsconnect
install.packages ('rsconnect')Passo 2. Autorizza account
Il rsconnect pacchetto deve essere autorizzato al tuo account utilizzando un token e un segreto. Per fare ciò, copia l'intero comando come mostrato di seguito nella pagina del tuo dashboard in R console. Dopo aver immesso correttamente il comando in R, ora ti autorizzo a distribuire le applicazioni al tuo account Shinyapps.io.
rsconnect :: setAccountInfo (name = 'account name', token = 'token', secret = 'secret')
Passaggio 3. Distribuisci app
Usa il codice seguente per distribuire le app Shiny.
libreria (rsconnect) rsconnect :: deployApp ('path / to / your / app')Una volta impostato, sei pronto per distribuire le tue brillanti app.
Ora che hai imparato a creare ed eseguire app Shiny, distribuisci l'app che abbiamo appena creato in Shinyapps.io come spiegato sopra o fai clic su pubblicare, che è presente nell'angolo in alto a destra della finestra dell'app Shiny.
io speroche questo tutorial di R Shiny ti ha aiutato a imparare come creare ed eseguire un'app Shiny. Divertiti a creare bellissime app web interattive utilizzando R Shiny.
Se desideri imparare la programmazione R e costruire una carriera colorata in Data Analytics, dai un'occhiata al nostro che viene fornito con formazione dal vivo con istruttore e esperienza di progetto nella vita reale. Questa formazione ti aiuterà a comprendere l'analisi dei dati e ti aiuterà a ottenere la padronanza dell'argomento.