R Programmierung: R-Befehle Sammlung

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“

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.