Как правильно использовать списки в R?

Что касается ваших вопросов, позвольте мне привести их в порядок и привести несколько примеров:

1) Список возвращается, если и когда оператор return добавляет его. Рассмотрим

 R> retList <- function() return(list(1,2,3,4)); class(retList())
 [1] "list"
 R> notList <- function() return(c(1,2,3,4)); class(notList())
 [1] "numeric"
 R> 

2) Имена просто не заданы:

R> retList <- function() return(list(1,2,3,4)); names(retList())
NULL
R> 

3) Они не возвращают то же самое. В вашем примере

R> x <- list(1,2,3,4)
R> x[1]
[[1]]
[1] 1
R> x[[1]]
[1] 1

где x[1] возвращает первый элемент x - который совпадает с x. Каждый скаляр является вектором длины один. С другой стороны x[[1]] возвращает первый элемент списка.

4). Наконец, они отличаются друг от друга тем, что они создают, соответственно, список, содержащий четыре скаляра, и список с одним элементом (который представляет собой вектор из четырех элементов).

Просто возьмите подмножество своих вопросов:

В этой статье об индексации рассматривается вопрос о разнице между [] и [[]].

Короче [[]] выбирает один элемент из списка, а [] возвращает список выбранных элементов. В вашем примере x = list(1, 2, 3, 4)' элемент 1 представляет собой одно целое число, но x[[1]] возвращает один 1 и x[1] возвращает список только с одним значением.

> x = list(1, 2, 3, 4)
> x[1]
[[1]]
[1] 1

> x[[1]]
[1] 1

Одна из причин приводит к тому, что работа, которую они выполняют (заказываются), предназначена для удовлетворения потребности в упорядоченном контейнере, который может содержать любой тип в любом node, который не выполняется. Списки повторно используются для различных целей в R, включая формирование базы data.frame, которая представляет собой список векторов произвольного типа (но с той же длиной).

Почему эти два выражения не возвращают один и тот же результат?

x = list(1, 2, 3, 4); x2 = list(1:4)

Чтобы добавить к ответу @Shane, если вы хотите получить тот же результат, попробуйте:

x3 = as.list(1:4)

Который принуждает вектор 1:4 к списку.

Просто добавьте еще один момент:

R имеет структуру данных, эквивалентную Python dict в пакете hash. Вы можете прочитать об этом в этом сообщении в блоге из группы открытых данных. Вот простой пример:

> library(hash)
> h <- hash( keys=c('foo','bar','baz'), values=1:3 )
> h[c('foo','bar')]
<hash> containing 2 key-value pairs.
  bar : 2
  foo : 1

В терминах удобства использования класс hash очень похож на список. Но производительность лучше для больших наборов данных.

Вы говорите:

С другой стороны, списки могут быть возвращены от функций, даже если вы никогда в списке, когда вы вызвали функции, и хотя функция не содержит конструктор List, например.

x = strsplit(LETTERS[1:10], "") # passing in an object of type 'character'
class(x)
# => 'list'

И я думаю, вы предполагаете, что это проблема (?). Я здесь, чтобы рассказать вам, почему это не проблема:-). Ваш пример немного прост, в том случае, когда вы выполняете разделение строк, у вас есть список с элементами длиной 1 элемент, поэтому вы знаете, что x[[1]] совпадает с unlist(x)[1]. Но что, если результат strsplit возвращал результаты разной длины в каждый бит. Простое возвращение вектора (по сравнению с списком) вообще не будет выполняться.

Например:

stuff <- c("You, me, and dupree",  "You me, and dupree",
           "He ran away, but not very far, and not very fast")
x <- strsplit(stuff, ",")
xx <- unlist(strsplit(stuff, ","))

В первом случае (x: который возвращает список) вы можете указать, что было 2-й "частью" третьей строки, например: x[[3]][2]. Как вы могли бы сделать то же самое с помощью xx теперь, когда результаты были "распущены" (unlist -ed)?

x = list(1, 2, 3, 4)
x2 = list(1:4)
all.equal(x,x2)

не то же самое, поскольку 1: 4 совпадает с c (1,2,3,4). Если вы хотите, чтобы они были такими же:

x = list(c(1,2,3,4))
x2 = list(1:4)
all.equal(x,x2)

Хотя это довольно старый вопрос, я должен сказать, что это касается именно тех знаний, которые я отсутствовал во время моих первых шагов в R - то есть, как выразить данные в моей руке как объект в R или как выбирать из существующих объектов. Нелегко для начинающего R начинать думать "в коробке R" с самого начала.

Итак, я сам начал использовать костыли, которые помогли мне много узнать, какой объект использовать для каких данных, и в основном представить себе реальное использование.

Хотя я не даю точных ответов на вопрос, короткий текст ниже может помочь читателю, который только что начал с R и задает близкие вопросы.

