R Shiny Tutorial: Alt hvad du behøver at vide

Denne R Shiny Tutorial giver dig en detaljeret og omfattende viden om R Shiny og hvordan du opretter interaktive webapplikationer.

Med udviklingen af ​​teknologi er der opstået nyere værktøjer og rammer til opbygning af webapplikationer, der viser statistikker, kort og grafer i realtid. Da disse funktioner kræver høj behandling og synkronisering, bruges programmeringssprog til at reducere serverindlæsningstiden. I denne R Shiny-vejledning forklarer jeg, hvordan du bedst udnytter R på dynamiske webapplikationer.



Vi vil dække og forstå følgende emner:



Hvad er R Shiny?

Shiny er en R-pakke, der giver brugerne mulighed for at oprette interaktive webapps. Dette værktøj opretter en HTML-ækvivalent webapp fra skinnende kode. Vi integrerer native HTML og CSS-kode med R Shiny-funktioner for at gøre applikationen præsentabel. Shiny kombinerer R's beregningskraft med interaktiviteten på det moderne web.Shiny opretter webapps, der implementeres på nettet ved hjælp af din server eller R Shiny's hosting-tjenester.

Funktioner ved R Shiny:

  • Opret nemme applikationer med grundlæggende eller ingen kendskab til webværktøjer
  • Integrer Shiny med native webværktøjer for at forbedre fleksibilitet og produktivitet
  • Forudbyggede I / O- og gengivelsesfunktioner
  • Nem gengivelse af applikationsindholdet uden flere genindlæsninger
  • Funktion til at tilføje beregnede (eller behandlede) output fra R-scripts
  • Tilføj live rapporter og visualiseringer.

Det bringer os til spørgsmålet:



Hvordan adskiller Shiny sig fra traditionelle applikationer?

Lad os tage et eksempel på en vejrapplikation, når brugeren opdaterer / indlæser siden eller ændrer input, skal den opdatere hele siden eller en del af siden ved hjælp af JS. Dette tilføjer belastning til serversiden til behandling. Blank giver brugeren mulighed for at isolere eller gengive (eller genindlæse) elementer i appen, hvilket reducerer serverbelastningen. Rulning gennem sider var let i traditionelle webapplikationer, men det var svært med skinnende apps. Kodens struktur spiller hovedrollen i forståelse og fejlretning af koden. Denne funktion er afgørende for skinnende apps med hensyn til andre applikationer.

Lad os gå videre til det næste emne i R Shiny-tutorial, hvor vi installerer R Shiny-pakken.

Installation af R Shiny

Installation af skinnende er som at installere enhver anden pakke i R. Gå til R-konsol og kør kommandoen nedenfor for at installere den blanke pakke.



install.packages ('skinnende')

Installer R Shiny - R shiny tutorial - Edureka

Når du har installeret, skal du indlæse den blanke pakke for at oprette blanke apps.

bibliotek (skinnende)

Før vi går videre i denne R-skinnende vejledning, skal vi se og forstå strukturen i en skinnende applikation.

Struktur af en skinnende app

Shiny består af 3 komponenter:

  1. Brugergrænseflade
  2. Server
  3. ShinyApp

en.Brugergrænsefladefunktion

Brugergrænseflade (UI) -funktion definerer appens layout og udseende. Du kan tilføje CSS- og HTML-tags i appen for at gøre appen mere præsentabel. Funktionen indeholder alle ind- og udgange, der skal vises i appen. Hvert element (division eller fane eller menu) inde i appen defineres ved hjælp af funktioner. Disse fås ved hjælp af et unikt id, som f.eks. HTML-elementer.Lad os lære videre om forskelligefunktioner, der bruges i appen.

Blanke layoutfunktioner

  • headerPanel ()tilføj en overskrift til appen. titlePanel () definerer underoverskrift til appen. Se nedenstående billede for en bedre forståelse af headerPanel og titlePanel .
  • SidebarLayout ()definerer layout, der skal holdes sidebarPanel og mainPanel elementer. Layoutet opdeler appskærm i sidepanel og hovedpanel. For eksempel i det nedenstående billede er det røde rektangel det mainPanel og det sorte rektangelområde er lodret sidebarPanel areal.

  • wellPanel ()definerer en container, der indeholder flere objekter app input / output objekter i det samme gitter.
  • tabsetPanel ()opretter en container til at holde faner. tabPanel () tilføjer fane i appen ved at definere fanelementer og komponenter. I nedenstående billede, den sorterektangel er tabsetPanel objekt og det røde rektangel er tabPanel objekt.
  • navlistPanel ()giver en sidemenu med links til forskellige fanepaneler, der ligner tabsetPanel () som en lodret liste på venstre side af skærmen. I nedenstående billede er det sorte rektangel navlistPanel objekt og det røde rektangel er tabPanel objekt.

