R Shiny Tutorial: Alt du trenger å vite

Med utviklingen av teknologi har det dukket opp nyere verktøy og rammer for å bygge webapplikasjoner som viser sanntidsstatistikk, kart og grafer. Siden disse funksjonene krever høy prosessering og synkronisering, brukes programmeringsspråk for å redusere serverbelastningstiden. I denne R Shiny-opplæringen vil jeg forklare hvordan du utnytter R best på dynamiske webapplikasjoner.

Vi vil dekke og forstå følgende emner:

• • Hva er R Shiny?
  • Funksjoner av R Shiny
  • Hvordan er Shiny forskjellig fra tradisjonelle applikasjoner?
  • Installerer R Shiny
  • Strukturen til en skinnende app .
  • Lag den første skinnende appen .
  • Sett opp Shinyapps.io-konto

Hva er R Shiny?

Shiny er en R-pakke som lar brukerne bygge interaktive webapper. Dette verktøyet oppretter en HTML-ekvivalent webapp fra skinnende kode. Vi integrerer innfødt HTML og CSS-kode med R Shiny-funksjoner for å gjøre applikasjonen presentabel. Shiny kombinerer beregningskraften til R med interaktiviteten til det moderne nettet.Shiny oppretter nettapper som distribueres på nettet ved hjelp av serveren din eller R Shiny’s hosting-tjenester.

Funksjoner av R Shiny:

• Lag enkle applikasjoner med grunnleggende eller ingen kunnskap om nettverktøy
• Integrer Shiny med integrerte nettverktøy for å forbedre fleksibilitet og produktivitet
• Forhåndsbygde I / O- og gjengivelsesfunksjoner
• Enkel gjengivelse av applikasjonsinnholdet uten flere omlastinger
• Funksjon for å legge til beregnede (eller behandlede) utganger fra R-skript
• Legg til live rapporter og visualiseringer.

Det bringer oss til spørsmålet:

Hvordan er Shiny forskjellig fra tradisjonelle applikasjoner?

La oss ta et eksempel på en værapplikasjon, når brukeren oppdaterer / laster inn siden eller endrer noe, bør den oppdatere hele siden eller en del av siden ved hjelp av JS. Dette legger til belastning på serversiden for behandling. Shiny lar brukeren isolere eller gjengi (eller laste inn) elementer i appen som reduserer serverbelastningen. Det var enkelt å bla gjennom sider i tradisjonelle webapplikasjoner, men det var vanskelig med skinnende apper. Strukturen til koden spiller hovedrollen i å forstå og feilsøke koden. Denne funksjonen er avgjørende for skinnende apper med hensyn til andre applikasjoner.

La oss gå videre til neste emne i R Shiny tutorial, og installere R Shiny-pakken.

Installerer R Shiny

Installere Shiny er som å installere en hvilken som helst annen pakke i R. Gå til R-konsoll og kjør kommandoen nedenfor for å installere den blanke pakken.

install.packages ('skinnende')

Når du har installert, laster du inn den blanke pakken for å lage blanke apper.

bibliotek (skinnende)

Før vi går videre i denne R-skinnende opplæringen, la oss se og forstå strukturen til et skinnende program.

Strukturen til en skinnende app

Shiny består av 3 komponenter:

1. Brukergrensesnitt
2. Server
3. ShinyApp

en.Brukergrensesnittfunksjon

Brukergrensesnitt (UI) -funksjon definerer utformingen og utseendet til appen. Du kan legge til CSS- og HTML-koder i appen for å gjøre appen mer presentabel. Funksjonen inneholder alle innganger og utganger som skal vises i appen. Hvert element (inndeling eller fane eller meny) i appen er definert ved hjelp av funksjoner. Disse er tilgjengelige med en unik id, som HTML-elementer.La oss lære videre om forskjelligefunksjoner som brukes i appen.

Blanke oppsettfunksjoner

• headerPanel ()legg til en overskrift i appen. titlePanel () definerer underoverskrift til appen. Se bildet nedenfor for bedre forståelse av headerPanel og titlePanel .
  

• SidebarLayout ()definerer layout å holde sidepanel og mainPanel elementer. Oppsettet deler appskjermen i sidepanel og hovedpanel. For eksempel, i bildet nedenfor, er det røde rektangelet det mainPanel området og det svarte rektangelområdet vertikalt er sidepanel område.

