R Language
하위 집합

소개

비고

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

원자 벡터

원자 벡터 (목록 및 표현식을 제외하고 벡터이기도 함)는 [ 연산자 :

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

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

[ 연산자는 인수로 벡터를 취할 수도 있습니다. 예를 들어 첫 번째 요소와 세 번째 요소를 선택하려면 다음과 같이하십시오.

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

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

어떤 때는 벡터에서 특정 값을 생략해야 할 수도 있습니다. 이는 해당 값의 색인 앞에 음의 부호 ( - )를 사용하여 수행 할 수 있습니다. 예를 들어, v1에서 첫 번째 값을 생략하면 v1[-1] 합니다. 이것은 하나 이상의 값으로 직선적으로 확장 될 수 있습니다. 예를 들어, v1[-c(1,3)] .

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

경우에 따라 벡터의 길이가 클 때 특정 값의 색인이 존재할 경우 특히이를 알고 싶습니다.

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

원자 벡터가 이름 ( names 속성)을 가지고 있다면 이름의 문자 벡터를 사용하여 부분 집합이 될 수 있습니다 :

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

v
##  one   two three 
##    1     2     3 

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

[[ 연산자는 길이가 1 인 인덱싱 벡터를 받아들이고 존재하는 이름을 제거한다는 점에서 원자 벡터를 인덱싱하는 데에도 사용할 수 있습니다.

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

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

벡터는 논리 벡터를 사용하여 부분 집합이 될 수도 있습니다. 숫자 및 문자 벡터를 사용한 부분 집합과는 달리, 부분 집합에 사용 된 논리 벡터는 요소가 추출되는 벡터의 길이와 같아야합니다. 따라서 논리 벡터 y 가 x 를 부분 집합화하는 데 사용되는 경우 x[y] , if length(y) < length(x) y 는 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)

기울기

목록은 [ :

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"

[ 연산자는 목록의 요소를 선택하고 더 작은 목록을 반환하므로 l1[2] 의 결과는 여전히 목록입니다. [[ 연산자는 목록 요소를 추출하고 목록 요소 유형의 객체를 반환합니다.

요소는 번호 또는 이름의 문자열로 색인화 될 수 있습니다 (존재하는 경우). 여러 요소가 선택 될 수있다 [ 번호 또는 이름의 문자열의 벡터를 전달하여. 벡터의 인덱싱 length > 1 의 [ 및 [[ 특정 요소 및 재귀 일부 (사용 가능한 경우)를 각각 갖는 "목록"을 반환

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

비교 대상 :

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

이는 다음과 같습니다.

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

$ 연산자를 사용하면 이름만으로 목록 요소를 선택할 수 있지만 [ 및 [[ , 따옴표가 필요하지 않습니다. 중위 연산자로 $ 는 하나의 이름 만 가질 수 있습니다 :

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

또한 $ 연산자는 기본적으로 부분 일치를 허용합니다.

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

부분 일치가 허용되는지 여부를 지정해야하는 경우 [[

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

options(warnPartialMatchDollar = TRUE) 설정하면 부분 일치가 $ 발생하면 "경고"가 표시됩니다.

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

행렬

객체의 각 차원에 대해 [ 연산자는 하나의 인수를 취합니다. 벡터는 하나의 차원을 가지며 하나의 인수를 취합니다. 행렬과 데이터 프레임은 두 개의 차원을 가지며 [i, j] 로 주어진 두 개의 인수를 취합니다 [i, j] 여기서 i 는 행이고 j 는 열입니다. 인덱싱은 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] 는 행렬의 i 번째 행, j 번째 열의 원소 mat . 예를 들어 i 값이 2 이고 j 값이 1 이면 행렬의 두 번째 행과 첫 번째 열에 숫자가 표시됩니다. i 또는 j 생략하면 해당 크기의 모든 값이 반환됩니다.

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

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

행렬에 행 또는 열 이름이있는 경우 (필수는 아님) 하위 집합에 사용할 수 있습니다.

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

기본적으로 하위 집합의 결과는 가능한 경우 단순화됩니다. 위의 예에서와 같이 하위 집합에 하나의 차원 만있는 경우 결과는 2 차원 행렬이 아닌 1 차원 벡터가됩니다. 이 기본값은 drop = FALSE 인수로 [ : :

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

물론 선택 영역 자체에 두 개의 차원이있는 경우 차원을 삭제할 수 없습니다.

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

위치 별 개별 매트릭스 항목 선택

Nx2 행렬을 사용하여 행렬에서 N 개의 개별 요소를 선택할 수도 있습니다 (좌표계 작동 방식과 동일). 벡터에서 (1st row, 1st column), (1st row, 3rd column), (2nd row, 3rd column), (2nd row, 1st column) 행렬의 항목을 추출하려면 그 좌표를 가진 인덱스 행렬을 만들고 행렬을 부분 집합 화하기 위해 그것을 사용하여 쉽게 할 수 있습니다 :

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

위의 예에서의 1 열 ind 행렬의 행을 의미 mat 의 둘째 열 ind 의 열을 의미 mat .

데이터 프레임

데이터 프레임을 더 작은 데이터 프레임 으로 서브 세트하는 것은리스트를 서브 세트하는 것과 동일하게 달성 될 수있다.

> 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

데이터 프레임을 열 벡터에 서브 세트하는 것은 이중 대괄호 [[]] 또는 달러 기호 연산자 $를 사용하여 수행 할 수 있습니다.

> 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

데이터를 2 차원 행렬로 서브 세트하는 것은 i 와 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

참고 : j (열)로 부분 집합 만하면 변수 자체 유형으로 단순화되지만 다른 변수는 다른 유형 및 클래스를 가질 수 있으므로 i 만으로 하위 집합을 지정하면 data.frame 반환합니다. drop 매개 변수를 FALSE 설정하면 데이터 프레임이 유지됩니다.

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

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

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

기타 대상

[ 및 [[ 연산자는 일반적인 기본 함수입니다. 즉, R에있는 모든 객체 (특히 isTRUE(is.object(x)) 는 명시 적 "class"속성을가집니다.)는 서브셋 된 경우 자체적으로 지정된 동작을 가질 수 있습니다. 즉에 대한 자신의 방법이있다 [ 및 / 또는 [[ .

예를 들어, [.data.frame ( is.object(iris) ) 개체의 경우 [.data.frame 및 [[.data.frame 메서드가 정의되어 있고 "matrix"와 및 "목록"과 같은 하위 집합. "data.frame"을 부분 집합 할 때 오류가 발생하면 실제로 [.data.frame 이 호출 될 때 호출 된 함수 [.data.frame [ .

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

현재 주제에 대한 자세한 내용이 없으면 예제 [ 메소드 :

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

우리는 상응하는 비 제네릭 .subset (그리고 [[ ]에 대한 .subset2 를 사용함으로써 [ 를 디스패치하는 방법을 극복 할 수 있습니다. 이것은 우리 자신의 "클래스"를 프로그래밍 할 때 효율적이고 ( "class"를 효율적으로 (메소드 디스패치 및 객체 복사를 피하면서) "클래스"를 계산할 때 unclass(x) 와 같은)를 피하고자 할 때 특히 유용합니다.

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

벡터 인덱싱

이 예제에서는 벡터를 사용합니다.

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

R 벡터는 1-indexed이므로, 예를 들어 x[1] 은 11 을 반환합니다. 괄호 연산자에 인덱스 벡터를 전달하여 x 의 서브 벡터를 추출 할 수도 있습니다.

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

우리가 음의 인덱스의 벡터를 전달하면 R은 지정된 인덱스가 제외 된 하위 벡터를 반환합니다.

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

부울 벡터를 대괄호 연산자에 전달할 수도 있습니다.이 경우 인덱싱 벡터가 TRUE 좌표에 해당하는 하위 벡터가 반환됩니다.

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

인덱싱 벡터가 배열 길이보다 짧으면 다음과 같이 반복됩니다.

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

요소 단위 행렬 연산

A와 B를 같은 차원의 두 행렬이라하자. 연산자 + , - , / , * , ^ 동일한 차원의 행렬에서 사용되는 매트릭스의 대응하는 요소에 필요한 연산을 수행하고 동일한 치수의 새로운 행렬을 반환한다. 이러한 작업은 일반적으로 요소 별 작업이라고합니다.

선형 대수 (Linear Algebra )에서 볼 수있는 "사실 (true)"행렬 곱셈의 경우 %*% . 예를 들어, A와 B의 곱셈은 A %*% B 입니다. 차원 요구 사항은 A 의 ncol() nrow() 이 B nrow() 와 동일하다는 것입니다.

행렬과 함께 사용되는 일부 함수