R Language
Variablen

Variablen, Datenstrukturen und grundlegende Operationen

In R werden Datenobjekte mit Hilfe benannter Datenstrukturen bearbeitet. Die Namen der Objekte können als "Variablen" bezeichnet werden, obwohl dieser Begriff in der offiziellen R-Dokumentation keine spezielle Bedeutung hat. Bei R-Namen wird zwischen Groß- und Kleinschreibung unterschieden. Sie können alphanumerische Zeichen ( az , Az , 0-9 ), den Punkt / Punkt ( . ) Und den Unterstrich ( _ ) enthalten. Um Namen für die Datenstrukturen zu erstellen, müssen wir die folgenden Regeln beachten:

• Namen, die mit einer Ziffer oder einem Unterstrich beginnen (z. B. 1a ), oder Namen, die gültige numerische Ausdrücke sind (z. B. .11 ), oder Namen mit Bindestrichen ('-') oder Leerzeichen können nur verwendet werden, wenn sie in Anführungszeichen gesetzt sind: `1a` und `.11` . Die Namen werden mit Backticks gedruckt:

   list( '.11' ="a")
   #$`.11`
   #[1] "a"
  

• Alle anderen Kombinationen von alphanumerischen Zeichen, Punkten und Unterstrichen können frei verwendet werden, wobei die Referenz mit oder ohne Backticks auf dasselbe Objekt verweist.

• Namen , die mit beginnen . werden als Systemnamen betrachtet und sind mit der ls() -Funktion nicht immer sichtbar.

Die Anzahl der Zeichen in einem Variablennamen ist nicht beschränkt.

Beispiele für gültige Objektnamen sind: foobar , foo.bar , foo_bar , .foobar

In R werden Variablen Werte mit dem Infix-Zuweisungsoperator <- zugewiesen. Der Operator = kann auch zum Zuweisen von Werten zu Variablen verwendet werden. Die richtige Verwendung ist jedoch die Zuordnung von Werten zu Parameternamen in Funktionsaufrufen. Beachten Sie, dass das Auslassen von Leerzeichen um Operatoren zu Verwirrung für Benutzer führen kann. Der Ausdruck a<-1 wird als Zuordnung (analysiert a <- 1 ) und nicht als logischen Vergleich ( a < -1 ).

> foo <- 42
> fooEquals = 43

foo erhält also den Wert 42 . foo in der Konsole foo fooEquals wird 42 ausgegeben, während Sie fooEquals wird 43 ausgegeben.

> foo
[1] 42
> fooEquals
[1] 43

Der folgende Befehl weist der Variablen x einen Wert zu und gibt den Wert gleichzeitig aus:

> (x <- 5) 
[1] 5
# actually two function calls: first one to `<-`; second one to the `()`-function
> is.function(`(`)
[1] TRUE  # Often used in R help page examples for its side-effect of printing.

Zuweisungen an Variablen können auch mit -> .

> 5 -> x
> x
[1] 5
> 

Arten von Datenstrukturen

Es gibt keine skalaren Datentypen in R. Vektoren der Länge Eins verhalten sich wie Skalare.

