R Language
deelverzameling

Invoering

Opmerkingen

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

Atoomvectoren

Atoomvectoren (die lijsten en uitdrukkingen uitsluiten, die ook vectoren zijn) worden met behulp van de [ operator:

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

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

De operator [ kan ook een vector als argument gebruiken. Om bijvoorbeeld het eerste en derde element te selecteren:

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

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

Soms moeten we een bepaalde waarde uit de vector weglaten. Dit kan worden bereikt met een negatief teken ( - ) vóór de index van die waarde. Als u bijvoorbeeld wilt weglaten om de eerste waarde uit v1 weg te laten, gebruikt u v1[-1] . Dit kan eenvoudig worden uitgebreid tot meer dan één waarde. Bijvoorbeeld v1[-c(1,3)] .

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

In sommige gevallen willen we, met name wanneer de lengte van de vector groot is, een index van een bepaalde waarde, als deze bestaat:

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

Als de atomaire vector heeft namen (a names attribuut), kan het worden subsets met behulp van een karakter vector namen:

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

v
##  one   two three 
##    1     2     3 

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

De [[ operator kan ook worden gebruikt om atoomvectoren te indexeren, met verschillen dat het een indexerende vector met een lengte van één accepteert en alle aanwezige namen verwijdert:

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

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

Vectoren kunnen ook worden gesubset met behulp van een logische vector. In tegenstelling tot subsetting met numerieke en tekenvectoren, moet de logische vector die wordt gebruikt voor subset gelijk zijn aan de lengte van de vector waarvan de elementen worden geëxtraheerd, dus als een logische vector y wordt gebruikt om x , dwz x[y] , als length(y) < length(x) dan wordt y gerecycled om overeen te komen met 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)

lijsten

Een lijst kan worden onderverdeeld met [ :

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"

Merk op dat het resultaat van l1[2] nog steeds een lijst is, aangezien de [ operator elementen van een lijst selecteert en een kleinere lijst retourneert. De [[ operator haalt lijstelementen op, retourneert een object van het type van het lijstelement.

Elementen kunnen worden geïndexeerd op nummer of een tekenreeks van de naam (als deze bestaat). Meerdere elementen kunnen worden geselecteerd met [ door een vector van getallen of reeksen namen door te geven. Indexering met een vector van length > 1 in [ en [[ retourneert een "lijst" met de opgegeven elementen en een recursieve subset (indien beschikbaar), respectievelijk :

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

Vergeleken bij:

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

wat overeenkomt met:

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

Met de operator $ kunt u lijstelementen uitsluitend op naam selecteren, maar in tegenstelling tot [ en [[ , heeft u geen aanhalingstekens nodig. Als infix-operator kan $ maar één naam hebben:

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

De $ -operator staat ook standaard gedeeltelijke matching toe:

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

in tegenstelling tot [[ waar moet worden gespecificeerd of gedeeltelijke matching is toegestaan:

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

Instellingsopties options(warnPartialMatchDollar = TRUE) , een "waarschuwing" wordt gegeven wanneer gedeeltelijke matching plaatsvindt met $ :

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

matrices

Voor elke dimensie van een object accepteert de operator [ één argument. Vectoren hebben één dimensie en hebben één argument. Matrices en gegevensframes hebben twee dimensies en nemen twee argumenten, gegeven als [i, j] waarbij i de rij is en j de kolom is. Het indexeren begint bij 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] is het element in de i -de rij, j -de kolom van de matrix mat . Een i waarde van 2 en een j waarde van 1 geven bijvoorbeeld het nummer in de tweede rij en de eerste kolom van de matrix. Als u i of j weglaat, worden alle waarden in die dimensie geretourneerd.

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

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

Wanneer de matrix rij- of kolomnamen heeft (niet vereist), kunnen deze worden gebruikt voor subsetting:

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

Standaard wordt het resultaat van een subset indien mogelijk vereenvoudigd. Als de subset slechts één dimensie heeft, zoals in de bovenstaande voorbeelden, is het resultaat een eendimensionale vector in plaats van een tweedimensionale matrix. Deze standaard kan worden opgeheven met het argument drop = FALSE naar [ :

## 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"

Dimensies kunnen natuurlijk niet worden verwijderd als de selectie zelf twee dimensies heeft:

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

Afzonderlijke matrixinvoer selecteren op basis van hun positie

Het is ook mogelijk om een Nx2-matrix te gebruiken om N individuele elementen uit een matrix te selecteren (zoals hoe een coördinatensysteem werkt). Als u in een vector de ingangen van een matrix in de (1st row, 1st column), (1st row, 3rd column), (2nd row, 3rd column), (2nd row, 1st column) wilt extraheren, kan dit eenvoudig worden gedaan door een indexmatrix met die coördinaten te maken en die te gebruiken om de matrix te subset:

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 het bovenstaande voorbeeld verwijst de 1e kolom van de ind matrix naar rijen in mat , de 2e kolom van ind naar kolommen in mat .

Dataframes

Een subframe instellen in een kleiner dataframe kan op dezelfde manier worden bereikt als een subset.

> 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

Een dataframe in een kolomvector plaatsen kan worden bereikt met dubbele haakjes [[]] of de dollartekenoperator $.

> 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

Een subset van gegevens als een tweedimensionale matrix kan worden bereikt met behulp van de termen i en j .

> 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

Opmerking: Subsetting alleen door j (kolom) vereenvoudigt het eigen type van de variabele, maar subsetting door alleen i retourneert een data.frame , omdat de verschillende variabelen verschillende typen en klassen kunnen hebben. Door de drop parameter op FALSE blijft het gegevensframe behouden.

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

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

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

Andere objecten

De operatoren [ en [[ zijn primitieve functies die generiek zijn. Dit betekent dat elk object in R (specifiek isTRUE(is.object(x)) --ie heeft een expliciet "class" attribuut) zijn eigen gespecificeerde gedrag kan hebben wanneer het wordt gesubsetteerd; ie heeft zijn eigen methoden voor [ en / of [[ .

Dit is bijvoorbeeld het geval bij "data.frame" ( is.object(iris) ) -objecten waarbij de methoden [.data.frame en [[.data.frame zijn gedefinieerd en deze beide "matrix" -achtig worden weergegeven en "lijst" -achtige subsetting. Met het afdwingen van een fout bij het instellen van een "data.frame", zien we dat in feite een functie [.data.frame werd aangeroepen toen we - gewoon - gebruikten van [ .

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

Zonder verdere details over het huidige onderwerp, een voorbeeld [ 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

We kunnen de methode van verzending van [ overwinnen door de equivalente niet-generieke .subset (en .subset2 voor [[ ) te gebruiken. Dit is vooral handig en efficiënt bij het programmeren van onze eigen "klassen" en wilt omzeilen (zoals unclass(x) ) vermijden bij het efficiënt berekenen van onze "klassen" (verzending van methoden vermijden en objecten kopiëren):

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

Vector indexeren

Voor dit voorbeeld gebruiken we de vector:

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

R-vectoren zijn 1-geïndexeerd, dus bijvoorbeeld x[1] geeft 11 terug. We kunnen ook een subvector van x extraheren door een vector van indices door te geven aan de bracket-operator:

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

Als we een vector van negatieve indices passeren, retourneert R een subvector met de opgegeven indices uitgesloten:

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

We kunnen ook een booleaanse vector doorgeven aan de bracket-operator, in welk geval deze een subvector retourneert die overeenkomt met de coördinaten waar de indexerende vector TRUE :

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

Als de indexeringsvector korter is dan de lengte van de array, wordt deze herhaald, zoals in:

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

Elementwise Matrix-bewerkingen

Laat A en B twee matrices van dezelfde dimensie zijn. De operatoren + , - , / , * , ^ wanneer gebruikt met matrices van dezelfde dimensie, voeren de vereiste bewerkingen uit op de overeenkomstige elementen van de matrices en retourneren een nieuwe matrix van dezelfde dimensie. Deze bewerkingen worden meestal elementgewijze bewerkingen genoemd.

Gebruik "* echte" matrixvermenigvuldiging, zoals te zien in lineaire algebra , %*% . De vermenigvuldiging van A met B is bijvoorbeeld: A %*% B De dimensionale vereisten zijn dat de ncol() van A hetzelfde is als nrow() van B

Sommige functies gebruikt met Matrices