Sammen med skinnende layoutfunktioner kan du også tilføje indbygget CSS til hver inputwidget i appen.Den skinnende app indeholder funktioner på webteknologierne sammen med skinnende R-funktioner og funktioner for at berige appen. Brug HTML-tags i den skinnende app ved hjælp af tags $.

Dit layout er klar. Det er tid til at tilføje widgets til appen. Shiny giver forskellige brugerinput- og outputelementer til brugerinteraktion. Lad os diskutere et par input- og outputfunktioner.

Blanke inputfunktioner

Hver inputwidget har en etiket, Id, andre parametre såsom valg, værdi, valgt, min, maks osv.

  • selectInput ()- Opret et dropdown HTML-element.
selectInput ('vælg', h3 ('Vælg felt'), valg = liste ('Valg 1' = 1, 'Valg 2' = 2, 'Valg 3' = 3), valgt = 1)

  • numericInput ()- indtastningsområde for at skrive et nummer eller en tekst.
dateInput ('num', 'Date input', value = '2014-01-01') numericInput ('num', 'Numeric input', value = 1) textInput ('num', 'Numeric input', value = ' Indtast tekst ... ')

  • radioKnapper ()- Opret radioknapper til brugerinput.
radioButtons ('radio', h3 ('Radio knapper'), valg = liste ('Valg 1' = 1, 'Valg 2' = 2, 'Valg 3' = 3), valgt = 1)

Blanke outputfunktioner

Shiny giver forskellige outputfunktioner, der vises R udgange som plots, billeder, tabeller osv., der viser tilsvarende R objekt.

  • plotOutput ()- vis R plot objekt.
plotOutput'top_batsman ')
  • tabel Output ()- viser output som tabel.
tableOutput'player_table ')

2. Serverfunktion

Server funktion defines server-logikken i Shiny-appen. Det involverer oprettelse af funktioner og output, der bruger input til at producere forskellige slags output. Hver klient (webbrowser) ringer til serverfunktionen, når den først indlæser Shiny-appen. Hver output gemmer returværdien fra gengivelsesfunktionerne.

Disse funktioner indfanger et R-udtryk og foretager beregninger og forbehandling af udtrykket. Brug gengivelsesfunktionen *, der svarer til det output, du definerer. Vi får adgang til input-widgetsved brug af input $ [widget-id] . Disse inputvariabler er reaktive værdier. Eventuelle mellemvariabler oprettet ved hjælp af inputvariabler skal gøres reaktive ved hjælp af reaktiv ({}) . Få adgang til variablerne ved hjælp af ().

gengive * funktioner udfører beregningen inde i serverfunktionen og gemmer i outputvariablerne. Outputtet skal gemmes med output $ [outputvariabelnavn] . Hver gengive * funktionen tager et enkelt argument, dvs. et R-udtryk omgivet af seler, {}.

3. ShinyApp-funktion

shinyApp ()funktion er hjertet iden app, der ringer LØG og server funktioner til at oprette en skinnende app.

Billedet nedenfor viser omridset af den skinnende app.

Lad os gå videre til det næste segment i R Shiny tutorial for at oprette den første R Shiny App.

Opret et skinnende webprojekt

Gå til Fil og Opret en Nyt projekt i enhver mappe -> Blank webapplikation -> [Navn på skinnende applikationsmappe]. Indtast navnet på telefonbogen, og klik på Okay .

Hvert nyt skinnende app-projekt indeholder et histogrameksempel for at forstå det grundlæggende i en skinnende app. Histogram-appen indeholder en skyder efterfulgt af et histogram, der opdaterer output for en ændring i skyderen. Nedenfor vises output fra histogram-appen.

For at køre den skinnende app skal du klikke på Kør app i øverste højre hjørne af kildepanelet. Den skinnende app viser en skyderwidget, der tager antallet af skraldespande som input og gengiver histogrammet i henhold til input.

