R Language
Delin

Introduktion

Anmärkningar

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

Atomvektorer

Atomvektorer (som utesluter listor och uttryck, som också är vektorer) delmängd med [ operatören:

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

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

[ Operatören kan också ta en vektor som argument. Till exempel för att välja det första och det tredje elementet:

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

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

Vissa gånger kan vi behöva utelämna ett visst värde från vektorn. Detta kan uppnås med ett negativt tecken ( - ) före indexet för det värdet. Till exempel, för att utelämna att utelämna det första värdet från v1, använd v1[-1] . Detta kan utvidgas till mer än ett värde på ett rakt framåt sätt. Till exempel v1[-c(1,3)] .

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

Vid vissa tillfällen vill vi veta, särskilt när vektorns längd är stor, index för ett visst värde, om det finns:

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

Om atom vektorn har namn (ett names attribut), kan den delmängd med hjälp av en karaktär vektor namn:

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

v
##  one   two three 
##    1     2     3 

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

[[ Operatören kan också användas för att indexera atomvektorer, med skillnader i att den accepterar en indexeringsvektor med en längd på en och ränder alla närvarande namn:

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

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

Vektorer kan också delmängdas med en logisk vektor. I motsats till underinställning med numeriska och teckenvektorer, måste den logiska vektorn som används för att delmängden vara lika med längden på vektorn vars element extraheras, så om en logisk vektor y används för att delmängden x , dvs. x[y] , om length(y) < length(x) sedan återvinns y till matchningslängd 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)

listor

En lista kan delas med [ :

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"

Observera att resultatet av l1[2] fortfarande är en lista, eftersom [ operatören väljer element i en lista och returnerar en mindre lista. [[ Operatören extraherar listelement och returnerar ett objekt av listelementets typ.

Element kan indexeras efter nummer eller en teckensträng med namnet (om det finns). Flera element kan väljas med [ genom att passera en vektor med siffror eller namnsträngar. Indexering med en längdvektor length > 1 i [ och [[ returnerar en "lista" med de angivna elementen och en rekursiv underuppsättning (om tillgänglig), respektive :

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

Jämfört med:

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

vilket motsvarar:

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

Operatören $ låter dig välja listelement enbart med namn, men till skillnad från [ och [[ , kräver inte offert [[ . Som infixoperatör kan $ bara ta ett enda namn:

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

Dessutom tillåter operatören $ delvis matchning som standard:

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

i motsats till [[ där det måste specificeras om partiell matchning är tillåten:

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

Inställningsalternativ options(warnPartialMatchDollar = TRUE) , en "varning" ges när partiell matchning sker med $ :

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

matriser

För varje dimension av ett objekt tar [ operatören ett argument. Vektorer har en dimension och tar ett argument. Matriser och dataramar har två dimensioner och tar två argument, angivna som [i, j] där i är raden och j är kolumnen. Indexering börjar 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] är elementet i den i rad, j kolumnen i mat . Till exempel ger ett i värde på 2 och ett j värde på 1 numret i den andra raden och den första kolumnen i matrisen. Om du utelämnar i eller j returneras alla värden i den dimensionen.

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

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

När matrisen har rad- eller kolumnnamn (krävs inte), kan dessa användas för att ställa in:

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

Som standard förenklas resultatet av en delmängd om möjligt. Om delmängden bara har en dimension, som i exemplen ovan, kommer resultatet att vara en endimensionell vektor snarare än en tvådimensionell matris. Detta standard kan åsidosättas med drop = FALSE argumentet till [ :

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

Naturligtvis kan dimensioner inte släppas om själva markeringen har två dimensioner:

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

Välja enskilda matrisposter efter sina positioner

Det är också möjligt att använda en Nx2-matris för att välja N enskilda element från en matris (som hur ett koordinatsystem fungerar). Om du ville extrahera, i en vektor, inmatningarna i en matris i (1st row, 1st column), (1st row, 3rd column), (2nd row, 3rd column), (2nd row, 1st column) detta görs enkelt genom att skapa en indexmatris med de koordinaterna och använda den för att dela matrisen:

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

I exemplet ovan avser den första kolumnen i ind rader i mat , den andra kolumnen med ind hänvisar till kolumner i mat .

Dataramar

Att dela in en dataram i en mindre dataram kan åstadkommas på samma sätt som att lägga till en lista.

> 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

Att dela in ett dataframe i en kolumnvektor kan utföras med dubbla parenteser [[]] eller dollarteckenoperatören $.

> 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

Att dela in en data som en tvådimensionell matris kan åstadkommas med hjälp av i och j termer.

> 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

Obs! Om du bara använder j (kolumn) förenklas variabelns egen typ, men att dela med i enbart ger en data.frame , eftersom de olika variablerna kan ha olika typer och klasser. Inställning av drop parametern till FALSE håller dataramen.

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

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

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

Andra föremål

Operatörerna [ och [[ är primitiva funktioner som är generiska. Detta innebär att alla objekt i R (specifikt isTRUE(is.object(x)) --ie har ett uttryckligt "klass" -attribut) kan ha sitt eget angivna beteende när det ställs in; dvs. har sina egna metoder för [ och / eller [[ .

Till exempel är detta fallet med "data.frame" ( is.object(iris) ) -objekt där [.data.frame och [[.data.frame metoder är definierade och de är gjorda för att visa både "matrix" -liknande och "lista" -liknande underinställningar. Med att tvinga fram ett fel när du sätter ned en "data.frame" ser vi att en funktion [.data.frame kallades när vi -just-använde [ .

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

Utan ytterligare detaljer om det aktuella ämnet, ett exempel [ metod:

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

Vi kan övervinna metodförsändningen av [ genom att använda den ekvivalenta icke-generiska. .subset (och .subset2 för [[ )). Detta är särskilt användbart och effektivt när du programmerar våra egna "klass" och vill undvika arbetsomgångar (som unclass(x) ) när du beräknar våra "klass" på ett effektivt sätt (undviker avsändning av metoder och kopierar objekt):

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

Vektorindex

I det här exemplet kommer vi att använda vektorn:

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

R-vektorer är 1-indexerade, så till exempel kommer x[1] att returnera 11 . Vi kan också extrahera en delvektor av x genom att överföra en vektor med index till konsolen operatör:

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

Om vi passerar en vektor med negativa index kommer R att returnera en undervektor med de angivna indexen uteslutna:

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

Vi kan också skicka en boolesk vektor till parentesoperatören, i vilket fall den returnerar en subvektor som motsvarar koordinaterna där indexeringsvektorn är TRUE :

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

Om indexeringsvektorn är kortare än arrayens längd kommer den att upprepas, som i:

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

Elementvis matrisoperationer

Låt A och B vara två matriser med samma dimension. Operatörerna + , - , / , * , ^ när de används med matriser av samma dimension utför de erforderliga operationerna på motsvarande element i matriserna och returnerar en ny matris med samma dimension. Dessa operationer kallas vanligtvis elementvisa operationer.

För "sann" matrismultiplikation, som framgår av Linear Algebra , använd %*% . Exempelvis är multiplikation av A med B: A %*% B Dimensionskraven är att ncol() för A är densamma som nrow() för B

Några funktioner som används med matriser