• wellPanel ()definerer en container som holder flere objekter app input / output objekter i samme rutenett.
• tabsetPanel ()oppretter en container for å holde faner. tabPanel () legger til fane i appen ved å definere faneelementer og komponenter. I bildet nedenfor, den svarterektangel er tabsetPanel objektet og det røde rektangelet er tabPanel gjenstand.
• navlistPanel ()gir en sidemeny med lenker til forskjellige fanepaneler som ligner på tabsetPanel () som en vertikal liste på venstre side av skjermen. På bildet nedenfor er det svarte rektangelet navlistPanel objektet og det røde rektangelet er tabPanel gjenstand.

Sammen med skinnende layoutfunksjoner kan du også legge til innebygd CSS til hver inngangsmodul i appen.Shiny-appen inneholder funksjoner i webteknologiene sammen med skinnende R-funksjoner og funksjoner for å berike appen. Bruk HTML-koder i Shiny-appen ved hjelp av tagger $.

Oppsettet ditt er klart. Det er på tide å legge til småprogram i appen. Shiny gir forskjellige brukerinn- og utgangselementer for brukerinteraksjon. La oss diskutere noen få inngangs- og utgangsfunksjoner.

Blanke inngangsfunksjoner

Hver inngangsvidget har en etikett, Id, andre parametere som valg, verdi, valgt, min, maks, etc.

• selectInput ()- opprett et rullegardin HTML-element.

selectInput ('velg', h3 ('Velg boks'), valg = liste ('Valg 1' = 1, 'Valg 2' = 2, 'Valg 3' = 3), valgt = 1)

• numericInput ()- inntastingsområde for å skrive inn et tall eller en tekst.

dateInput ('num', 'Date input', value = '2014-01-01') numericInput ('num', 'Numeric input', value = 1) textInput ('num', 'Numeric input', value = ' Skriv inn tekst ... ')

android studio tutorials for nybegynnere

• radioKnapper ()- lage radioknapper for brukerinngang.

radioButtons ('radio', h3 ('Radio knapper'), valg = liste ('Valg 1' = 1, 'Valg 2' = 2, 'Valg 3' = 3), valgt = 1)

Blanke utgangsfunksjoner

Shiny gir forskjellige utgangsfunksjoner som vises R utganger som plott, bilder, tabeller osv. som viser tilsvarende R gjenstand.

• plotOutput ()- vis R-plotobjekt.

plotOutput'top_batsman ')

• tableOutput ()- viser utdata som tabell.

tableOutput'player_table ')

2. Serverfunksjon

Server funksjon ddefinerer server-logikken til Shiny-appen. Det innebærer å lage funksjoner og utganger som bruker innganger til å produsere forskjellige typer utdata. Hver klient (nettleser) ringer til serverfunksjonen når den laster inn Shiny-appen. Hver utgang lagrer returverdien fra gjengivelsesfunksjonene.

Disse funksjonene fanger et R-uttrykk og gjør beregninger og forbehandling på uttrykket. Bruk render * -funksjonen som tilsvarer utdataene du definerer. Vi får tilgang til input widgetsved hjelp av skriv inn $ [widget-id] . Disse inngangsvariablene er reaktive verdier. Eventuelle mellomvariabler opprettet ved hjelp av inngangsvariabler må gjøres reaktive ved hjelp av reaktiv ({}) . Få tilgang til variablene ved hjelp av ().

gjengi * funksjoner utfører beregningen inne i serverfunksjonen og lagrer i outputvariablene. Utgangen må lagres med output $ [navn på outputvariabel] . Hver gjengi * funksjon tar et enkelt argument, dvs. et R-uttrykk omgitt av seler, {}.

3. ShinyApp-funksjon

shinyApp ()funksjon er hjertet avappen som ringer LØK og server funksjoner for å lage en skinnende app.

hva brukes marionett til

Bildet nedenfor viser omrisset av Shiny-appen.

La oss gå videre til neste segment i R Shiny-opplæringen for å lage den første R Shiny App.

Lag et skinnende webprosjekt

Gå til Fil og Opprett en Nytt prosjekt i hvilken som helst katalog -> Blank webapplikasjon -> [Navn på katalogen for skinnende applikasjoner]. Skriv inn navnet på katalogen og klikk OK .

