¿Cómo Utilizar Correctamente las Listas en R?

Con respecto a sus preguntas, permítanme abordarlas en orden y dar algunos ejemplos:

1) Se devuelve una lista si y cuando la instrucción return agrega una. Considere

 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) Los nombres simplemente no se establecen:

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

3) No devuelven lo mismo. Su ejemplo da

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

Donde x[1] devuelve el primer elemento de x -- que es el mismo que x. Cada escalar es un vector de longitud uno. Por otro lado x[[1]] devuelve el primer elemento de la lista.

4) Por último, los dos son diferentes entre ellos crean, respectivamente, una lista que contiene cuatro escalares y una lista con un solo elemento (que pasa a ser un vector de cuatro elementos).

Solo para tomar un subconjunto de sus preguntas:

Este artículo sobre indización aborda la cuestión de la diferencia entre [] y [[]].

En resumen [[]] selecciona un solo elemento de una lista y [] devuelve una lista de los elementos seleccionados. En su ejemplo, x = list(1, 2, 3, 4)' el elemento 1 es un solo entero, pero x[[1]] devuelve un solo 1 y x[1] devuelve una lista con un solo valor.

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

> x[[1]]
[1] 1

Una razón por la que las listas funcionan como lo hacen (ordenadas) es para abordar la necesidad de un contenedor ordenado que pueda contener cualquier tipo en cualquier nodo, lo que los vectores no hacen. Las listas se reutilizan para una variedad de propósitos en R, incluyendo formar la base de a data.frame, que es una lista de vectores de tipo arbitrario (pero de la misma longitud).

¿Por qué estas dos expresiones no devuelven el mismo resultado?

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

Para añadir a la respuesta de @Shane, si quieres obtener el mismo resultado, try:

x3 = as.list(1:4)

Que coacciona el vector 1:4 en una lista.

Solo para añadir un punto más a esto:

R tiene una estructura de datos equivalente al dict de Python en el paquete hash . Puedes leer sobre ello en esta entrada del blog del Grupo de Datos Abiertos. He aquí un ejemplo sencillo:

> 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

En términos de usabilidad, la clase hash es muy similar a una lista. Pero el rendimiento es mejor para grandes conjuntos de datos.

Usted dice:

Para otro, las listas pueden ser devueltas de funciones a pesar de que nunca pasado en una Lista cuando llamó a la función, y aunque la función no contiene un constructor de lista, por ejemplo,

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

Y supongo que usted sugiere que esto es un problema (?). Estoy aquí para decirte por qué no es un problema : -). Su ejemplo es un poco simple, ya que cuando hace la división de cadenas, tiene una lista con elementos que tienen 1 elemento de longitud, por lo que sabe eso x[[1]] es lo mismo que unlist(x)[1]. Pero qué pasa si el resultado de strsplit devuelve resultados de diferente longitud en cada bin. Simplemente devolver un vector (frente a la lista) no.

Por ejemplo:

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, ","))

En el primer caso (x : que devuelve una lista), puedes decir cuál era la 2da "parte" de la 3ra cadena, por ejemplo: x[[3]][2]. ¿Cómo podrías hacer lo mismo usando xx ahora que los resultados han sido "desenredados" (unlist-ed)?

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

No es lo mismo porque 1: 4 es lo mismo que c (1,2,3,4). Si quieres que sean los mismos entonces:

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

Respecto a los vectores y el concepto hash/array de otros lenguajes:

1. Los vectores son los átomos de R. Eg, rpois(1e4,5) (5 números aleatorios), numeric(55) (longitud-55 vector cero sobre dobles), y character(12) (12 cadenas vacías), son todos "básicos".

2. Cualquiera de las listas o vectores pueden tener 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
   

3. Los vectores requieren que todo sea del mismo tipo de datos. Mira esto:

   > 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
   

4. Las listas pueden contener diferentes tipos de datos, como se ve en otras respuestas y la propia pregunta de la OP.

