Mit der Entwicklung der Technologie sind neuere Tools und Frameworks zum Erstellen von Webanwendungen entstanden, die Echtzeitstatistiken, Karten und Grafiken anzeigen. Da diese Funktionen eine hohe Verarbeitung und Synchronisation erfordern, werden Programmiersprachen verwendet, um die Serverladezeit zu reduzieren. In diesem Tutorial zu R Shiny werde ich erklären, wie Sie R in dynamischen Webanwendungen optimal nutzen können.
Wir werden die folgenden Themen behandeln und verstehen:
Was ist R Shiny?
Shiny ist ein R-Paket, mit dem Benutzer interaktive Webanwendungen erstellen können. Dieses Tool erstellt eine HTML-äquivalente Web-App aus Shiny-Code. Wir integrieren nativen HTML- und CSS-Code in R Shiny-Funktionen, um die Anwendung präsentabel zu machen. Shiny kombiniert die Rechenleistung von R mit der Interaktivität des modernen Webs.Shiny erstellt Web-Apps, die über Ihren Server oder die Hosting-Services von R Shiny im Web bereitgestellt werden.
Eigenschaften von R Shiny:
- Erstellen Sie einfache Anwendungen mit grundlegenden oder keinen Kenntnissen über Web-Tools
- Integrieren Sie Shiny in native Web-Tools, um Flexibilität und Produktivität zu verbessern
- Vorgefertigte E / A- und Renderfunktionen
- Einfaches Rendern des Anwendungsinhalts ohne mehrfaches Nachladen
- Funktion zum Hinzufügen von berechneten (oder verarbeiteten) Ausgaben von R-Skripten
- Fügen Sie Live-Berichte und Visualisierungen hinzu.
Das bringt uns zu der Frage:
Wie unterscheidet sich Shiny von herkömmlichen Anwendungen?
Nehmen wir ein Beispiel für eine Wetteranwendung. Wenn der Benutzer die Seite aktualisiert / lädt oder Eingaben ändert, sollte die gesamte Seite oder ein Teil der Seite mit JS aktualisiert werden. Dies erhöht die Belastung der Serverseite für die Verarbeitung. Mit Shiny kann der Benutzer Elemente in der App isolieren oder rendern (oder neu laden), wodurch die Serverlast verringert wird. Das Scrollen durch Seiten war in herkömmlichen Webanwendungen einfach, in Shiny-Apps jedoch schwierig. Die Struktur des Codes spielt die Hauptrolle beim Verständnis und Debuggen des Codes. Diese Funktion ist für glänzende Apps im Vergleich zu anderen Anwendungen von entscheidender Bedeutung.
Fahren wir mit dem nächsten Thema im R Shiny-Lernprogramm fort und installieren das R Shiny-Paket.
R Shiny installieren
Das Installieren von Shiny ist wie das Installieren eines anderen Pakets in R. Gehen Sie zu R Konsole Führen Sie den folgenden Befehl aus, um das Shiny-Paket zu installieren.
install.packages ('glänzend')
Laden Sie nach der Installation das Shiny-Paket, um Shiny-Apps zu erstellen.
Bibliothek (glänzend)
Bevor wir in diesem R-Shiny-Tutorial weiter vorgehen, wollen wir die Struktur einer Shiny-Anwendung sehen und verstehen.
Struktur einer Shiny App
Shiny besteht aus 3 Komponenten:
ein.Benutzeroberflächenfunktion
Benutzeroberfläche Die (UI) -Funktion definiert das Layout und das Erscheinungsbild der App. Sie können der App CSS- und HTML-Tags hinzufügen, um die App präsentabler zu machen. Die Funktion enthält alle Ein- und Ausgänge, die in der App angezeigt werden sollen. Jedes Element (Unterteilung oder Registerkarte oder Menü) in der App wird mithilfe von Funktionen definiert. Auf diese wird wie bei HTML-Elementen mit einer eindeutigen ID zugegriffen.Lassen Sie uns mehr über verschiedene lernenFunktionen in der App verwendet.
Glänzende Layoutfunktionen
headerPanel ()
Fügen Sie der App eine Überschrift hinzu. titlePanel () Definiert die Unterüberschrift der App. Siehe das folgende Bild für ein besseres Verständnis von headerPanel und titlePanel .
SidebarLayout ()
definiert das zu haltende Layout SeitenleistePanel und Hauptfeld Elemente. Das Layout unterteilt den App-Bildschirm in Seitenleisten und Hauptfenster. Im folgenden Bild ist das rote Rechteck beispielsweise das Hauptfeld Bereich und der schwarze Rechteckbereich vertikal ist SeitenleistePanel Bereich.
wellPanel()
Definiert einen Container, der mehrere Objekte enthält. Eingabe- / Ausgabeobjekte der App im selben Raster.tabsetPanel ()
Erstellt einen Container für Tabulatoren. tabPanel () Fügt der App eine Registerkarte hinzu, indem Registerkartenelemente und -komponenten definiert werden. Im folgenden Bild das SchwarzRechteck ist tabsetPanel Objekt und das rote Rechteck ist das tabPanel Objekt.navlistPanel ()
bietet ein Seitenmenü mit Links zu verschiedenen Registerkarten ähnlich wie tabsetPanel () wie eine vertikale Liste auf der linken Seite des Bildschirms. Im folgenden Bild ist das schwarze Rechteck navlistPanel Objekt und das rote Rechteck ist das tabPanel Objekt.
Neben den Funktionen für glänzendes Layout können Sie jedem Eingabe-Widget in der App auch Inline-CSS hinzufügen.Die Shiny-App enthält Funktionen der Webtechnologien sowie glänzende R-Features und -Funktionen, um die App zu bereichern. Verwenden Sie HTML-Tags in der Shiny-App mit Tags $.
Unterschied zwischen Methodenüberladung und Überschreiben in Java
Ihr Layout ist fertig. Es ist Zeit, Widgets zur App hinzuzufügen. Shiny bietet verschiedene Benutzereingabe- und -ausgabeelemente für die Benutzerinteraktion. Lassen Sie uns einige Eingabe- und Ausgabefunktionen diskutieren.
Glänzende Eingabefunktionen
Jedes Eingabe-Widget verfügt über eine Bezeichnung, eine ID und andere Parameter wie Auswahl, Wert, Ausgewählt, Min, Max usw.
selectInput ()
- Erstellen Sie ein Dropdown-HTML-Element.
selectInput ('select', h3 ('Select box'), Auswahl = Liste ('Auswahl 1' = 1, 'Auswahl 2' = 2, 'Auswahl 3' = 3), ausgewählt = 1)
numericInput ()
- Eingabebereich zur Eingabe einer Zahl oder eines Textes.
dateInput ('num', 'Datumseingabe', Wert = '2014-01-01') numericInput ('num', 'Numerische Eingabe', Wert = 1) textInput ('num', 'Numerische Eingabe', Wert = ' Text eingeben...')
Radio Knöpfe()
- Erstellen Sie Optionsfelder für Benutzereingaben.
radioButtons ('radio', h3 ('Optionsfelder'), Auswahl = Liste ('Auswahl 1' = 1, 'Auswahl 2' = 2, 'Auswahl 3' = 3), ausgewählt = 1)
Shiny Output-Funktionen
Shiny bietet verschiedene Ausgabefunktionen, die angezeigt werden R. Ausgaben wie Diagramme, Bilder, Tabellen usw., die entsprechend angezeigt werden R. Objekt.
plotOutput ()
- R-Plot-Objekt anzeigen.
plotOutput'top_batsman ')
-
tableOutput ()
- Zeigt die Ausgabe als Tabelle an.
tableOutput'player_table ')
2. Serverfunktion
Server Funktion dDefiniert die serverseitige Logik der Shiny-App. Dabei werden Funktionen und Ausgaben erstellt, die Eingaben verwenden, um verschiedene Arten von Ausgaben zu erzeugen. Jeder Client (Webbrowser) ruft die Serverfunktion auf, wenn er die Shiny-App zum ersten Mal lädt. Jede Ausgabe speichert den Rückgabewert der Renderfunktionen.
Diese Funktionen erfassen einen R-Ausdruck und führen Berechnungen und Vorverarbeitungen für den Ausdruck durch. Verwenden Sie die Funktion render *, die der von Ihnen definierten Ausgabe entspricht. Wir greifen auf Eingabe-Widgets zumit Eingabe $ [Widget-ID] . Diese Eingangsvariablen sind reaktive Werte. Alle Zwischenvariablen, die mit Eingabevariablen erstellt wurden, müssen mit reaktiv gemacht werden reaktiv ({}) . Greifen Sie mit () auf die Variablen zu.
machen * Funktionen führen die Berechnung innerhalb der Serverfunktion durch und speichern sie in den Ausgabevariablen. Die Ausgabe muss mit gespeichert werden Ausgabe $ [Name der Ausgabevariable] . Jeder machen * Die Funktion verwendet ein einzelnes Argument, d. h. einen von geschweiften Klammern umgebenen R-Ausdruck {}.
3. ShinyApp-Funktion
shinyApp ()
Funktion ist das Herzstück vondie App, die anruft ZWIEBEL und Server Funktionen zum Erstellen einer Shiny App.
Das folgende Bild zeigt den Umriss der Shiny-App.
Fahren wir mit dem nächsten Abschnitt im R Shiny-Lernprogramm fort, um die erste R Shiny-App zu erstellen.
Erstellen Sie ein Shiny-Webprojekt
Gehe zu Datei und erstellen Sie eine Neues Projekt in einem beliebigen Verzeichnis -> Glänzende Webanwendung -> [Name des glänzenden Anwendungsverzeichnisses]. Geben Sie den Namen des Verzeichnisses ein und klicken Sie auf OK .
Jedes neue Shiny-App-Projekt enthält ein Histogramm-Beispiel, um die Grundlagen einer Shiny-App zu verstehen. Die Histogramm-App enthält einen Schieberegler, gefolgt von einem Histogramm, das die Ausgabe für eine Änderung des Schiebereglers aktualisiert. Unten ist die Ausgabe der Histogramm-App.
Klicken Sie auf, um die Shiny-App auszuführen App ausführen Schaltfläche in der oberen rechten Ecke des Quellbereichs. Die Shiny-App zeigt ein Schieberegler-Widget an, das die Anzahl der Fächer als Eingabe verwendet und das Histogramm entsprechend der Eingabe rendert.
Wie erstelle ich ein Array von Objekten in Java?
Nachdem Sie die Struktur und das Ausführen einer Shiny-App verstanden haben. Lassen Sie uns fortfahren, um unsere erste Shiny App zu erstellen.
Erstellen Sie die erste Shiny-App
Sie können entweder ein neues Projekt erstellen oder im selben Arbeitsverzeichnis fortfahren. In diesem R Shiny-Tutorial erstellen wir eine einfache Shiny-App, um IPL-Statistiken anzuzeigen. Der in der App verwendete Datensatz kann heruntergeladen werden Hier . Der Datensatz umfasst 2 Dateien, Lieferungen.csv Enthält Punktelieferungen für jeden Ball (in über) Schlagmann, Bowler, Laufdetails und Übereinstimmungen.csv Die Datei enthält Spieldetails wie Spielort, Wurf, Veranstaltungsort und Spieldetails. Die folgende App erfordert Grundkenntnisse von dplyr und um das folgende Tutorial zu verstehen.
Befolgen Sie die folgenden Schritte, um Ihre erste glänzende App zu erstellen.
Schritt 1 :: Erstellen Sie den Umriss einer Shiny-App.
Löschen Sie den vorhandenen Code mit Ausnahme der Funktionsdefinitionen in der App . R. Datei.
Schritt 2 :: Laden Sie Bibliotheken und Daten.
In diesem Schritt laden wir die erforderlichen Pakete und Daten. Bereinigen Sie anschließend die extrahierten Daten und wandeln Sie sie in das erforderliche Format um. Fügen Sie zuvor den folgenden Code hinzu ZWIEBEL und Server Funktion.
Code:
Bibliothek (glänzend) Bibliothek (tidyverse) # Laden des Datensatzes --------------------------------------- ---------------- Deliveries = read.csv ('C: UsersCherukuri_SindhuDownloadsdeliveries.csv', stringsAsFactors = FALSE) match = read.csv ('C: UsersCherukuri_SindhuDownloadsmatches.csv', stringsAsFactors = FALSE) # Dataset bereinigen ----------------------------------------- --------- Namen (Übereinstimmungen) [1] = 'match_id' IPL = dplyr :: inner_join (Übereinstimmungen, Lieferungen)
Erläuterung ::
Die ersten 2 Zeilen werden geladen tidyverse und Glänzend Paket. In den nächsten 2 Zeilen werden Datasets-Lieferungen und -Matches geladen und in Variablen gespeichertLieferungen
undStreichhölzer
. Die letzten 2 Zeilen aktualisieren den Spaltennamen desStreichhölzer
Datensatz, um einen inneren Join mit dem durchzuführenLieferungen
Tabelle. Wir speichern das Join-Ergebnis imIPL
Variable.
Schritt 3 :: Erstellen Sie das Layout der Shiny App .
Wie bereits erwähnt, ist die ZWIEBEL Die Funktion definiert das Erscheinungsbild, die Widgets und die Objekte der App in der Shiny-App.Lassen Sie uns dasselbe im Detail diskutieren.
Code
Zwiebel<- 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')) ) )))
Das ZWIEBEL Funktion enthält a headerPanel () oder titlePanel () und gefolgt von tabsetPanel um mehrere Registerkarten in der App zu definieren. tabPanel () definiert die Objekte für jede Registerkarte. Jeder tabPanel () besteht aus Titel und Hauptfeld(). Hauptfeld() Erstellt einen Container mit der Breite 12, d. h. das vollständige Fenster, und richtet die Eingabe- und Ausgabeobjekte in der Mitte aus.
Erläuterung
Die App besteht aus 2 Registerkarten: Jahreszeit und Team gewinnt & Punkte.
Jahreszeit Registerkarte besteht aus selectInput (( ) , Submit-Button und eine Tabelle. saison_Jahr wird verwendet, um Eingaben aus dem l zu lesenist of values. tableOutput () Zeigt die für die Serverfunktion berechnete Tabellenausgabe an.Die Tabelle player_table wird unter der Schaltfläche angezeigt, die in der Serverfunktion definiert ist und im nächsten Schritt erläutert wird. Team gewinnt & Punkte Die Registerkarte zeigt den teamweisen Gewinn und die Punkte in den jeweiligen Balkendiagrammen an. plotOutput () Zeigt die vom Rendern zurückgegebenen Ausgaben an * * Funktionen. Alle Ausgabe- und Eingabefunktionen sind in einem div-Tag enthalten, um das Inline-Styling hinzuzufügen.
Nachdem wir mit der UI-Funktion vertraut sind, wollen wir in unserem R Shiny-Tutorial die Serverfunktion verstehen und verwenden.
Schritt 4: Fügen Sie die Serverfunktionsanweisungen hinzu
Das Server Funktion beinhaltet das Erstellen von Funktionen und Outputs, die Benutzereingaben verwenden, um verschiedene Arten von Ausgaben zu erzeugen. DasDie Serverfunktion wird im Folgenden Schritt für Schritt erläutert.
Übereinstimmungen_Jahr = reaktiv ({Übereinstimmungen%>% Filter (Saison == Eingabe $ Saison_Jahr)}) Playoff = Reaktiv ({n-te (Sortierung (Übereinstimmungen_Jahr () $ Match_ID, abnehmend = WAHR), 4)}) Übereinstimmungen = Reaktiv ({Übereinstimmungen_Jahr) ()%>% filter (match_id% group_by (team1)%>% zusammenfassen (count = n ())}) t2 = reaktiv ({match_played ()%>% group_by (team2)%>% zusammenfassen (count = n () ))}) wl = reaktiv ({Matches_played ()%>% Filter (Gewinner! = '')%>% group_by (Gewinner)%>% zusammenfassen (no_of_wins = n ())}) wl1 = reaktiv ({Matches_played ( )%>% group_by (Gewinner)%>% zusammenfassen (no_of_wins = n ())}) gebunden = reaktiv ({Matches_played ()%>% Filter (Gewinner == '')%>% select (Team1, Team2)} ) playertable = reaktiv ({data.frame (Teams = t1 () $ team1, gespielt = t1 () $ count + t2 () $ count, Wins = wl () $ no_of_wins, Points = wl () $ no_of_wins * 2) })
Der obige Codefilter entspricht den Übereinstimmungen, die jedes Jahr vor den Playoffs gespielt werden, und speichert das Ergebnis in der Variablen match_played.player_table
Die Tabelle enthält teambezogene Spielstatistiken, z. B. gespielte Spiele, Siege und Punkte. VariablenÜbereinstimmungen_gespielt
,player_table
,t1
,gebunden
usw. sind alle mittelschwer reaktive Werte . Auf diese Variablen muss mit () zugegriffen werden, wie im obigen Code gezeigt.player_table
wird mit der Funktion renderTable angezeigt. Erstellen Sie als Nächstes die Ausgabevariable zum Speichern der Wiedergabetabelle.
wie man Eclipse unter Windows ausführt
Ausgabe $ player_table = renderTable ({playertable ()})
Jetzt können Sie Balkendiagramme erstellen, um die Gewinne und Punkte anzuzeigen, die jedes Team in der Saison erzielt hat. Der folgende Code zeigt Balkendiagramme mit ggplot an. renderPlot () ruft das ggplot-Objekt ab und speichert das Ergebnis in einer Variablenwon_bar_plot
Der ggplot-Code ist selbsterklärend und umfasst grundlegende Grafik- und Zuordnungsfunktionen zum Bearbeiten von Legenden, Beschriftungen und Plots.
Ausgabe $ wins_bar_plot = renderPlot ({ggplot (wl1 () [2: 9,], aes (Gewinner, no_of_wins, fill = Gewinner)) + geom_bar (stat = 'Identität') + theme_classic () + xlab ('Teams') + ylab ('Anzahl der Siege') + Thema (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 = Gewinner, (no_of_wins + 0.6), label = no_of_wins, size = 7))}) output $ points_bar_plot = renderPlot ({ggplot (playertable (), aes () Teams, Punkte, füllen = Teams)) + geom_bar (stat = 'Identität', Größe = 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, (Punkte + 1), label = Punkte, size = 7)})
Schritt 5: Führen Sie die Shiny-App aus.
Klicken Sie auf App ausführen. Nach einem erfolgreichen Lauf sieht Ihre Shiny-App wie folgt aus. Jeder Fehler oder jede WarnungWenn es sich um eine App handelt, werden diese in der R-Konsole angezeigt.
Tab1 - Jahreszeit
Tab2 - Team gewinnt und punktet
Mal sehen, wieeinrichtenShinyapps.io-Konto zum Bereitstellen Ihrer Shiny-Apps.
Richten Sie ein Shinyapps.io-Konto ein
Gehe zu S.hinyapps.io Melden Sie sich mit Ihren Daten an, geben Sie einen eindeutigen Kontonamen für die Seite ein und speichern Sie ihn. Nach dem erfolgreichen Speichern wird ein detailliertes Verfahren zum Bereitstellen von Apps über die R-Konsole angezeigt. Gehen Sie wie folgt vor, um Ihr Konto in Rstudio zu konfigurieren.
Schritt 1. Installieren Sie rsconnect
install.packages ('rsconnect')
Schritt 2. Konto autorisieren
Das rsconnect Das Paket muss mithilfe eines Tokens und eines Geheimnisses für Ihr Konto autorisiert werden. Kopieren Sie dazu den gesamten Befehl wie unten auf Ihrer Dashboard-Seite in gezeigt R. Konsole. Nachdem Sie den Befehl in R erfolgreich eingegeben haben, ermächtige ich Sie nun, Anwendungen für Ihr Shinyapps.io-Konto bereitzustellen.
rsconnect :: setAccountInfo (name = 'kontoname', token = 'token', secret = 'secret')
Schritt 3. App bereitstellen
Verwenden Sie den folgenden Code, um Shiny-Apps bereitzustellen.
Bibliothek (rsconnect) rsconnect :: deployApp ('Pfad / zu / Ihrer / App')
Nach dem Einstellen können Sie Ihre glänzenden Apps bereitstellen.
Nachdem Sie gelernt haben, wie Sie Shiny-Apps erstellen und ausführen, stellen Sie die soeben erstellte App wie oben beschrieben in Shinyapps.io bereit oder klicken Sie auf veröffentlichen, Dies befindet sich in der oberen rechten Ecke des Shiny-App-Fensters.
Ich hoffeMit diesem R Shiny-Tutorial haben Sie gelernt, wie Sie eine Shiny-App erstellen und ausführen. Viel Spaß beim Erstellen interaktiver und schöner Web-Apps mit R Shiny.
Wenn Sie R-Programmierung lernen und eine farbenfrohe Karriere in Data Analytics aufbauen möchten, lesen Sie unsere Dies beinhaltet ein von Lehrern geführtes Live-Training und praktische Projekterfahrung. Diese Schulung hilft Ihnen, die Datenanalyse zu verstehen und das Thema zu beherrschen.