Hvert nye prosjekt med skinnende apper inneholder et histogrameksempel for å forstå det grunnleggende i en skinnende app. Histogramappen inneholder en glidebryter etterfulgt av et histogram som oppdaterer utdataene for endring i glidebryteren. Nedenfor vises utgangen fra histogramappen.

For å kjøre Shiny-appen, klikk på Kjør app -knappen øverst til høyre i kildepanelet. Shiny-appen viser en glidebryter som tar antall søppel som innspill og gjengir histogrammet i henhold til inngangen.

Nå som du forsto strukturen og hvordan du kjører en skinnende app. La oss gå videre og lage vår første skinnende app.

Lag den første skinnende appen

Du kan enten opprette et nytt prosjekt eller fortsette i samme arbeidskatalog. I denne R Shiny-opplæringen vil vi lage en enkel Shiny-app for å vise IPL-statistikk. Datasettet som brukes i appen kan lastes ned her . Datasettet består av to filer, leveranser.csv inneholder poengleveranser for hver ball (i over) batsman, bowler, løpedetaljer og matches.csv filen inneholder kampdetaljer som kampsted, kast, spillested og spilldetaljer. Appen nedenfor krever grunnleggende kunnskap om dplyr og for å forstå veiledningen nedenfor.

Følg trinnene nedenfor for å lage din første skinnende app.

Trinn 1 : Lag omrisset av en skinnende app.

Fjern eksisterende kode bortsett fra funksjonsdefinisjonene i app . R fil.

Steg 2 : Last inn biblioteker og data.

I dette trinnet laster vi inn nødvendige pakker og data. Rengjør og transformer deretter ekstraherte data til ønsket format. Legg til koden nedenfor før LØK og server funksjon.

Kode:

bibliotek (skinnende) bibliotek (tidyverse) # Laster datasett --------------------------------------- ---------------- leveranser = read.csv ('C: UsersCherukuri_SindhuDownloadsdeliveries.csv', stringsAsFactors = FALSE) treff = read.csv ('C: UsersCherukuri_SindhuDownloadsmatches.csv', stringsAsFactors = FALSE) # Rengjøringsdatasett --------------------------------------------- --------- names (matches) [1] = 'match_id' IPL = dplyr :: inner_join (matches, leverings)

Forklaring :

De første to linjene lastes inn tidyverse og Skinnende pakke. De neste to linjene laster datasettleveranser og samsvarer og lagrer i variablerleveranserogfyrstikker. De siste to linjene oppdaterer kolonnenavnet påfyrstikkerdatasett for å utføre en indre sammenkobling medleveranserbord. Vi lagrer sammenføyningsresultatet iIPLvariabel.

Trinn 3 : Lag oppsettet til Shiny-appen .

Som diskutert tidligere, LØK funksjon definerer appens utseende, småprogram og objekter i den skinnende appen.La oss diskutere det samme i detalj.

Kode

løk<- 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')) ) )))

De LØK funksjonen inneholder en headerPanel () eller titlePanel () og etterfulgt av tabsetPanel for å definere flere faner i appen. tabPanel () definerer henholdsvis objektene for hver fane. Hver tabPanel () består av tittel og mainPanel (). mainPanel () oppretter en beholder med bredde 12 dvs. full vindu og juster inn- og utgangsobjekter i midten.

Forklaring

Appen består av to faner: Årstid og Team vinner og poeng.

Årstid kategorien består av velg Inngang ( ) , send inn knapp og et bord. season_year brukes til å lese innspill fra ler av verdier. tableOutput () viser tabellutdata beregnet på serverfunksjon.Tabell player_table vises under knappen som er definert i serverfunksjonen som skal diskuteres i neste trinn. Team vinner og poeng fanen viser lagmessig gevinst og poeng i respektive stolpediagrammer. plotOutput () viser utganger som er returnert fra gjengivelse * funksjoner. Alle utgangs-, inngangsfunksjonene er lukket i en div-tag for å legge til innebygd styling.

Nå som vi er kjent med ui-funksjonen, la oss gå videre med å forstå og bruke serverfunksjonen i vår R Shiny tutorial.

Trinn 4: Legg til serverfunksjonene

De server funksjon innebærer å skape funksjoner og outputs som bruker brukerinnganger til å produsere forskjellige typer utdata. Deserverfunksjonen forklares trinnvis nedenfor.