He visto lenguajes (ruby, javascript) en los que "arrays" pueden contener tipos de datos variables, pero por ejemplo en C++ "arrays" deben ser todos del mismo tipo de datos. Creo que esto es una cosa de velocidad / eficiencia: si tienes un numeric(1e6) sabes su tamaño y la ubicación de cada elemento a priori ; si la cosa podría contener "Flying Purple People Eaters" en algún segmento desconocido, entonces tienes que analizar realmente las cosas para conocer los hechos básicos sobre se.

Ciertas operaciones R estándar también tienen más sentido cuando el tipo está garantizado. Por ejemplo, cumsum(1:9) tiene sentido, mientras que cumsum(list(1,2,3,4,5,'a',6,7,8,9)) no, sin que se garantice que el tipo sea doble.

En cuanto a su segunda pregunta:

Las listas se pueden devolver desde funciones aunque nunca haya pasado una Lista cuando llamó a la función{[16]]}

Las funciones devuelven diferentes tipos de datos de los que se introducen todo el tiempo. plot devuelve un gráfico aunque no toma una trama como entrada. Arg devuelve un numeric aunque aceptó un complex. Sucesivamente.

(Y en cuanto a strsplit: el código fuente es aquí.)

Si ayuda, tiendo a concebir "listas" en R como "registros"en otros lenguajes pre-OO:

• no hacen ninguna suposición sobre un tipo global (o más bien el tipo de todos los registros posibles de cualquier arity y nombres de campo está disponible).
• sus campos pueden ser anónimos (luego se accede a ellos por estricto orden de definición).

El nombre "registro" chocaría con el significado estándar de" registros " (también conocido como filas) en el lenguaje de la base de datos, y puede ser que esta sea la razón por la que su nombre se sugiere: como listas (de campos).

Aunque esta es una pregunta bastante antigua, debo decir que está tocando exactamente el conocimiento que me faltaba durante mis primeros pasos en R, es decir, cómo expresar datos en mi mano como objeto en R o cómo seleccionar entre objetos existentes. No es fácil para un novato de R pensar" en una caja de R " desde el principio.

Así que yo mismo comencé a usar muletas debajo, lo que me ayudó mucho a averiguar qué objeto usar para qué datos, y básicamente a imaginar el uso en el mundo real.

Aunque no dar respuestas exactas a la pregunta el texto corto a continuación podría ayudar al lector que acaba de comenzar con R y está haciendo preguntas simmilares.

• Vector atómico ... Lo llamé "secuencia" para mí, sin dirección, solo secuencia de los mismos tipos. [ subconjuntos.
• Vector ... secuencia con una dirección a partir de subconjuntos 2D, [.
• Matriz ... montón de vectores con la misma longitud formando filas o columnas, [ subconjuntos por filas y columnas, o por secuencia.
• Matrices ... matrices en capas que forman 3D
• Dataframe ... una tabla 2D como en Excel, donde puedo ordenar, agregar o eliminar filas o columnas o hacer arit. operaciones con ellos, solo después de algún tiempo realmente reconocí que dataframe es una implementación inteligente de list donde puedo subconjunto usando [ por filas y columnas, pero incluso usando [[.
• List ... para ayudarme a mí mismo pensé en la lista como de tree structure donde [i] selecciona y devuelve ramas enteras y [[i]] devuelve elemento de la rama. Y porque si es tree like structure, incluso puede usar un index sequence para abordar cada hoja en un list muy complejo usando su [[index_vector]]. Las listas pueden ser simples o muy complejas y pueden mezclar varios tipos de objetos en uno.

Así que para lists puede terminar con más formas de cómo seleccionar un leaf dependiendo de la situación como en el siguiente ejemplo.

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

Esta forma de pensar me ayudó mucho.

¿por Qué estos dos operadores diferentes, [ ], y [[ ]], devuelven el mismo resultado?

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

1. [ ] proporciona una operación de subajuste. En general subconjunto de cualquier objeto tendrá el mismo tipo que el objeto original. Por lo tanto, x[1] proporciona una lista. Del mismo modo x[1:2] es un subconjunto de la lista original, por lo tanto, es una lista. Ex.

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

2. [[ ]] es para extraer un elemento de la lista. x[[1]] es válido y extraer el primer elemento de la lista. x[[1:2]] no es válido como [[ ]] no proporciona una configuración secundaria como [ ].

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