Nu hvor du forstod strukturen, og hvordan du kører en skinnende app. Lad os gå videre med at oprette vores første skinnende app.

Opret den første skinnende app

Du kan enten oprette et nyt projekt eller fortsætte i den samme arbejdsmappe. I denne R Shiny-tutorial opretter vi en simpel Shiny-app, der viser IPL-statistik. Datasættet, der bruges i appen, kan downloades her . Datasættet består af 2 filer, leverings.csv indeholder scoreleverancer for hver bold (i over) batsman, bowler, detaljer om løb og matches.csv filen indeholder matchdetaljer såsom matchplacering, kast, sted og spiloplysninger. Appen nedenfor kræver grundlæggende viden om dplyr og at forstå nedenstående tutorial.

Følg nedenstående trin for at oprette din første skinnende app.

Trin 1 : Opret omridset af en skinnende app.

Ryd den eksisterende kode bortset fra funktionsdefinitionerne i app . R fil.

Trin 2 : Indlæs biblioteker og data.

I dette trin indlæser vi de nødvendige pakker og data. Rens derefter og omdann de udpakkede data til det krævede format. Tilføj nedenstående kode før LØG og server fungere.

Kode:

bibliotek (skinnende) bibliotek (tidyverse) # Indlæser datasæt --------------------------------------- ---------------- leveringer = read.csv ('C: UsersCherukuri_SindhuDownloadsdeliveries.csv', stringsAsFactors = FALSE) matches = read.csv ('C: UsersCherukuri_SindhuDownloadsmatches.csv', stringsAsFactors = FALSE) # Rengøringsdatasæt -------------------------------------------- --------- navne (matches) [1] = 'match_id' IPL = dplyr :: inner_join (matches, leveringer)

Forklaring :

De første 2 linier indlæses tidyverse og Skinnende pakke. De næste 2 linjer indlæser leveringer og matches af datasæt og gemmer i variablerleverancerogTændstikker. De sidste 2 linjer opdaterer kolonnenavnet påTændstikkerdatasæt for at udføre en indre sammenføjning medleverancerbord. Vi gemmer slutresultatet iIPLvariabel.

Trin 3 : Opret layoutet af den skinnende app .

big data tutorial for begyndere

Som tidligere omtalt, LØG funktion definerer appens udseende, widgets og objekter i den skinnende app.Lad os diskutere det samme detaljeret.

Kode

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

Det LØG funktionen indeholder en headerPanel () eller titlePanel () og efterfulgt af tabsetPanel for at definere flere faner i appen. tabPanel () definerer henholdsvis objekterne for hver fane. Hver tabPanel () består af titel og mainPanel (). mainPanel () opretter en beholder med bredde 12 dvs. fuldt vindue og justerer input- og outputobjekter i midten.

Forklaring

Appen består af 2 faner: Sæson og Team vinder og point.

Sæson fanen består af vælg Input ( ) , send-knap og en tabel. season_year bruges til at læse input fra ler af værdier. tabel Output () viser tabeloutput beregnet på serverfunktion.Tabel player_table vises under knappen, der er defineret i serverfunktionen, som skal diskuteres i det næste trin. Team vinder og point fanen viser holdmæssig gevinst og point i respektive søjlediagrammer. plotOutput () viser output returneret fra gengivelse * funktioner. Alle output-, inputfunktioner er lukket i et div-tag for at tilføje inline-styling.

Nu hvor vi er fortrolige med ui-funktionen, lad os gå videre med at forstå og bruge serverfunktion i vores R Shiny tutorial.

Trin 4: Tilføj serverfunktionens udsagn

Det server funktion involverer oprettelse af funktioner og outpuds, der bruger brugerindgange til at producere forskellige slags output. Detserverfunktion forklares trin for trin nedenfor.