matches_year = reactive ({matches%>% filter (season == input $ season_year)}) playoff = reactive ({nth (sort (matches_year () $ match_id, decreasing = TRUE), 4)}) matches_played = reactive ({matches_year ()%>% filter (match_id% group_by (team1)%>% oppsummere (count = n ())}) t2 = reaktiv ({matches_played ()%>% group_by (team2)%>% oppsummere (count = n ( ))}) wl = reaktiv ({matches_played ()%>% filter (vinner! = '')%>% group_by (vinner)%>% oppsummerer (no_of_wins = n ())}) wl1 = reaktiv ({matches_played ( )%>% group_by (vinner)%>% oppsummere (no_of_wins = n ())}) bundet = reaktiv ({matches_played ()%>% filter (vinner == '')%>% velg (team1, team2)} ) playertable = reaktiv ({data.frame (Teams = t1 () $ team1, Spilt = t1 () $ count + t2 () $ count, Wins = wl () $ no_of_wins, Points = wl () $ no_of_wins * 2) })

Ovennevnte koder filter kamper spilt før sluttspill hvert år, og lagrer resultatet i matches_played variabelen.spiller_tabellTabellen inneholder lagmessig kampstatistikk, dvs. spilt, seier og poeng. Variablerkamper_spilt,spiller_tabell,t1,uavgjort, etc er alle mellomliggende reaktive verdier . Disse variablene må nås ved hjelp av () som vist i koden ovenfor.spiller_tabellvises ved hjelp av renderTable-funksjonen. Deretter oppretter du outputvariabelen for å lagre spillbar.

output $ player_table = renderTable ({playertable ()})

Nå kan vi lage stolpediagrammer for å vise seire og poeng scoret av hvert lag i sesongen. Koden nedenfor viser stolpediagrammer ved hjelp av ggplot. renderPlot () henter ggplot-objekt og lagrer resultatet i variabelwins_bar_plot.Ggplot-koden er selvforklarende, den involverer grunnleggende grafikk og kartleggingsfunksjoner for å redigere forklaring, etiketter og plot.

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

Trinn 5: Kjør Shiny-appen.

Klikk på Kjør app. Med et vellykket løp vil din skinnende app se ut som nedenfor. Eventuelle feil eller advarslerer relatert til appen, vil den vise disse i R Console.

Tab1 - Sesong

hvordan du driver kraft i python

Tab2 - Lagvinner og poeng

La oss se hvordanå sette oppShinyapps.io-konto for å distribuere dine skinnende apper.

Sett opp Shinyapps.io-konto

Gå til Shinyapps.io og logg på med informasjonen din, og gi deretter et unikt kontonavn for siden og lagre den. Etter at du har lagret, vil du se en detaljert prosedyre for å distribuere apper fra R-konsollen. Følg fremgangsmåten nedenfor for å konfigurere kontoen din i Rstudio.

Trinn 1. Installer rsconnect

install.packages ('rsconnect')

Steg 2. Autoriser konto

De koble til pakken må være autorisert til kontoen din ved hjelp av et token og hemmelighet. For å gjøre dette, kopier hele kommandoen som vist nedenfor på dashbord siden i R konsoll. Når du har angitt kommandoen med suksess i R, autoriserer jeg deg nå til å distribuere applikasjoner til Shinyapps.io-kontoen din.

rsconnect :: setAccountInfo (name = 'account name', token = 'token', secret = 'secret')

Trinn 3. Distribuere app

Bruk koden nedenfor for å distribuere skinnende apper.

bibliotek (rsconnect) rsconnect :: deployApp ('path / to / your / app')

Når du er klar, er du klar til å distribuere de skinnende appene dine.

Nå som du lærte hvordan du oppretter og kjører skinnende apper, distribuerer vi appen vi nettopp opprettet i Shinyapps.io som forklart ovenfor, eller klikk på publisere, som er til stede øverst til høyre i vinduet Shiny app.

jeg håperat denne R Shiny-opplæringen hjalp deg med å lære hvordan du oppretter og kjører en Shiny-app. Ha det gøy med å lage interaktive og vakre nettapper med R Shiny.

Hvis du ønsker å lære R-programmering og bygge en fargerik karriere i Data Analytics, så sjekk ut vår som kommer med instruktørstyrt liveopplæring og reell prosjektopplevelse. Denne opplæringen vil hjelpe deg med å forstå dataanalyse og hjelpe deg med å mestre emnet.