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

Атомные векторы

Атомные векторы (которые исключают списки и выражения, которые также являются векторами) являются подмножествами с использованием оператора [ operator:

# 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

Оператор [[ также может использоваться для индексирования атомных векторов с различиями в том, что он принимает вектор индексирования с длиной одного и разделяет любые имена:

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] , если 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'

Матрицы

Для каждого измерения объекта оператор [ operator принимает один аргумент. Векторы имеют один размер и принимают один аргумент. Матрицы и фреймы данных имеют два измерения и принимают два аргумента, заданные как [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 

По умолчанию результат подмножества будет, по возможности, упрощен. Если подмножество имеет только одно измерение, как в приведенных выше примерах, результатом будет одномерный вектор, а не двумерная матрица. Это значение по умолчанию может быть переопределено с аргументом 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

Подмножество данных в виде двумерной матрицы может быть выполнено с использованием термов 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

Примечание. Только data.frame 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)) --ie имеет явный атрибут класса), может иметь свое определенное поведение при подмножестве; т.е. имеет свои собственные методы для [ и / или [[ .

Например, это имеет место с объектами «data.frame» ( is.object(iris) ), где [[.data.frame методы [.data.frame и [[.data.frame , и они созданы для отображения как «матричных» и "list" -подобное подмножество. С форсированием ошибки при подмножестве «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

Мы можем преодолеть метод отправки [ с использованием эквивалентного не-generic .subset (и .subset2 для [[ ). Это особенно полезно и эффективно при программировании наших собственных «классов» и избегает unclass(x) например, 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-индексируются, поэтому, например, 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 - две матрицы той же размерности. Операторы + , - , / , * , ^ при использовании с матрицами одинаковой размерности выполняют требуемые операции над соответствующими элементами матриц и возвращают новую матрицу той же размерности. Эти операции обычно называются элементарными операциями.

Для «истинного» умножения матрицы, как видно из линейной алгебры , используйте %*% . Например, умножение A на B: A %*% B Требования к размеру заключаются в том, что ncol() of A является таким же, как nrow() of B

Некоторые функции, используемые с матрицами