Protocolo:

¿Qué es una lista en R?

Una lista en R es el objeto que contiene elementos de diferentes tipos - como cadenas, números, vectores y otras listas dentro de ella.

Una lista en R también puede contener una matriz o una función como sus elementos. La lista se crea utilizando la función list() en R. En otras palabras, una lista es un vector genérico que contiene otros objetos.

NOTA: Un vector que tiene todos los elementos del mismo tipo se llama vector atómico, pero un vector que tiene elementos de diferentes tipos se llama lista.

Podemos comprobar si es una lista con la función typeof() y encontrar su longitud utilizando length().

# Crearemos diferentes estructuras de datos para almacenarlas en una lista:
message("\n# Crearemos diferentes estructuras de datos para almacenarlas en una lista:")
## 
## # Crearemos diferentes estructuras de datos para almacenarlas en una lista:
## Vector:
print("## Vector:")
## [1] "## Vector:"
vnum <- c(1,2,3)

vchar <- c("Terminator", "Fast&Furious", "Love&Mounster")

vlog <- c(TRUE, FALSE, FALSE, TRUE)

lista_vec <- list(vnum, vchar, vlog)

lista_vec
## [[1]]
## [1] 1 2 3
## 
## [[2]]
## [1] "Terminator"    "Fast&Furious"  "Love&Mounster"
## 
## [[3]]
## [1]  TRUE FALSE FALSE  TRUE
# Averiguemos si es una lista:
message("\n# Averiguemos si es una lista:")
## 
## # Averiguemos si es una lista:
typeof(lista_vec)
## [1] "list"
# Averiguemos su longitud:
cat("La longitud de la lista es =", length(lista_vec))
## La longitud de la lista es = 3

¿Como Crear Listas?

  • La lista se puede crear con la función list().

  • Su estructura se puede examinar con la función str().

# Vamos a crear una lista que contenga cadenas, números, vectores y valores lógicos.
message("\n# Vamos a crear una lista que contenga cadenas, números, vectores y valores lógicos.")
## 
## # Vamos a crear una lista que contenga cadenas, números, vectores y valores lógicos.
lista_variada <- list("Cadena", "Felipe", c(1,2,3), TRUE, 12.21331, 23421L)

cat("\n>lista_variada <- list(\"Cadena\", \"Felipe\", c(1,2,3), TRUE, 12.21331, 23421L)", "\n \nOUTPUT:\n \n")
## 
## >lista_variada <- list("Cadena", "Felipe", c(1,2,3), TRUE, 12.21331, 23421L) 
##  
## OUTPUT:
## 
print(lista_variada)
## [[1]]
## [1] "Cadena"
## 
## [[2]]
## [1] "Felipe"
## 
## [[3]]
## [1] 1 2 3
## 
## [[4]]
## [1] TRUE
## 
## [[5]]
## [1] 12.21331
## 
## [[6]]
## [1] 23421
# Estrutura de la lista:
message("\n# Estrutura de la lista:")
## 
## # Estrutura de la lista:
str(lista_variada)
## List of 6
##  $ : chr "Cadena"
##  $ : chr "Felipe"
##  $ : num [1:3] 1 2 3
##  $ : logi TRUE
##  $ : num 12.2
##  $ : int 23421

¿Cómo nombrar los elementos de la lista?

Nombrando listas a través de etiquetas:

En este ejemplo, a, b y c se denominan etiquetas, lo que facilita la referencia a los componentes de la lista.

# Etiquetas en la lista:
message("\n# Etiquetas en la lista:")
## 
## # Etiquetas en la lista:
x <- list("a" = 2.5, "b" = TRUE, "c" = 1:3)

Sin embargo, las etiquetas son opcionales. Podemos crear la misma lista sin las etiquetas. En este caso, los índices numéricos se utilizan por defecto.

# Listas sin etiquetas:
message("\n# Listas sin etiquetas:")
## 
## # Listas sin etiquetas:
x <- list(2.5,TRUE,1:3)

Nombrar listas en R con names()

Nombrar listas en R, se realiza de la siguiente manera:

# Vamos a crear una lista que contenga un vector, una matriz y una lista:
message("\n# Vamos a crear una lista que contenga un vector, una matriz y una lista:")
## 
## # Vamos a crear una lista que contenga un vector, una matriz y una lista:
ListaDeDatos <- list(c("Superman", "Batman", "Aquaman"), matrix(-5:5, nrow = 2), list(TRUE, FALSE, 12.121, 234L))
## Warning in matrix(-5:5, nrow = 2): la longitud de los datos [11] no es un
## submúltiplo o múltiplo del número de filas [2] en la matriz
## Nombremos los elementos de la lista:
message("\n## Nombremos los elementos de la lista:")
## 
## ## Nombremos los elementos de la lista:
names(ListaDeDatos) <- c("SuperHeroes", "Matriz", "Lista Logica & Numerica")