• Атомный вектор... Я назвал эту "последовательность" для себя, без направления, просто последовательность одного и того же типа. [ подмножества.
• Вектор... последовательность с одним направлением от 2D, [ подмножеств.
• Матрица... связка векторов с одинаковой длиной, образующая строки или столбцы, подмножества [ по строкам и столбцам или по последовательности.
• Массивы... слоистые матрицы, образующие 3D
• Dataframe... 2D-таблица, как в excel, где я могу сортировать, добавлять или удалять строки или столбцы или создавать arit. операции с ними, только через некоторое время я действительно осознал, что dataframe - это умная реализация list, где я могу подмножество с помощью [ по строкам и столбцам, но даже используя [[.
• Список... чтобы помочь себе, я думал о списке с tree structure, где [i] выбирает и возвращает целые ветки, а [[i]] возвращает элемент из ветки. И поскольку это tree like structure, вы можете даже использовать index sequence для адресации каждого отдельного листа на очень сложном list, используя его [[index_vector]]. Списки могут быть простыми или очень сложными и могут смешивать различные типы объектов в один.

Итак, для lists вы можете больше использовать способ выбора leaf в зависимости от ситуации, как в следующем примере.

l <- list("aaa",5,list(1:3),LETTERS[1:4],matrix(1:9,3,3))
l[[c(5,4)]] # selects 4 from matrix using [[index_vector]] in list
l[[5]][4] # selects 4 from matrix using sequential index in matrix
l[[5]][1,2] # selects 4 from matrix using row and column in matrix

Этот способ мышления очень помог мне.

Почему эти два разных оператора [ ] и [[ ]] возвращают тот же результат?

x = list(1, 2, 3, 4)

• [ ] выполняет вспомогательную настройку. В общем подмножестве любого объекта будет иметь тот же тип, что и исходный объект. Поэтому x[1] предоставляет список. Аналогично x[1:2] является подмножеством исходного списка, поэтому это список. Пример.

  x[1:2]
  
  [[1]] [1] 1
  
  [[2]] [1] 2
  

• [[ ]] предназначен для извлечения элемента из списка. x[[1]] и извлечь первый элемент из списка. x[[1:2]] недействителен как [[ ]] не предоставляет настройку sub, например [ ].

   x[[2]] [1] 2 
  
  > x[[2:3]] Error in x[[2:3]] : subscript out of bounds
  

Если это помогает, я склонен воспринимать "списки" в R как "записи" на других языках до OO:

• они не делают никаких предположений о всеобъемлющем типе (или, скорее, о типе всех возможных записей любых имен arity и field).
• их поля могут быть анонимными (тогда вы получаете доступ к ним по строгим определениям).

Название "запись" столкнулось бы со стандартным значением "записей" (aka rows) в языке базы данных, и, возможно, именно поэтому их имя предложило себя как списки (полей).

Относительно векторов и концепции хэш/массив от других языков:

• Векторы представляют собой атомы R. Например, rpois(1e4,5) (5 случайных чисел), numeric(55) (длина - 55 нулевой вектор над удвоениями), а character(12) (12 пустых строк) - все "основной".

• Либо списки, либо векторы могут иметь names.

  > n = numeric(10)
  > n
   [1] 0 0 0 0 0 0 0 0 0 0
  > names(n)
  NULL
  > names(n) = LETTERS[1:10]
  > n
  A B C D E F G H I J 
  0 0 0 0 0 0 0 0 0 0
  

• Векторы требуют, чтобы все было одним и тем же типом данных. Смотрите это:

  > i = integer(5)
  > v = c(n,i)
  > v
  A B C D E F G H I J           
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
  > class(v)
  [1] "numeric"
  > i = complex(5)
  > v = c(n,i)
  > class(v)
  [1] "complex"
  > v
     A    B    C    D    E    F    G    H    I    J                          
  0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i
  

• Списки могут содержать различные типы данных, как видно из других ответов и самого вопроса OP.

Я видел языки (ruby, javascript), в которых "массивы" могут содержать переменные типы данных, но, например, в С++ "массивы" должен быть одинаковый тип данных. Я считаю, что это скорость/эффективность: если у вас есть numeric(1e6), вы знаете его размер и расположение каждого элемента априори; если предмет может содержать "Flying Purple People Eaters" в некотором неизвестном фрагменте, тогда вы должны фактически разбирать материал, чтобы знать основные факты об этом.

Некоторые стандартные операции R также имеют больше смысла, когда тип гарантирован. Например, cumsum(1:9) имеет смысл, тогда как cumsum(list(1,2,3,4,5,'a',6,7,8,9)) нет, без гарантированного двойного типа.

Что касается вашего второго вопроса:

Списки могут быть возвращены из функций, даже если вы никогда не передавали в List, когда вы вызывали функцию

Функции возвращают разные типы данных, чем они все время вводятся. plot возвращает график, даже если он не принимает график в качестве входа. Arg возвращает a numeric, даже если он принял complex. Etc.

(И что касается strsplit: исходный код здесь.)