R Language
Subsetting

Einführung

Bemerkungen

x <- 1:3
x[NA]
## [1] NA NA NA

x[as.integer(NA)]
## [1] NA

x[c(NA, 1, NA, NA)]
## [1] NA  1 NA NA

(1:3)[10]
## [1] NA
(1:3)[[10]]
## Error in (1:3)[[10]] : subscript out of bounds
as.matrix(1:3)[10]
## [1] NA
as.matrix(1:3)[, 10]
## Error in as.matrix(1:3)[, 10] : subscript out of bounds
list(1, 2, 3)[10]
## [[1]]
## NULL
list(1, 2, 3)[[10]]
## Error in list(1, 2, 3)[[10]] : subscript out of bounds

c(a = 1, b = 2)["c"]
## <NA> 
##   NA 
list(a = 1, b = 2)["c"]
## <NA>
## NULL

Atomare Vektoren

Atomare Vektoren (die Listen und Ausdrücke, die ebenfalls Vektoren sind, ausschließen) werden mit dem Operator [ subset:

# create an example vector
v1 <- c("a", "b", "c", "d")

# select the third element
v1[3]
## [1] "c"

Der Operator [ kann auch einen Vektor als Argument verwenden. So wählen Sie beispielsweise das erste und das dritte Element aus:

v1 <- c("a", "b", "c", "d")

v1[c(1, 3)]
## [1] "a" "c"

Manchmal müssen wir einen bestimmten Wert aus dem Vektor auslassen. Dies kann durch ein negatives Vorzeichen ( - ) vor dem Index dieses Wertes erreicht werden. Wenn Sie beispielsweise den ersten Wert in v1 nicht v1[-1] möchten, verwenden Sie v1[-1] . Dieser kann auf einfache Weise auf mehrere Werte erweitert werden. Zum Beispiel v1[-c(1,3)] .

> v1[-1]
[1] "b" "c" "d"
> v1[-c(1,3)]
[1] "b" "d"

In manchen Fällen möchten wir insbesondere, wenn die Länge des Vektors groß ist, den Index eines bestimmten Werts wissen, falls vorhanden:

> v1=="c"
[1] FALSE FALSE  TRUE FALSE
> which(v1=="c")
[1] 3

Wenn das Atomvektornamen (a hat names Attribut), kann es ein Zeichen Vektor Namen Subset werden:

v <- 1:3
names(v) <- c("one", "two", "three")

v
##  one   two three 
##    1     2     3 

v["two"]
## two 
##   2

Der Operator [[ kann auch zum Indizieren atomarer Vektoren verwendet werden, mit dem Unterschied, dass er einen Indizierungsvektor mit einer Länge von 1 akzeptiert und vorhandene Namen entfernt:

v[[c(1, 2)]]
## Error in v[[c(1, 2)]] : 
##  attempt to select more than one element in vectorIndex

v[["two"]]
## [1] 2

Vektoren können auch mit einem logischen Vektor untergeordnet werden. Im Gegensatz zum Subsetting mit numerischen und Zeichenvektoren muss der für die Teilmenge verwendete logische Vektor der Länge des Vektors entsprechen, dessen Elemente extrahiert werden. Wenn also ein logischer Vektor y für die Teilmenge x , dh x[y] , falls length(y) < length(x) dann wird y wiederverwendet, um der length(x) :

v[c(TRUE, FALSE, TRUE)]
##  one three 
##    1     3 

v[c(FALSE, TRUE)]  # recycled to 'c(FALSE, TRUE, FALSE)'
## two 
##   2 

v[TRUE]   # recycled to 'c(TRUE, TRUE, TRUE)'
##  one   two three 
##    1     2     3 

v[FALSE]   # handy to discard elements but save the vector's type and basic structure
## named integer(0)

Listen

Eine Liste kann mit [ :

l1 <- list(c(1, 2, 3), 'two' = c("a", "b", "c"), list(10, 20))
l1
## [[1]]
## [1] 1 2 3
## 
## $two
## [1] "a" "b" "c"
##
## [[3]]
## [[3]][[1]]
## [1] 10
##
## [[3]][[2]]
## [1] 20

l1[1]
## [[1]]
## [1] 1 2 3

l1['two']
## $two
## [1] "a" "b" "c"

l1[[2]]
## [1] "a" "b" "c"

l1[['two']]
## [1] "a" "b" "c"

Beachten Sie, dass das Ergebnis von l1[2] immer noch eine Liste ist, da der Operator [ Elemente einer Liste auswählt und eine kleinere Liste zurückgibt. Der Operator [[ extrahiert Listenelemente und gibt ein Objekt vom Typ des Listenelements zurück.

Elemente können nach Nummer oder einer Zeichenfolge des Namens (falls vorhanden) indiziert werden. Mit [ können mehrere Elemente ausgewählt werden, indem ein Vektor mit Zahlen oder Namensfolgen übergeben wird. Indizierung mit einem Vektor der length > 1 in [ und [[ gibt eine "Liste" mit den angegebenen Elementen bzw. einer rekursiven Teilmenge (falls verfügbar) zurück :

l1[c(3, 1)]
## [[1]]
## [[1]][[1]]
## [1] 10
## 
## [[1]][[2]]
## [1] 20
## 
## 
## [[2]]
## [1] 1 2 3

Verglichen mit:

l1[[c(3, 1)]]
## [1] 10

was äquivalent ist zu:

l1[[3]][[1]]
## [1] 10

Mit dem Operator $ können Sie Listenelemente nur nach Namen auswählen. Anders als bei [ und [[ sind keine Anführungszeichen erforderlich. Als Infix-Operator kann $ nur einen einzigen Namen annehmen:

l1$two
## [1] "a" "b" "c"

Außerdem erlaubt der Operator $ standardmäßig die teilweise Übereinstimmung:

l1$t
## [1] "a" "b" "c"

Im Gegensatz zu [[ muss angegeben werden, ob ein partieller Abgleich zulässig ist:

l1[["t"]]
## NULL
l1[["t", exact = FALSE]]
## [1] "a" "b" "c"

Einstellungsoptionen options(warnPartialMatchDollar = TRUE) , eine Warnung wird ausgegeben, wenn ein teilweiser Abgleich mit $ :

l1$t
## [1] "a" "b" "c"
## Warning message:
## In l1$t : partial match of 't' to 'two'

Matrizen

Für jede Dimension eines Objekts [ Operator [ ein Argument. Vektoren haben eine Dimension und ein Argument. Matrizen und Datenrahmen haben zwei Dimensionen und nehmen zwei Argumente an, gegeben als [i, j] wobei i die Zeile und j die Spalte ist. Die Indizierung beginnt bei 1.

## a sample matrix
mat <- matrix(1:6, nrow = 2, dimnames = list(c("row1", "row2"), c("col1", "col2", "col3")))

mat
#      col1 col2 col3
# row1    1    3    5
# row2    2    4    6

mat[i,j] ist das Element in der i - ten Reihe, j - ten Spalte der Matrix - mat . Ein i Wert von 2 und ein j Wert von 1 geben beispielsweise die Anzahl in der zweiten Zeile und der ersten Spalte der Matrix an. Das Auslassen von i oder j gibt alle Werte in dieser Dimension zurück.

mat[ , 3]
## row1 row2 
##    5    6 

mat[1, ]
# col1 col2 col3 
#    1    3    5 

Wenn die Matrix Zeilen- oder Spaltennamen hat (nicht erforderlich), können diese zum Subsetting verwendet werden:

mat[ , 'col1']
# row1 row2 
#    1    2 

Standardmäßig wird das Ergebnis einer Teilmenge wenn möglich vereinfacht. Wenn die Teilmenge wie in den obigen Beispielen nur eine Dimension hat, ist das Ergebnis ein eindimensionaler Vektor und keine zweidimensionale Matrix. Dieser Standardwert kann mit dem Argument drop = FALSE auf [ :] überschrieben werden.

## This selects the first row as a vector
class(mat[1, ])
# [1] "integer"

## Whereas this selects the first row as a 1x3 matrix:
class(mat[1, , drop = F])
# [1] "matrix"

Dimensionen können natürlich nicht gelöscht werden, wenn die Auswahl selbst zwei Dimensionen hat:

mat[1:2, 2:3]  ## A 2x2 matrix
#      col2 col3
# row1    3    5
# row2    4    6

Auswahl einzelner Matrixeinträge anhand ihrer Positionen

Es ist auch möglich, eine Nx2-Matrix zu verwenden, um N einzelne Elemente aus einer Matrix auszuwählen (wie ein Koordinatensystem funktioniert). Wenn Sie in einem Vektor die Einträge einer Matrix in (1st row, 1st column), (1st row, 3rd column), (2nd row, 3rd column), (2nd row, 1st column) extrahieren möchten, können Sie dies tun Sie können dies leicht tun, indem Sie eine Indexmatrix mit diesen Koordinaten erstellen und diese zum Untersetzen der Matrix verwenden:

mat
#      col1 col2 col3
# row1    1    3    5
# row2    2    4    6

ind = rbind(c(1, 1), c(1, 3), c(2, 3), c(2, 1))
ind
#      [,1] [,2]
# [1,]    1    1
# [2,]    1    3
# [3,]    2    3
# [4,]    2    1

mat[ind]
# [1] 1 5 6 2

In dem obigen Beispiel bezieht sich die 1. Spalte der ind Matrix auf Zeilen in mat , die 2. Spalte von ind auf Spalten in mat .

Datenrahmen

Das Unterteilen eines Datenrahmens in einen kleineren Datenrahmen kann auf dieselbe Weise erfolgen wie das Unterteilen einer Liste.

> df3 <- data.frame(x = 1:3, y = c("a", "b", "c"), stringsAsFactors = FALSE)

> df3
##   x y
## 1 1 a
## 2 2 b
## 3 3 c

> df3[1]   # Subset a variable by number
##   x
## 1 1
## 2 2
## 3 3

> df3["x"]   # Subset a variable by name 
##   x
## 1 1
## 2 2
## 3 3

> is.data.frame(df3[1])
## TRUE

> is.list(df3[1])
## TRUE

Das Unterteilen eines Datenrahmens in einen Spaltenvektor kann mit doppelten Klammern [[]] oder dem Dollarzeichenoperator $ durchgeführt werden.

> df3[[2]]    # Subset a variable by number using [[ ]]
## [1] "a" "b" "c"

> df3[["y"]]  # Subset a variable by name using [[ ]]
## [1] "a" "b" "c"

> df3$x    # Subset a variable by name using $
## [1] 1 2 3

> typeof(df3$x)
## "integer"

> is.vector(df3$x)
## TRUE

Das Unterteilen von Daten als zweidimensionale Matrix kann unter Verwendung von i und j Ausdrücken erreicht werden.

> df3[1, 2]    # Subset row and column by number
## [1] "a"

> df3[1, "y"]  # Subset row by number and column by name
## [1] "a"

> df3[2, ]     # Subset entire row by number  
##   x y
## 2 2 b

> df3[ , 1]    # Subset all first variables 
## [1] 1 2 3

> df3[ , 1, drop = FALSE]
##   x
## 1 1
## 2 2
## 3 3

Anmerkung: Das Subsetting by j (column) vereinfacht sich allein auf den eigenen Typ der Variablen, aber das Subetting by i allein gibt einen data.frame , da die verschiedenen Variablen unterschiedliche Typen und Klassen haben können. Wenn Sie den drop Parameter auf FALSE bleibt der Datenrahmen erhalten.

> is.vector(df3[, 2])
## TRUE

> is.data.frame(df3[2, ])
## TRUE

> is.data.frame(df3[, 2, drop = FALSE])
## TRUE

Andere Objekte

Die Operatoren [ und [[ sind generische Funktionen. Dies bedeutet, dass jedes Objekt in R (insbesondere isTRUE(is.object(x)) - es hat ein explizites "class" -Attribut) sein eigenes Verhalten haben kann, wenn es subsettiert wird. dh hat eigene Methoden für [ und / oder [[ .

Dies ist zum Beispiel der Fall bei "data.frame" ( is.object(iris) ) Objekten, bei [[.data.frame Methoden [.data.frame und [[.data.frame definiert sind und beide "Matrix" -ähnlich sind und "list" -ähnliches Subsetting. Mit einem Fehler zu zwingen , wenn ein „data.frame“ subsetting, sehen wir , dass, tatsächlich, eine Funktion [.data.frame genannt wurde , als wir früher -just- [ .

iris[invalidArgument, ]
## Error in `[.data.frame`(iris, invalidArgument, ) : 
##   object 'invalidArgument' not found

Ohne weitere Details zum aktuellen Thema, ein Beispiel [ Methode:

x = structure(1:5, class = "myClass")
x[c(3, 2, 4)]
## [1] 3 2 4
'[.myClass' = function(x, i) cat(sprintf("We'd expect '%s[%s]' to be returned but this a custom `[` method and should have a `?[.myClass` help page for its behaviour\n", deparse(substitute(x)), deparse(substitute(i))))

x[c(3, 2, 4)]
## We'd expect 'x[c(3, 2, 4)]' to be returned but this a custom `[` method and should have a `?[.myClass` help page for its behaviour
## NULL

Das Methoden-Dispatching von [ kann überwunden werden, indem der äquivalente, nicht-generische .subset (und .subset2 für [[ )) verwendet wird. Dies ist besonders nützlich und effizient, wenn Sie unsere eigenen "Klassen" programmieren und unclass(x) (wie unclass(x) ) vermeiden möchten, wenn Sie auf unseren "Klassen" effizient berechnen (Methodenversand und Kopieren von Objekten vermeiden):

.subset(x, c(3, 2, 4))
## [1] 3 2 4

Vektor-Indizierung

In diesem Beispiel verwenden wir den Vektor:

> x <- 11:20
> x
 [1] 11 12 13 14 15 16 17 18 19 20

R-Vektoren sind 1-indiziert, so dass zum Beispiel x[1] 11 . Wir können auch einen Untervektor von x extrahieren, indem Sie einen Indexvektor an den Klammeroperator übergeben:

> x[c(2,4,6)]
[1] 12 14 16

Wenn wir einen Vektor negativer Indizes übergeben, gibt R einen Untervektor mit den angegebenen Indizes zurück:

> x[c(-1,-3)]
[1] 12 14 15 16 17 18 19 20

Wir können auch einen booleschen Vektor an den Klammeroperator übergeben. In diesem Fall gibt er einen Untervektor zurück, der den Koordinaten entspricht, bei denen der Indexierungsvektor TRUE :

> x[c(rep(TRUE,5),rep(FALSE,5))]
[1] 11 12 13 14 15 16

Ist der Indexierungsvektor kürzer als die Länge des Arrays, wird er wie folgt wiederholt:

> x[c(TRUE,FALSE)]
[1] 11 13 15 17 19
> x[c(TRUE,FALSE,FALSE)]
[1] 11 14 17 20

Elementweise Matrixoperationen

Sei A und B zwei Matrizen gleicher Dimension. Die Operatoren + , - , / , * , ^ wenn sie mit Matrizen derselben Dimension verwendet werden, die erforderlichen Operationen für die entsprechenden Elemente der Matrizen aus und geben eine neue Matrix derselben Dimension zurück. Diese Operationen werden normalerweise als elementweise Operationen bezeichnet.

Verwenden Sie für "echte" Matrixmultiplikationen, wie in der linearen Algebra zu sehen , %*% . Die Multiplikation von A mit B ist beispielsweise: A %*% B Die ncol() bestehen darin, dass ncol() von A mit nrow() von B nrow()

Einige Funktionen, die mit Matrizen verwendet werden