cat("\n> names(ListaDeDatos) <- c(\"SuperHeroes\", \"Matriz\", \"Lista Logica & Numerica\")", "\n \nOUTPUT:\n \n")
## 
## > names(ListaDeDatos) <- c("SuperHeroes", "Matriz", "Lista Logica & Numerica") 
##  
## OUTPUT:
## 
print(ListaDeDatos)
## $SuperHeroes
## [1] "Superman" "Batman"   "Aquaman" 
## 
## $Matriz
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]   -5   -3   -1    1    3    5
## [2,]   -4   -2    0    2    4   -5
## 
## $`Lista Logica & Numerica`
## $`Lista Logica & Numerica`[[1]]
## [1] TRUE
## 
## $`Lista Logica & Numerica`[[2]]
## [1] FALSE
## 
## $`Lista Logica & Numerica`[[3]]
## [1] 12.121
## 
## $`Lista Logica & Numerica`[[4]]
## [1] 234

¿Cómo acceder a la lista de elementos de R?

Se puede acceder a las listas de forma similar a los vectores. Se pueden utilizar vectores enteros, lógicos o de caracteres para la indexación.

# Utilizaremos la lista que hemos creado en la sección anterior:
message("\n# Utilizaremos la lista que hemos creado en la sección anterior:")
## 
## # Utilizaremos la lista que hemos creado en la sección anterior:
print(ListaDeDatos)
## $SuperHeroes
## [1] "Superman" "Batman"   "Aquaman" 
## 
## $Matriz
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]   -5   -3   -1    1    3    5
## [2,]   -4   -2    0    2    4   -5
## 
## $`Lista Logica & Numerica`
## $`Lista Logica & Numerica`[[1]]
## [1] TRUE
## 
## $`Lista Logica & Numerica`[[2]]
## [1] FALSE
## 
## $`Lista Logica & Numerica`[[3]]
## [1] 12.121
## 
## $`Lista Logica & Numerica`[[4]]
## [1] 234
# Acceder al primer elemento de la lista:
cat("\n# Acceder al primer elemento de la lista:\n", "print(ListaDeDatos[1])", "\n \nOUTPUT:\n")
## 
## # Acceder al primer elemento de la lista:
##  print(ListaDeDatos[1]) 
##  
## OUTPUT:
print(ListaDeDatos[1])
## $SuperHeroes
## [1] "Superman" "Batman"   "Aquaman"
# también utilizando el nombre del elemento, podemos acceder a los elementos de la lista:
cat("\n# también utilizando el nombre del elemento, podemos acceder a los elementos de la lista:", "\n \n> print(ListaDeDatos$Matriz)", "\n \nOUTPUT:\n \n")
## 
## # también utilizando el nombre del elemento, podemos acceder a los elementos de la lista: 
##  
## > print(ListaDeDatos$Matriz) 
##  
## OUTPUT:
## 
print(ListaDeDatos$Matriz)
##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]   -5   -3   -1    1    3    5
## [2,]   -4   -2    0    2    4   -5

Nota = T: TRUE F: FALSE

# Llamamos a un elemento de una lista:
message("\n# Llamamos a un elemento de una lista:")
## 
## # Llamamos a un elemento de una lista:
x <- list("Daniel", 20, c("Español", "Ingles"))
names(x) <- c("Nombre", "Edad", "Lengua_Materna")

