Kommentar
# Ich bin ein Kommentar
Ausgabe
• print(“Hello World”) • cat(“Hello”, “World”)
Information über R-Befehle
# Informationen über einen bestimmten Befehlt z.B. ‘which’ ermitteln • apropos(“which”) • help(which) • ?which • RSiteSearch(“which”)
Befehl-Historie & Exit
# Zuvor eingegebene Befehle anzeigen history()
# RStudio Verlassen q()
Arbeitsverzeichnis
# Mein R Arbeitsverzeichnis anzeigen getwd()
# Arbeitsverzeichnis ändern
# Ein neues Arbeitsverzeichnis angeben
setwd(‘PFAD’)
R-Befehle/Script Speichern
# R-Befehle bzw. R-Scribt lokal speichern save (myTable, file=“C:/Users/axxKreis/Desktop/myTable.RData”)
R-Befehle/Script laden
# Persistierte Ergebnisse laden load (file=“C:/Users/axxKreis/Desktop/myTable.RData”)
CSV-Datei laden
# Eine Tabelle (CSV-Datei) laden myCsvTable <- read.table(file=“C:/[PFAD]/myCsvTable.csv”, header=TRUE, sep=";") oder myCsvTable <- read.csv(file=“C:/[PFAD]/myCsvTable.csv”, header=TRUE, sep=";")
Bibliotheken
Informationen über vorhandene Bibliothelen
# Gibt an, wo die Bibiotheken installiert sind .libPaths()
# Die installierten basis Pakete anzeigen lassen getOption(“defaultPackages”)
# Die Liste alle Pakete, die aktuell geladen wurden (.packages())
# Alle Pakete, die bereits installiert wurden und zur Verfügung stehen (.packages(all.available=TRUE)) oder library() # Für detaillierte Informationen oder installed.packages()
# Ort, an der sich die installierten Pakete bzw. libs befinden Sys.getenv(“R_LIBS_USER”)
Bibliothek laden
# Existierende Bibliothek z.B. rpart laden library(rpart)
Bibliothek installieren
install.packages(c(“tree”,“maptree”)) install.packages(“Name der Bibiothek”, dependencies=TRUE)
Öffentliche Liste von R Bibliotheken
https://cran.r-project.org/web/packages/available_packages_by_date.html
Installierte Pakete updaten
update.packages()
Bibliotheken beim Start von R-Studio laden
# Mit einem Texteditor im Admin-Modus die folgende Datei anpassen: C:\Program Files\R\R-3.2.4\etc\Rprofile.site # Innerhalb der Datei die gewünschten Bibliotheken eintragen library(DBI) library(FSelector) library(ggplot2) library(lattice) library(RODBC) library(RMySQL) library(lattice)
Datenbank Bibliotheken installieren und laden
RODBC entspricht ODBC DBI entspricht JDB RMySQL entspricht MySQL
# DB Packages installieren install.packages(“RODBC”) install.packages(“DBI”) install.packages(“RMySQL”) # MySQL
# Installiertes Paket laden library(RODBC) # Im Fehlerfall wird eine Meldung angezeigt. Ansonsten keine Ausgabe. library(DBI) library(RMySQL)
Bibliothek für Datenverarbeitung
install.packages(“FSelector”)
Bestimmung der Entropy für ’target value’
entropy (entropyTargetValue)
Information Gain
information.gain(data)
# ‘Information Gain’ für das Attribut ‘xxx’ in Bezug auf das ’target value’ bestimmen information.gain (head(data[c(“TARGET.VALUE”,“xxx”)],length(data$TARGET.VALUE)))
Bibliothek für Visiualisierungs
# Visualisierungspakete • lattice # Muss installiert und geladen werden • ggplot2
Datentypen
# Am meisten verwendeten Datentypen
- Vectors
- Logical
- Numeric
- Integer
- Complex (1+2x)
- Character
- Raw (Hexadezimal)
- Lists
- Matrices
- Arrays
- Factors
Variablen (Symbol)
Deklaration
a <- 1 oder a = 1
# Funktionale Schreibweise ‘<-’(a,1)
Alle Variablen anzeigen
ls()
# Alle Variablen, die zum Pattern passen anzeigen ls(pattern = “var”)
# Alle Variablen inkl. die versteckten Dateien anzeigen ls (all.names = TRUE)
Variable/n ‘a’ löschen
rm(a)
# Alle Variablen löschen rm(list = ls())
Variablen miteinander vergleichen
a = 1 b = 2 a==b # FALSE
Operatoren
Arithmetische Operatoren
- + * / %% %/% ^
Relationale Operatoren
> < == <= >= !=
Logische Operatoren
& | ! && ||
Zuweisungsoperatoren
<− (lokal) = «− (global) -> -»
Sonstige Operatoren
: %in% %*%
Bespiele
# Module (%%)
a = c(4, 8, 12) b = c(12, 8, 4) a%%b
Ergebnis: 4 0 0
# Wie oft passen die Werte aus Vektor ‘a’ in Vector ‘b’
a = c(4, 8, 12) b = c(12, 8, 4) a%/%b
Ergebnis: 0 1 3 # Vektor ‘a’ um die Zahlen in Vektor ‘b’ exponieren z.B. 2*2*2=8; 3*3=9; 4*4=16 a = c(2, 3, 4) b = c(3, 2, 2) a^b
Ergebnis: 8 9 16
# Kontrollieren, ob die Werte von Vektor ‘a’ größer sind als die von Vektor ‘b’ a = c(4, 8, 12) b = c(12, 8, 4) a>b
Ergebnis: FALSE FALSE TRUE # Gibt true aus, falls die Werte von Vaktor ‘a’ und ‘b’ TRUE sein sollten a = c(2, TRUE, 4) b = c(3, FALSE, 2) a&b
Ergebnis: TRUE FALSE TRUE
# Gibt TRUE aus, falls ein Wert eines Vektors TRUE sein sollte z.B. 0 und 0 = FALSE oder FALSE und FALSE = FALSE a = c(3,0,TRUE,FALSE, 0) b = c(4,0,FALSE,FALSE, 0.1) a|b
Ergebnis: TRUE FALSE TRUE FALSE TRUE
# Beinhaltet ein Vektor einen bestimmten Wert a = c(3,0,TRUE,FALSE, 0) 3%in%a
Ergebnis: TRUE String
String
# einfache Anführungsstriche werden intern in doppelte umgewandelt ‘hello’ “Hello”
Länger einer Zeichenkette ermitteln
nchar(a)
Substring
a=“abcdefg” substr(a,3,5)
Ergebnis: cde
String Verkettung
a <- “Hello” b <- ‘How’ c <- “are you?”
paste(a,b,c) “Hello How are you?”
paste(a,b,c, sep = “@”) “Hello@How@are you?”
paste(a,b,c, sep = “”, collapse = “”) “HelloHoware you? "
5 Stelligen String erzeugen
format(18, width = 5) [1] " 18”
Ausrichtung der Ausgabe
format(“Hello”, width = 8, justify = “centre”) #left, right, centre, none " Hello "
String groß und klein schreiben
x = “Hello” toupper(x) tolower(x)
Faktor
v = c(“thomas”, “thomas”, “thomas”, “linda”)
levels(v) NULL
typeof(v) [1] “character”
class(v) [1] “character”
# Faktor Umwandlung & kontrollieren
v = factor(v)
is.factor(v) TRUE
levels(v) “linda” “thomas”
typeof(v) “integer”
class(v) “factor”
# Innerhalb von ‘data frame’ werden Strings in Faktoren umgewandelt a <- c(“Thomas”, “Linda”, “Felix”, “Sam”) b <- c(34,19,18,56) myDataFrame <- data.frame(a,b) is.factor(a) is.factor(myDataFrame$a)
Ergebnis: FALSE TRUE
# Reihenfolge der Faktoren bestimmen a <- factor( c(“Thomas”, “Linda”, “Felix”, “Sam”, “Linda”)
Ergebnis: Levels: Felix Linda Sam Thomas
# Reihenfolge ändern a <- factor( a, levels = c(“Linda”, “Sam”, “Thomas”, “Felix”) )
Ergebnis: Levels: Linda Sam Thomas Felix # Faktor generieren - 4 gibt an, wie oft ein Faktor vorkommen soll und 2 gibt an, wieviele der Faktor vorkommen sollen - In diesem Beispiel soll “Linda” und “Sam” jeweils 4x vorkommen. a <- gl(2, 4, labels = c(“Linda”, “Sam”, “Thomas”, “Felix”))
Ergebnis: Linda Linda Linda Linda Sam Sam Sam Sam Levels: Linda Sam Thomas Felix Vektor
# Vektor erstellen myVector <- c(1,2,c(3,4),5)
Ergebnis: 1 2 3 4 5 # Wenn ein Vektor ein String beinhaltet, werden alle non-string Werte in Strings umgewandelt c(‘hello’,0,TRUE)
Ergebnis: “hello” “0” “TRUE”
# Vektor Index auslesen days <- c(“mo”, “di”, “mi”, “do”, “fr”, “sa”, “so”) days[c(1,3)]
Ergebnis: “mo” “mi”
# Jeden zweiten Wert ausgeben days <- c(“mo”, “di”, “mi”, “do”, “fr”, “sa”, “so”) days[c(TRUE,FALSE)]
Ergebnis: “mo” “mi” “fr” “so”
# Einzelne Index entfernen days <- c(“mo”, “di”, “mi”, “do”, “fr”, “sa”, “so”) days[c(-2,-3)]
Ergebnis: “mo” “do” “fr” “sa” “so”
# Index Reihenfolge bestimmen days <- c(“mo”, “di”, “mi”, “do”, “fr”, “sa”, “so”) days[c(1,7,6,5,4,3,2)]
Ergebnis: “mo” “so” “sa” “fr” “do” “mi” “di”
# Operatoren auf zwei Vektoren anwenden +, -, *, /
# Ungleiche Länge wird wie folgt gerechnet: 1*1, 2*2, 3*3, 4*1, 5*2, 6*3 a = c(1, 2, 3) b = c(1, 2, 3, 4, 5, 6) a*b
Ergebnis: 1 4 9 4 10 18
# Vektor Sortierung (numerisch und Strings) a = c(1, 4, 9, 4, 10, 18) sort(a)
# Reihenfolge der Sortierung ändern sort(a, decreasing = TRUE)
# Länge ermitteln length (myVector)
# Sortieren sort(myVector)
# Duplikate erkennen duplicated (myVector)
# Vektor mit ganzen Zahlen zwischen 1 und 50 1:50
# Dritte Stelle eines Vektors auslesen a[3]
# Erste bis dritte Stelle des Vektors auslesen a[1:3]
# Vectoren zusammenfügen bzw. Tabelle bauen first.name <- c(“Hannes”, “Julia”) last.name <- c(“Müller”, “Schmidt”) myTable <- data.frame(first.name, last.name)
oder
x <- c(“a”, “b”) y <- c(“A”, “B”) paste(x,y) # Ergebnis: “a A” “b B” “a C”
oder
rbin (x, y)
oder
cbind (x,y)
Liste
# Eine Liste erstellen und den name ‘meineListe’ geben meineListe <- list(1, 2, c(3,4))
Ergebnis: [[1]] [1] 1
[[2]] [1] 2
[[3]] [1] 3 4
# Listen bzw. Elemente der Liste betitteln names(meineListe) <- c(“Element1”, “Element2”) # die ersten beideb Listen betitteln
Ergebnis: $Element1 [1] 1
$Element2 [1] 2
$
# Die Namen der Listen explizit ausgeben names(meineListe)
# Zugriff auf die Listenelemente meineListe[1] oder meineListe$Element1
# Liste komplett überschreiben meineListe <- list(c(10, 20, 30), “Hello Liste”)
# Listenelement überschreiben meineListe[2] <- “Hello World!”
# Listen miteinander verknüpfen a = list(1,2,3) b = list(4,5,6) meineNeueListe = c(a,b)
# Liste in ein Vektor umwandeln unlist(meineNeueListe)
Ergebnis: [1] 1 2 3 4 5 6
Matrix
# Matrix erstellen (immer zweidimensional)
matrix( c(1,2,3,4,5,6), ncol = 3, nrow = 2, byrow = FALSE)
Ergebnis: [,1] [,2] [,3] [1,] 1 3 5 [2,] 2 4 6
oder
matrix( c(1,2,3,4,5,6), ncol = 3, nrow = 2, byrow = TRUE) Ergebnis: [,1] [,2] [,3] [1,] 1 2 3 [2,] 4 5 6
# Metrix mit vorgegbenem Zeilen- und Spaltenbezeichnung rownames = c(“row1”, “row2”, “row3”) colnames = c(“col1”, “col2”, “col3”, “col4”) myMatrix <- matrix(c(1:12), ncol = 4, nrow = 3, byrow = TRUE, dimnames = list(rownames, colnames))
Ergebnis: col1 col2 col3 col4 row1 1 2 3 4 row2 5 6 7 8 row3 9 10 11 12
# Die gesamte erste Zeile auslesen myMatrix[1,]
Ergebnis: col1 col2 col3 col4 1 2 3 4
# Die gesamte erste Spalte auslesen myMatrix[,1]
Ergebnis: row1 row2 row3 1 5 9
# Werte aus der ersten Zeile und der dritten Spalte auslesen. myMatrix[1,3]
# Matrix Addition (Weitere mathematische Operationen funktionieren auf die gleiche Weise) myMatrix1 [,1] [,2] [,3] [1,] 1 2 3 [2,] 4 5 6
myMatrix2 [,1] [,2] [,3] [1,] 1 2 3 [2,] 4 5 6
myMatrix1 + myMatrix2
Ergebnis: [,1] [,2] [,3] [1,] 2 4 6 [2,] 8 10 12
Array
# Array (n- bzw. mehrdimensinal) array(“a”, dim = c(3,4,2) )
Ergebnis: , , 1
[,1] [,2] [,3] [,4] [1,] “a” “a” “a” “a” [2,] “a” “a” “a” “a” [3,] “a” “a” “a” “a”
, , 2
[,1] [,2] [,3] [,4] [1,] “a” “a” “a” “a” [2,] “a” “a” “a” “a” [3,] “a” “a” “a” “a”
# Multidimensionaler Vektor a <- array(c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), dim=c(3, 4))
oder
a <- c(1,2,3,4) b <- c(5,6,7,8,9,10,11,12) rownames = c(“row1”, “row2”, “row3”) colnames = c(“col1”, “col2”, “col3”, “col4”) myArray <- array( c(a,b), dim = c(3,4,2), dimnames = list(rownames, colnames) )
Ergebnis: , , 1
col1 col2 col3 col4 row1 1 4 7 10 row2 2 5 8 11 row3 3 6 9 12
, , 2
col1 col2 col3 col4 row1 1 4 7 10 row2 2 5 8 11 row3 3 6 9 12
# Ausgabe: Zeile 1, Spalte 3 und Dimension 2 myArray[1,3,2]
Ergebnis: 7
# Ausgabe der gesamten zweiten Dimension: myArray[,,2]
# Array der zweiten Dimension überschreiben a <- c(13,14,15,16) b <- c(17,18,19,20,21,22,23,24) rownames = c(“row1”, “row2”, “row3”) colnames = c(“col1”, “col2”, “col3”, “col4”) myArray[,,2] <- array( c(a,b), dim = c(3,4), dimnames = list(rownames, colnames) )
# Matrix Berechnung vornehmen bzw. eine Funktion anwenden z.B. die Summe der Zeilen aller Dimensionen bilden d.h. die Summe der ersten Zeile der ersten Dimension + die Summe der ersten Zeile der zweiten Dimension usw. apply(myArray, c(1), sum) # Zeile = 1; Spalte = 2; Zeile & Spalte = c(1,2)
Ergebnis: row1 row2 row3 92 100 108
Data Frame
# Data Frame - Die Werte einer Spalte müssen vom gleichen Type und Länge sein myDataFrame <- data.frame ( name = c(“Thomas”, “Johan”, “Linda”), alter = c(34, 21, 49), geschlecht = c(“M”, “M”, “W”), stringsAsFactors = FALSE )
Ergebnis: name alter geschlecht 1 Thomas 34 M 2 Johan 21 M 3 Linda 49 W
# Die Struktur der data.frame anzeigen lassen str(myDataFrame)
Ergebnis: ‘data.frame’: 3 obs. of 3 variables: $ name : Factor w/ 3 levels “Johan”,“Linda”,..: 3 1 2 $ alter : num 34 21 49 $ geschlecht: Factor w/ 2 levels “M”,“W”: 1 1 2
# Spalten Werte auswerten summary(myDataFrame)
Ergebnis: name alter geschlecht Length:3 Min. :21.00 Length:3 Class :character 1st Qu.:27.50 Class :character Mode :character Median :34.00 Mode :character Mean :34.67 3rd Qu.:41.50 Max. :49.00
# Spalte auslesen data.frame(myDataFrame$name)
Ergebnis: myDataFrame.name 1 Thomas 2 Johan 3 Linda
# Die ersten beiden Spalten anzeigen lassen - index fängt bei 0 an myDataFrame[0:1,]
Ergebnis: name alter geschlecht 1 Thomas 34 M
# Spalte 1 & 3 auslesen - index fängt bei 1 an myDataFrame[c(1,3)]
Ergebnis: name geschlecht 1 Thomas M 2 Johan M 3 Linda W
# Neue Spalte hinzufügen myDataFrame$SpaltenBezeichnung <- c(“Wert1”,“Wert2”,“Wert3”)
Ergebnis: name alter geschlecht SpaltenBezeichnung 1 Thomas 34 M Wert1 2 Johan 21 M Wert2 3 Linda 49 W Wert3
# Neue Zeile hinzufügen newDataFrameRows <- data.frame ( name = c(“Igor”, “Andreas”, “Sascha”), alter = c(19, 25, 34), geschlecht = c(“M”, “M”, “W”), SpaltenBezeichnung = c(“new1”,“new2”,“new3”), stringsAsFactors = FALSE )
rbind(myDataFrame,newDataFrameRows)
Ergebnis: name alter geschlecht SpaltenBezeichnung 1 Thomas 34 M Wert1 2 Johan 21 M Wert2 3 Linda 49 W Wert3 4 Igor 19 M new1 5 Andreas 25 M new2 6 Sascha 34 W new3
Tabelle
# GUI aufrufen, um die zuvor erstelle Tabelle zu bearbeiten myTable <- edit (myTable) oder fix (myTable) # Hier wird der veränderte Wert zum ursprünglichen Symbol (myTable) hinzugefügt
# Anzahl Zeilen und Spalten einer Tabelle anzeigen dim(tableName)
# Die Namen der Spalten auflisten colnames(tablName)
# Tabelle auf gewünschte Spalten reduzieren Eingabe: train[,c(‘age’,’name’)]
Bedingung (if/else)
# if / else x <- 1 if (1 > 2) “yes” else “no”
# Ausdrücke mit Semikolon (;)hintereinander schreiben “hello”; 1+1; 1*3
Loop
i = 5 repeat {if (i > 25) break else {print(i); i <- i + 5;}} oder while (i <= 25) {print(i); i <- i + 5} oder for (i in seq(from=0, to=100, by=5)) print(i)
oder
seq(0, 100, by = 5)
Ergebnis: 0 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 Datenbank Verbindungsaufbau und Query Abfrage
Funktionen
# Unterschiedliche Schreibweisen und Funktionsparameter log2(64) log(x=64,base=2) log(64,2)
# funktion mit Funktion-Argumenten erstellen x <- function(i) i^2 x(2) # Ergebnis: 4
# Eigene Funktion schreiben nameDerFunktion <- function(Übergabeparameter) { print(Übergabeparameter) }
# Funktionsaufruf nameDerFunktion(Übergabeparameter)
# Funktion mit mehreren Parameter sayHelloWorld <- function(s,h) { cat(s, “”, h) } sayHelloWorld(s=“Hello”, h=“World”) oder sayHelloWorld(“Hello”, “World”)
# Funktion mit vorgegebenen Werten sayHelloWorld <- function(s=“H”,h=“W”) { cat(s, “”, h) } sayHelloWorld() # Für die Ausgabe der vorgegebenen Werten sayHelloWorld(“Hello”, “World”) # Um die vorgegebenen Werte zu überschreiben
Mathematische Funktionen
# Anzahl der Nachkommastellen festlegen. Maximal sind 17 Stellige Zahlen z.B. eine Zahl und 16 Nachkommastellen erlaubt. Default = 6 Nachkommastellen bzw. 7 Stellige Zahlen options(digits=17) # Runden z.B. Wurzel 99 round( sqrt(99) ) oder round(x=sqrt(99), digits=2) # Angabe der Nachkommastellen oder round(sqrt(99), 2)
# Durchschnittswert Berechnen x = c(1,2,3) # (1+2+3)/3 mean(x) # 2
# Median bzw. Zentralwert Berechnung x = c(1, 2, 4, 99) median(x) # 3
# Minimalwert und Maximalwert min(x) max x) oder range(x) # 1 99
# Maximaler Wert minus minimaler Wert diff( range(x) ) # Zufällige Daten erzeugen sample(1:1000, 10, replace = FALSE, prob = NULL)
# 10x die Zahl 0 erzeugen a <- rep(0, 10)
# Formatierung der Ausgabe format(20.0, nsmall = 10) # die Nachkommastelle um 10 Stellen auffüllen
Ergebnis: “20.0000000000”
# Reduzierung der Nachkommastellen format(20.123456789, digits = 4)
Ergebnis: 20.12
# Wissenschaftliche Schreibweise format(20.0000000000, scientific = TRUE)
Ergebnis: 2e+01 # # Eingab in String formatieren format(100)
Ergebnis: “100”