Med utvecklingen av teknik har nyare verktyg och ramar dykt upp för att bygga webbapplikationer som visar statistik, kartor och grafer i realtid. Eftersom dessa funktioner kräver hög bearbetning och synkronisering används programmeringsspråk för att minska serverns laddningstid. I denna R Shiny-handledning kommer jag att förklara hur du använder R på bästa möjliga sätt i dynamiska webbapplikationer.
Vi kommer att täcka och förstå följande ämnen:
Vad är R Shiny?
Shiny är ett R-paket som tillåter användare att bygga interaktiva webbappar. Detta verktyg skapar en HTML-motsvarande webbapp från blank kod. Vi integrerar inbyggd HTML- och CSS-kod med R Shiny-funktioner för att göra applikationen presentabel. Shiny kombinerar R-beräkningskraften med interaktiviteten hos den moderna webben.Shiny skapar webbappar som distribueras på webben med din server eller R Shiny's värdtjänster.
Funktioner hos R Shiny:
- Skapa enkla applikationer med grundläggande eller ingen kunskap om webbverktyg
- Integrera Shiny med integrerade webbverktyg för att förbättra flexibilitet och produktivitet
- Förbyggda I / O- och renderingsfunktioner
- Enkel återgivning av applikationsinnehållet utan flera omladdningar
- Funktion för att lägga till beräknade (eller bearbetade) utgångar från R-skript
- Lägg till liverapporter och visualiseringar.
Det leder oss till frågan:
Hur skiljer sig Shiny från traditionella applikationer?
Låt oss ta ett exempel på en väderapplikation, när användaren uppdaterar / laddar sidan eller ändrar någon ingång, bör den uppdatera hela sidan eller en del av sidan med JS. Detta lägger till belastning på serversidan för bearbetning. Shiny tillåter användaren att isolera eller återge (eller ladda om) element i appen vilket minskar serverbelastningen. Det var enkelt att bläddra i sidor i traditionella webbapplikationer men det var svårt med blanka appar. Kodens struktur spelar huvudrollen för att förstå och felsöka koden. Den här funktionen är avgörande för glänsande appar med avseende på andra applikationer.
hur man vänder en strängpython
Låt oss gå vidare till nästa ämne i R Shiny tutorial, installera R Shiny-paketet.
Installerar R Shiny
Installera Shiny är som att installera något annat paket i R. Gå till R-konsol och kör kommandot nedan för att installera det blanka paketet.
install.packages ('blank') 
När du har installerat laddar du det blanka paketet för att skapa blanka appar.
bibliotek (glänsande)
Innan vi går vidare i denna R-blanka handledning, låt oss se och förstå strukturen för en blank applikation.
Struktur för en blank app
Shiny består av 3 komponenter:
ett.Användargränssnittsfunktion
Användargränssnitt (UI) -funktionen definierar appens layout och utseende. Du kan lägga till CSS- och HTML-taggar i appen för att göra appen mer presentabel. Funktionen innehåller alla in- och utgångar som ska visas i appen. Varje element (division eller flik eller meny) i appen definieras med hjälp av funktioner. Dessa nås med ett unikt id, som HTML-element.Låt oss lära oss mer om olikafunktioner som används i appen.
Blanka layoutfunktioner
headerPanel ()lägg till en rubrik i appen. titlePanel () definierar underrubrik för appen. Se bilden nedan för en bättre förståelse av headerPanel och titlePanel .
SidebarLayout ()definierar layout att hålla sidofältPanel och mainPanel element. Layouten delar upp appskärmen i sidofältet och huvudpanelen. Till exempel, i bilden nedan är den röda rektangeln den mainPanel och det svarta rektangelområdet vertikalt är sidofältPanel område.
wellPanel ()definierar en behållare som innehåller flera inmatnings- / utgångsobjekt för objekt i samma rutnät.tabsetPanel ()skapar en behållare för att hålla flikar. tabPanel () lägger till flik i appen genom att definiera flikelement och komponenter. I bilden nedan, den svartarektangel är tabsetPanel objekt och den röda rektangeln är tabPanel objekt.navlistPanel ()ger en sidomeny med länkar till olika flikpaneler som liknar tabsetPanel () som en vertikal lista till vänster på skärmen. I bilden nedan är den svarta rektangeln navlistPanel objekt och den röda rektangeln är tabPanel objekt.
Tillsammans med blanka layoutfunktioner kan du också lägga till inbyggd CSS till varje ingångswidget i appen.Shiny-appen innehåller funktioner i webbteknologierna tillsammans med glänsande R-funktioner och funktioner för att berika appen. Använd HTML-taggar i den blanka appen med taggar $.
Din layout är klar. Det är dags att lägga till widgets i appen. Shiny tillhandahåller olika användarinmatnings- och utgångselement för användarinteraktion. Låt oss diskutera några in- och utgångsfunktioner.
Blanka ingångsfunktioner
Varje ingångsvidget har en etikett, Id, andra parametrar som val, värde, valt, min, max, etc.
selectInput ()- skapa ett dropdown-HTML-element.
selectInput ('select', h3 ('Select box'), choice = list ('Choice 1' = 1, 'Choice 2' = 2, 'Choice 3' = 3), vald = 1)numericInput ()- inmatningsområde för att skriva ett nummer eller en text.
dateInput ('num', 'Date input', value = '2014-01-01') numericInput ('num', 'Numeric input', value = 1) textInput ('num', 'Numeric input', value = ' Skriv text...')radioknappar()- skapa radioknappar för användarinmatning.
radioKnappar ('radio', h3 ('Radioknappar'), val = lista ('Val 1' = 1, 'Val 2' = 2, 'Val 3' = 3), vald = 1)Shiny Output-funktioner
Shiny ger olika utgångsfunktioner som visas R utgångar som plottar, bilder, tabeller, etc som visar motsvarande R objekt.
plotOutput ()- visa R-plotobjekt.
plotOutput'top_batsman ')
-
tableOutput ()- visar utdata som tabell.
tableOutput'player_table ')
2. Serverfunktion
Server funktion dundersöker serverns logik för Shiny-appen. Det handlar om att skapa funktioner och utgångar som använder ingångar för att producera olika typer av utdata. Varje klient (webbläsare) ringer till serverfunktionen när den först laddar appen Shiny. Varje utgång lagrar returvärdet från renderingsfunktionerna.
Dessa funktioner fångar ett R-uttryck och gör beräkningar och förbehandling av uttrycket. Använd render * -funktionen som motsvarar den utdata du definierar. Vi har åtkomst till input-widgetsanvänder sig av mata in $ [widget-id] . Dessa ingångsvariabler är reaktiva värden. Alla mellanliggande variabler som skapas med hjälp av inmatningsvariabler måste göras reaktiva med reaktiv ({}) . Få åtkomst till variablerna med ().
framställa * funktioner utför beräkningen inuti serverfunktionen och lagrar i utdatavariablerna. Utgången måste sparas med output $ [output variabelnamn] . Varje framställa * -funktionen tar ett enda argument, dvs ett R-uttryck omgivet av hängslen, {}.
3. ShinyApp-funktion
shinyApp ()funktion är hjärtat avappen som ringer LÖK och server funktioner för att skapa en blank app.
Bilden nedan visar konturen för den blanka appen.
Låt oss gå vidare till nästa segment i R Shiny-självstudien för att skapa den första R Shiny-appen.
Skapa ett glänsande webbprojekt
Gå till Fil och skapa en Nytt projekt i valfri katalog -> Glänsande webbapplikation -> [Namn på glänsande applikationskatalog]. Ange namnet på katalogen och klicka OK .
Varje nytt Shiny app-projekt kommer att innehålla ett histogramexempel för att förstå grunderna i en blank app. Histogramappen innehåller en skjutreglage följt av ett histogram som uppdaterar utdata för en ändring av skjutreglaget. Nedan visas utgången från histogramappen.
För att köra den blanka appen, klicka på Kör app i det övre högra hörnet av källfönstret. Den blanka appen visar en skjutreglage-widget som tar antalet lagerplatser som inmatning och gör histogrammet enligt ingången.
Nu när du förstod strukturen och hur du kör en blank app. Låt oss gå vidare och skapa vår första blanka app.
Skapa den första blanka appen
Du kan antingen skapa ett nytt projekt eller fortsätta i samma arbetskatalog. I denna R Shiny-handledning skapar vi en enkel Shiny-app för att visa IPL-statistik. Datauppsättningen som används i appen kan laddas ner här . Datauppsättningen består av två filer, leveranser.csv innehåller poängleveranser för varje boll (i över) slagman, bowler, kördetaljer och matches.csv filen innehåller matchningsdetaljer som matchplats, kast, plats och spelinformation. Nedanstående app kräver grundläggande kunskap om dplyr och för att förstå nedanstående handledning.
Följ stegen nedan för att skapa din första blanka app.
slå ihop sorteringsprogram i Java
Steg 1 : Skapa konturen för en blank app.
Rensa den befintliga koden förutom funktionsdefinitionerna i app . R fil.
Steg 2 : Ladda bibliotek och data.
I det här steget laddar vi de paket och data som krävs. Rengör sedan och omvandla extraherade data till önskat format. Lägg till koden nedan innan LÖK och server fungera.
Koda:
bibliotek (glänsande) bibliotek (tidyverse) # Laddar datauppsättning --------------------------------------- ---------------- leveranser = read.csv ('C: UsersCherukuri_SindhuDownloadsdeliveries.csv', stringsAsFactors = FALSE) matchar = read.csv ('C: UsersCherukuri_SindhuDownloadsmatches.csv', stringsAsFactors = FALSE) # Rengöringsdataset --------------------------------------------- --------- namn (matchningar) [1] = 'match_id' IPL = dplyr :: inner_join (matchningar, leveranser)Förklaring :
De första två raderna laddas tidyverse och Skinande paket. De nästa två raderna laddar datauppsättningar och matchar och lagrar i variablerleveranserochtändstickor. De sista två raderna uppdaterar kolumnnamnet påtändstickordataset för att utföra en inre koppling medleveransertabell. Vi lagrar kopplingsresultatet iIPLvariabel.
Steg 3 : Skapa layouten för Shiny-appen .
Som diskuterats tidigare har LÖK funktionen definierar appens utseende, widgets och objekt i den blanka appen.Låt oss diskutera detsamma i detalj.
Koda
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 funktionen innehåller en headerPanel () eller titlePanel () och följt av tabsetPanel för att definiera flera flikar i appen. tabPanel () definierar objekten för varje flik. Varje tabPanel () består av titel och mainPanel (). mainPanel () skapar en behållare med bredd 12 dvs hela fönstret och justera in- och utmatningsobjekt i mitten.
Förklaring
Appen består av två flikar: Säsong och Team vinner och poäng.
Säsong fliken består av välj Inmatning ( ) , skicka knapp och ett bord. säsong_år används för att läsa inmatning från lär av värden. tableOutput () visar tabellutdata beräknat på serverfunktion.Tabell player_table visas nedanför knappen som definieras i serverfunktionen som ska diskuteras i nästa steg. Team vinner och poäng fliken visar lagmässig vinst och poäng i respektive stapeldiagram. plotOutput () visar utgångar som returneras från renderingen * funktioner. Alla utdata, inmatningsfunktioner är inneslutna i en div-tagg för att lägga till inline-styling.
Nu när vi är bekanta med ui-funktionen, låt oss gå vidare med att förstå och använda serverfunktionen i vår R Shiny-handledning.
Steg 4: Lägg till serverfunktionsuttalanden
De server funktion innebär att skapa funktioner och outputs som använder användaringångar för att producera olika typer av utdata. Deserverfunktionen förklaras steg för steg nedan.
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)%>% summer (count = n ())}) t2 = reactive ({matches_played ()%>% group_by (team2)%>% summarize (count = n ( ))}) wl = reaktiv ({matches_played ()%>% filter (vinnare! = '')%>% group_by (vinnare)%>% sammanfatta (no_of_wins = n ())}) wl1 = reaktiv ({matches_played ( )%>% group_by (vinnare)%>% sammanfatta (no_of_wins = n ())}) bunden = reaktiv ({matches_played ()%>% filter (vinnare == '')%>% välj (team1, team2)} ) playertable = reaktivt ({data.frame (Teams = t1 () $ team1, Spelat = t1 () $ count + t2 () $ count, Wins = wl () $ no_of_wins, Points = wl () $ no_of_wins * 2) })Ovanstående kodfilter matchar spelas före slutspelet varje år och lagrar resultatet i variabeln matches_played.spelartabelltabellen innehåller lagvis matchstatistik, dvs. spelade, vinster och poäng. Variablermatchar,spelartabell,t1,bunden, etc är alla mellanliggande reaktiva värden . Dessa variabler måste nås med () som visas i koden ovan.spelartabellvisas med renderTable-funktionen. Skapa sedan utgångsvariabeln för att lagra spelbord.
output $ player_table = renderTable ({playertable ()})Nu kan vi skapa stapeldiagram för att visa vinster och poäng för varje lag under säsongen. Koden nedan visar stapeldiagram med ggplot. renderPlot () hämtar ggplot-objekt och lagrar resultatet i variabelwins_bar_plot.Ggplot-koden är självförklarande, den innefattar grundläggande grafik- och kartfunktioner för att redigera legend, etiketter och plot.
output $ wins_bar_plot = renderPlot ({ggplot (wl1 () [2: 9,], aes (vinnare, no_of_wins, fill = vinnare)) + geom_bar (stat = 'identitet') + theme_classic () + xlab ('Team') + ylab ('Antal vinster') + tema (axel.text.x = element_text (färg = 'vit'), legend.position = 'ingen', axel.titel = element_text (storlek = 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))))Steg 5: Kör appen Shiny.
Klicka på Kör app. Med en lyckad körning kommer din Shiny-app att se ut nedan. Eventuella fel eller varningarNär den är relaterad till appen kommer den att visas i R Console.
Tab1 - Säsong
Tab2 - Lagvinst och poäng
Låt oss se huratt ställa inShinyapps.io-konto för att distribuera dina blanka appar.
Ställ in Shinyapps.io-konto
Gå till Shinyapps.io och logga in med din information, ange sedan ett unikt kontonamn för sidan och spara den. När du har sparat framgångsrikt ser du en detaljerad procedur för att distribuera appar från R-konsolen. Följ proceduren nedan för att konfigurera ditt konto i Rstudio.
Steg 1. Installera rsconnect
install.packages ('rsconnect')Steg 2. Auktorisera konto
De koppla in paketet måste vara auktoriserat till ditt konto med en token och hemlighet. För att göra detta, kopiera hela kommandot som visas nedan på din instrumentpanelsida i R trösta. När du väl har angett kommandot framgångsrikt i R, godkänner jag dig nu att distribuera applikationer till ditt Shinyapps.io-konto.
rsconnect :: setAccountInfo (name = 'account name', token = 'token', secret = 'secret')
Steg 3. Distribuera app
Använd koden nedan för att distribuera blanka appar.
bibliotek (rsconnect) rsconnect :: deployApp ('sökväg / till / din / app')När du väl är klar är du redo att distribuera dina blanka appar.
Nu när du lärde dig att skapa och köra glänsande appar, distribuera appen som vi just skapade i Shinyapps.io som förklaras ovan eller klicka på publicera, som finns i det övre högra hörnet av det glänsande appfönstret.
jag hoppasatt denna R Shiny-handledning hjälpte dig att lära dig hur du skapar och kör en Shiny-app. Ha kul att skapa interaktiva och vackra webbappar med R Shiny.
Om du vill lära dig R-programmering och bygga en färgstark karriär inom Data Analytics, kolla in vår som kommer med instruktörsledad live-utbildning och verklig projektupplevelse. Denna utbildning hjälper dig att förstå dataanalys och hjälper dig att behärska ämnet.