## Lista:
print("## Lista:")
## [1] "## Lista:"
print(x)
## $Nombre
## [1] "Daniel"
## 
## $Edad
## [1] 20
## 
## $Lengua_Materna
## [1] "Español" "Ingles"
## índice mediante vector de enteros:
message("\n## índice mediante vector de enteros:\n")
## 
## ## índice mediante vector de enteros:
cat("x[c(1:2)]", "\n \nOUTPUT:\n")
## x[c(1:2)] 
##  
## OUTPUT:
print(x[c(1:2)])
## $Nombre
## [1] "Daniel"
## 
## $Edad
## [1] 20
## usando un entero negativo para excluir el segundo componente:
message("\n## usando un entero negativo para excluir el segundo componente:")
## 
## ## usando un entero negativo para excluir el segundo componente:
cat("x[-2]", "\n \nOUTPUT:\n")
## x[-2] 
##  
## OUTPUT:
print(x[-2])
## $Nombre
## [1] "Daniel"
## 
## $Lengua_Materna
## [1] "Español" "Ingles"
## índice mediante vector lógico:
message("\n## índice mediante vector lógico:")
## 
## ## índice mediante vector lógico:
cat("x[c(F,T,T)]", "\n \nOUTPUT:\n")
## x[c(F,T,T)] 
##  
## OUTPUT:
print(x[c(F,T,T)])
## $Edad
## [1] 20
## 
## $Lengua_Materna
## [1] "Español" "Ingles"
## índice utilizando el vector de caracteres:
message("\n## índice utilizando el vector de caracteres:")
## 
## ## índice utilizando el vector de caracteres:
cat("\nx[c(\"Nombre\", \"Lengua_Materna\")", "\n \nOUTPUT:\n")
## 
## x[c("Nombre", "Lengua_Materna") 
##  
## OUTPUT:
print(x[c("Nombre", "Lengua_Materna")])
## $Nombre
## [1] "Daniel"
## 
## $Lengua_Materna
## [1] "Español" "Ingles"

Forma alternativa:

Indexación:

