Zum Inhalt springen

R Programmierung: R-Befehle Sammlung

    [toc]

    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