matches_year = reaktiv ({matches%>% filter (sæson == input $ season_year)}) playoff = reaktiv ({nth (sort (matches_year () $ match_id, faldende = TRUE), 4)}) matches_played = reaktiv ({matches_year ()%>% filter (match_id% group_by (team1)%>% summarize (count = n ())}) t2 = reactive ({matches_played ()%>% group_by (team2)%>% summarize (count = n ( ))}) wl = reaktiv ({matches_played ()%>% filter (vinder! = '')%>% group_by (vinder)%>% opsummer (no_of_wins = n ())}) wl1 = reaktiv ({matches_played ( )%>% group_by (vinder)%>% opsummer (no_of_wins = n ())}) bundet = reaktivt ({matches_played ()%>% filter (vinder == '')%>% vælg (team1, team2)} ) playertable = reaktiv ({data.frame (Teams = t1 () $ team1, Spillet = t1 () $ count + t2 () $ count, Wins = wl () $ no_of_wins, Points = wl () $ no_of_wins * 2) })

Ovenstående kodefilterkampe, der blev spillet før slutspil hvert år, og gemmer resultatet i matches_played-variablen.spiller_tabelTabellen indeholder holdmæssig kampstatistik, dvs. spillet, sejre og point. Variablermatches_played,spiller_tabel,t1,bundetosv. er alle mellemliggende reaktive værdier . Disse variabler skal tilgås ved hjælp af () som vist i koden ovenfor.spiller_tabelvises ved hjælp af renderTable-funktionen. Opret derefter outputvariablen for at gemme afspilningstabel.

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

Lad os nu oprette søjlediagrammer for at vise sejre og point scoret af hvert hold i sæsonen. Koden nedenfor viser søjlediagrammer ved hjælp af ggplot. renderPlot () henter ggplot-objekt og gemmer resultatet i variabelwins_bar_plot.Ggplot-koden er selvforklarende, den involverer grundlæggende grafik og kortlægningsfunktioner til redigering af forklaring, etiketter og plot.

output $ wins_bar_plot = renderPlot ({ggplot (wl1 () [2: 9,], aes (vinder, no_of_wins, fill = vinder)) + geom_bar (stat = 'identitet') + theme_classic () + xlab ('Teams') + ylab ('Antal sejre') + tema (axis.text.x = element_text (farve = 'hvid'), legend.position = 'none', axis.title = element_text (størrelse = 14), plot.background = element_rect (color = 'white')) + geom_text (aes (x = vinder, (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 ( størrelse = 14), axis.title = element_text (størrelse = 14)) + geom_text (aes (Teams, (Points + 1), label = Points, størrelse = 7))))

Trin 5: Kør appen Shiny.

Klik på Kør app. Med en vellykket kørsel vil din Shiny app se ud som nedenfor. Enhver fejl eller advarseler relateret til appen, vil den vise disse i R Console.

Tab1 - Sæson

Tab2 - Team vinder og point

Lad os se hvordanat opretteShinyapps.io-konto for at implementere dine skinnende apps.

Opret Shinyapps.io-konto

Gå til Shinyapps.io og log ind med dine oplysninger, og giv derefter et unikt kontonavn til siden, og gem dem. Når du har gemt med succes, vil du se en detaljeret procedure til implementering af apps fra R-konsollen. Følg nedenstående procedure for at konfigurere din konto i Rstudio.

Trin 1. Installer rsconnect

install.packages ('rsconnect')

Trin 2. Godkend konto

Det rtilslut pakken skal godkendes til din konto ved hjælp af et token og hemmelighed. For at gøre dette skal du kopiere hele kommandoen som vist nedenfor på din dashboardside i R konsol. Når du har indtastet kommandoen med succes i R, giver jeg dig nu tilladelse til at distribuere applikationer til din Shinyapps.io-konto.

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

Trin 3. Implementer app

Brug nedenstående kode til at implementere skinnende apps.

bibliotek (rsconnect) rsconnect :: deployApp ('sti / til / din / app')

Når du er indstillet, er du klar til at implementere dine skinnende apps.

Nu hvor du lærte at oprette og køre skinnende apps, skal du installere den app, vi lige har oprettet i Shinyapps.io som forklaret ovenfor eller klikke på offentliggøre, som findes i øverste højre hjørne af det skinnende appvindue.

Jeg håberat denne R Shiny tutorial hjalp dig med at lære, hvordan du opretter og kører en Shiny app. Hav det sjovt ved at skabe interaktive og smukke webapps ved hjælp af R Shiny.

Hvis du ønsker at lære R-programmering og opbygge en farverig karriere i Data Analytics, så tjek vores som kommer med instruktørstyret live træning og projektoplevelse i det virkelige liv. Denne træning hjælper dig med at forstå dataanalyser og hjælpe dig med at opnå beherskelse af emnet.