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
$<NA> # Für das dritte Element wurde kein Titel vergeben
[1] 3 4
# 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“