• Vektoren: Atomare Vektoren müssen eine Folge von Objekten derselben Klasse sein: eine Folge von Zahlen oder eine Folge von logischen Zeichen oder eine Folge von Zeichen. v <- c(2, 3, 7, 10) , v2 <- c("a", "b", "c") sind beide Vektoren.
• Matrizen: Eine Matrix aus Zahlen, logischen Zeichen oder Zeichen. a <- matrix(data = c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), nrow = 4, ncol = 3, byrow = F) . Wie Vektoren muss die Matrix aus Elementen derselben Klasse bestehen. Um Elemente aus Matrixzeilen und -spalten zu extrahieren, müssen Sie Folgendes angeben: a[1,2] gibt [1] 5 , dh das Element in der ersten Zeile, zweiten Spalte.
• Listen: Verkettung verschiedener Elemente mylist <- list (course = 'stat', date = '04/07/2009', num_isc = 7, num_cons = 6, num_mat = as.character(c(45020, 45679, 46789, 43126, 42345, 47568, 45674)), results = c(30, 19, 29, NA, 25, 26 ,27) ) . Das Extrahieren von Elementen aus einer Liste kann nach Name (wenn die Liste benannt ist) oder nach Index erfolgen. In diesem Beispiel erhalten mylist$results und mylist[[6]] dasselbe Element. Warnung: Wenn Sie mylist[6] versuchen, gibt R mylist[6] Fehler aus, sondern extrahiert das Ergebnis als Liste. Während mylist[[6]][2] erlaubt ist (es gibt 19), gibt mylist[6][2] einen Fehler.
• Datenrahmen: Objekt mit Spalten, die Vektoren gleicher Länge, jedoch (möglicherweise) verschiedener Typen sind. Sie sind keine Matrizen. exam <- data.frame(matr = as.character(c(45020, 45679, 46789, 43126, 42345, 47568, 45674)), res_S = c(30, 19, 29, NA, 25, 26, 27), res_O = c(3, 3, 1, NA, 3, 2, NA), res_TOT = c(30,22,30,NA,28,28,27)) . Die Spalten können nach Name exam$matr , exam$matr , exam[, 'matr'] oder nach exam[1] , exam[,1] gelesen werden. Zeilen können auch nach Namenstest exam['rowname', ] oder exam['rowname', ] exam[1,] gelesen werden. Dataframes sind eigentlich nur Listen mit einer bestimmten Struktur (Rownames-Attribut und Komponenten gleicher Länge).

Gemeinsame Operationen und einige Warnhinweise

Standardvorgänge werden Element für Element ausgeführt. Siehe ?Syntax für die Regeln der Operatorvorrangigkeit. Die meisten Operatoren (und andere Funktionen in der Basis-R) verfügen über Recyclingregeln, die Argumente unterschiedlicher Länge zulassen. Angesichts dieser Objekte:

Beispielobjekte

> a <- 1
> b <- 2
> c <- c(2,3,4)
> d <- c(10,10,10)
> e <- c(1,2,3,4)
> f <- 1:6
> W <- cbind(1:4,5:8,9:12)
> Z <- rbind(rep(0,3),1:3,rep(10,3),c(4,7,1))

Einige Vektoroperationen

> a+b # scalar + scalar
[1] 3
> c+d # vector + vector
[1] 12 13 14
> a*b # scalar * scalar 
[1] 2
> c*d # vector * vector (componentwise!)
[1] 20 30 40
> c+a # vector + scalar
[1] 3 4 5
> c^2 # 
[1]  4  9 16
> exp(c) 
[1]  7.389056 20.085537 54.598150

Einige Vektoroperationen Warnungen!

> c+e # warning but.. no errors, since recycling is assumed to be desired.
[1] 3 5 7 6
Warning message:
In c + e : longer object length is not a multiple of shorter object length

R summiert, was es kann, und verwendet dann den kürzeren Vektor erneut, um die Lücken auszufüllen ... Die Warnung wurde nur ausgegeben, weil die beiden Vektoren Längen haben, die nicht genau Vielfache sind. c + f # keine Warnung.

Einige Matrixoperationen Warnung!

> Z+W # matrix + matrix #(componentwise)
> Z*W # matrix* matrix#(Standard product is always componentwise)

Um eine Matrix zu verwenden, multiplizieren Sie: V% *% W

> W + a # matrix+ scalar is still componentwise
     [,1] [,2] [,3]
[1,]    2    6   10
[2,]    3    7   11
[3,]    4    8   12
[4,]    5    9   13

> W + c # matrix + vector... : no warnings and R does the operation in a column-wise manner
     [,1] [,2] [,3]
[1,]    3    8   13
[2,]    5   10   12
[3,]    7    9   14
[4,]    6   11   16

"Private" Variablen

Ein führender Punkt in einem Namen einer Variablen oder Funktion in R wird im Allgemeinen verwendet, um anzuzeigen, dass die Variable oder Funktion verborgen sein soll.

So deklarieren Sie die folgenden Variablen

> foo <- 'foo'
> .foo <- 'bar'

Wenn Sie dann mit der ls Funktion Objekte ls , wird nur das erste Objekt angezeigt.

> ls()
[1] "foo"

all.names = TRUE Sie jedoch all.names = TRUE an die Funktion übergeben, wird die private Variable all.names = TRUE

> ls(all.names = TRUE)
[1] ".foo"          "foo"