La indexación con [ como se muestra arriba nos dará la sublista no el contenido dentro del componente. Para recuperar el contenido, tenemos que utilizar [[.

Sin embargo, este enfoque nos permitirá acceder a un solo componente a la vez.

# [ devuelve una lista:
message("\n# [ devuelve una lista:")
## 
## # [ devuelve una lista:
cat("> x[\"Nombre\"]", "\n \nOUTPUT:\n")
## > x["Nombre"] 
##  
## OUTPUT:
print(x["Nombre"])
## $Nombre
## [1] "Daniel"
cat("\n> typeof(x[\"Nombre\"])", "\n \nOUTPUT:\n")
## 
## > typeof(x["Nombre"]) 
##  
## OUTPUT:
print(typeof(x["Nombre"]))
## [1] "list"
# doble [[ retorna Un numero real:
message("\n# doble [[ retorna Un numero real:")
## 
## # doble [[ retorna Un numero real:
cat("> x[[\"Edad\"]]", "\n \nOUTPUT:\n")
## > x[["Edad"]] 
##  
## OUTPUT:
print(x[["Edad"]])
## [1] 20
cat("\n> typeof(x[[\"Edad\"]])", "\n \nOUTPUT:\n")
## 
## > typeof(x[["Edad"]]) 
##  
## OUTPUT:
print(typeof(x[["Edad"]]))
## [1] "double"

Una alternativa a [[, que se utiliza a menudo al acceder al contenido de una lista, es el operador $.

Ambos son iguales, excepto que $ puede hacer coincidencias parciales en las etiquetas.

# igual que x[["nombre"]]:
message("\n# igual que x[[\"nombre\"]]:")
## 
## # igual que x[["nombre"]]:
cat("x$Nombre", "\n \nOUTPUT:\n")
## x$Nombre 
##  
## OUTPUT:
print(x$Nombre)
## [1] "Daniel"
# La indexación puede hacerse de forma recursiva:
message("\n# La indexación puede hacerse de forma recursiva:")
## 
## # La indexación puede hacerse de forma recursiva:
cat("\nx$Lengua_Materna[1]","\n \nOUTPUT:\n")
## 
## x$Lengua_Materna[1] 
##  
## OUTPUT:
print(x$Lengua_Materna[1])
## [1] "Español"
# Esto es igual que:
cat("\n \nEsto es igual que:\n")
## 
##  
## Esto es igual que:
cat("x[[\"Lengua_Materna\"]][2]", "\n \nOUTPUT:\n")
## x[["Lengua_Materna"]][2] 
##  
## OUTPUT:
print(x[["Lengua_Materna"]][2])
## [1] "Ingles"

¿Cómo modificar una lista?

Podemos modificar los componentes de una lista mediante la reasignación. Podemos elegir cualquiera de las técnicas de acceso a los componentes comentadas anteriormente para modificarla.

# Cambiemos el nombre de la lista:

cat("\nx[[\"Nombre\"]]", "\n \nOUTPUT:\n")
## 
## x[["Nombre"]] 
##  
## OUTPUT:
print(x[["Nombre"]])
## [1] "Daniel"
message("\n# Cambiemos el nombre de la lista:")
## 
## # Cambiemos el nombre de la lista:
cat("\nx[[\"Nombre\"]] <- \"Felipe\"", "\n \nOUTPUT:\n \n")
## 
## x[["Nombre"]] <- "Felipe" 
##  
## OUTPUT:
## 
x[["Nombre"]] <- "Felipe"

print(x[["Nombre"]])
## [1] "Felipe"

¿Cómo añadir componentes a una lista?

Añadir nuevos componentes es fácil. Simplemente asignamos valores usando nuevas etiquetas y entrará en acción.

# Añadir un nuevo elemento:

cat("x", "\n \nOUTPUT:\n \n")
## x 
##  
## OUTPUT:
## 
print(x)
## $Nombre
## [1] "Felipe"
## 
## $Edad
## [1] 20
## 
## $Lengua_Materna
## [1] "Español" "Ingles"
message("\n# Añadir un nuevo elemento:")
## 
## # Añadir un nuevo elemento:
x[["Estado Civil"]] <- "Soltero"

cat("x[[\"Estado Civil\"]] <- \"Soltero\"", "\n \nOUTPUT:\n \n")
## x[["Estado Civil"]] <- "Soltero" 
##  
## OUTPUT:
## 
print(x)
## $Nombre
## [1] "Felipe"
## 
## $Edad
## [1] 20
## 
## $Lengua_Materna
## [1] "Español" "Ingles" 
## 
## $`Estado Civil`
## [1] "Soltero"

¿Cómo borrar componentes de una lista?

Podemos eliminar un componente asignándole NULL.

# Elimiar un elemnto:

cat("str(x)", "\n \nOUTPUT:\n \n")
## str(x) 
##  
## OUTPUT:
## 
str(x)
## List of 4
##  $ Nombre        : chr "Felipe"
##  $ Edad          : num 20
##  $ Lengua_Materna: chr [1:2] "Español" "Ingles"
##  $ Estado Civil  : chr "Soltero"
message("\n# Elimiar un elemnto:")
## 
## # Elimiar un elemnto:
cat("x[[\"Edad\"]] <- NULL", "\n \nOUTPUT:\n \n")
## x[["Edad"]] <- NULL 
##  
## OUTPUT:
## 
x[["Edad"]] <- NULL

cat("str(x)", "\n \nOUTPUT:\n \n")
## str(x) 
##  
## OUTPUT:
## 
str(x)
## List of 3
##  $ Nombre        : chr "Felipe"
##  $ Lengua_Materna: chr [1:2] "Español" "Ingles"
##  $ Estado Civil  : chr "Soltero"

¿Cómo fusionar listas?

Podemos fusionar varias listas en una sola colocando todos los elementos de la lista dentro de c().

# Unir listas en R:
message("\n# Unir listas en R:")
## 
## # Unir listas en R:
cat("Creamos dos listas independientes, que luego se uniran con c()",
    "\n lista_num <- list(1:5)\n",
    "lista_meses <- list(\"ENERO\",\"FEBRERO\", \"MARZO\", \"ABRIL\", \"MAYO\")", "Las uniremos en una sola con el comando:\n", "\n \nunion <- c(lista_num, lista_meses)", "\n \nOUTPUT:\n \n")
## Creamos dos listas independientes, que luego se uniran con c() 
##  lista_num <- list(1:5)
##  lista_meses <- list("ENERO","FEBRERO", "MARZO", "ABRIL", "MAYO") Las uniremos en una sola con el comando:
##  
##  
## union <- c(lista_num, lista_meses) 
##  
## OUTPUT:
## 
lista_num <- list(1:5)

lista_meses <- list("ENERO","FEBRERO", "MARZO", "ABRIL", "MAYO")

union <- c(lista_num, lista_meses)
print(union)
## [[1]]
## [1] 1 2 3 4 5
## 
## [[2]]
## [1] "ENERO"
## 
## [[3]]
## [1] "FEBRERO"
## 
## [[4]]
## [1] "MARZO"
## 
## [[5]]
## [1] "ABRIL"
## 
## [[6]]
## [1] "MAYO"

Listas predefinidas

Las listas de letras y nombres de meses están predefinidas:

# Listas predefinidas de R:
message("\n# Listas predefinidas de R:")
## 
## # Listas predefinidas de R:
cat("\n=> Lista del abecedario en minúscula:\n \n", letters)
## 
## => Lista del abecedario en minúscula:
##  
##  a b c d e f g h i j k l m n o p q r s t u v w x y z
cat("\n \n=> Lista del abecedario en Mayúscula:\n \n", LETTERS)
## 
##  
## => Lista del abecedario en Mayúscula:
##  
##  A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
cat("\n \n=>Iniciales de los meses del año en ingles:\n \n", month.abb)
## 
##  
## =>Iniciales de los meses del año en ingles:
##  
##  Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
cat("\n \n=> Meses del año en ingles:\n \n", month.name)
## 
##  
## => Meses del año en ingles:
##  
##  January February March April May June July August September October November December