Chapter 6 FACTORES Y LISTAS.

En este capítulo se desarrollará el tema de factores donde los niveles no tienen un orden y otro en donde los niveles si están ordenados, para esto se usará las funciones: factor() y ordered(). Asimismo, se crearán listas y explicaremos para que sirven y cuando usarlas.

6.1 Factores.

En R un objeto factor es una variable que asigna índices a las categorías de las variable. Esto permite una mayor facilidad de procesamiento que si se mantendría la variable en string. Por otro lado, también sirve para asignar categorías a números, este uso es característico de softwares como STATA y SPSS. Hay dos tipos de variables factor en R: los que tienen los niveles desordenados (porque no es necesario que haya un orden) y los que tienen niveles ordenados. En el primero caso usaremos la función factor() o su variante as.factor(), y para el segundo caso, usaremos la función ordered().

6.1.1 Factores con niveles desordenados.

Los niveles no necesitarán un orden cuando las categorías de las variables no tienen un orden jerárquico. Por ejemplo, la variable sexo que tiene dos categorías: masculino y femenino. En esta variable el género másculino no vale más que el género femenino ni viceversa. Otro ejemplo, es el estado civil, en esta variable las categorías no tienen un orden jerarquico, ya que, ser soltero no es más o menos que estar casado o estar viudo.

Una vez que se ha comprendido cuando las categorías no tienen un orden jerarquico, podemos ver unos ejemplos para ver como funciona en el software la función factor().

Primero vamos a crear un vector aleatorio llamado sexo en donde se tienen las dos categorías: masculino y femenino.

# Generando el vector sexo.
set.seed(2021)
sexo<-sample(c("MASCULINO", "FEMENINO"), 33, T)

# Hemos creado al vector sexo con 33 elementos.
sexo

##  [1] "MASCULINO" "FEMENINO"  "FEMENINO"  "FEMENINO"  "MASCULINO" "FEMENINO" 
##  [7] "FEMENINO"  "FEMENINO"  "FEMENINO"  "FEMENINO"  "MASCULINO" "FEMENINO" 
## [13] "FEMENINO"  "MASCULINO" "MASCULINO" "MASCULINO" "MASCULINO" "MASCULINO"
## [19] "FEMENINO"  "MASCULINO" "FEMENINO"  "FEMENINO"  "MASCULINO" "FEMENINO" 
## [25] "MASCULINO" "MASCULINO" "FEMENINO"  "FEMENINO"  "FEMENINO"  "FEMENINO" 
## [31] "MASCULINO" "FEMENINO"  "MASCULINO"

Podemos darnos cuenta que todos los elementos del vector sexo son character. Entonces, si nosotros queremos colocar un índice a cada variable y así mejorar el procesamiento, entonces necesitamos convertir a factor la variable sexo.

La forma más sencilla es usando la función as.factor(). Veamos como:

# Convirtiendo a factor la variable sexo. 
sexo1<-as.factor(sexo)

Estamos guardando el resultado en la variable sexo1.

sexo1

##  [1] MASCULINO FEMENINO  FEMENINO  FEMENINO  MASCULINO FEMENINO  FEMENINO 
##  [8] FEMENINO  FEMENINO  FEMENINO  MASCULINO FEMENINO  FEMENINO  MASCULINO
## [15] MASCULINO MASCULINO MASCULINO MASCULINO FEMENINO  MASCULINO FEMENINO 
## [22] FEMENINO  MASCULINO FEMENINO  MASCULINO MASCULINO FEMENINO  FEMENINO 
## [29] FEMENINO  FEMENINO  MASCULINO FEMENINO  MASCULINO
## Levels: FEMENINO MASCULINO

Ahora los elementos del vector no son character, además, en la parte inferior se observa que se tiene dos niveles: FEMENINO Y MASCULINO. Lo que ha hecho el software es asignar un índice a cada categoría de la variable sexo, en este caso ha asignado el índice 1 a la categoría femenino y 2 a la categoría masculino. Para observar esto usamos la función str() que nos arroja la estructura de cada vector.

# Viendo la estructura de la variable sexo1.
str(sexo1)

##  Factor w/ 2 levels "FEMENINO","MASCULINO": 2 1 1 1 2 1 1 1 1 1 ...

En efecto, nos arroja que la variable sexo1 tiene dos niveles: femenino y masculino y que el índice del primero es 1 y del segundo es 2. Esto es lo que se observa en la parte sombreada de amarillo de la siguiente imagen.

Primero observamos un 2, luego un 1, luego otro 1 y otro 1 y luego un 2 y así sicesivamente. estos son los índices que considera el software para cada categoría. Pero usted se preguntará cómo sé que el 2 corresponde a la categoría femenino y el 1 a masculino. El orden es el mismo que la posición de cada elemento.

Otra forma para saber cual vale 1 y cual vale dos es el orden en el cual aparecen los niveles de la variable. Para saber cuales son los niveles podemos llamar al vector y ver en la última fila.

sexo1

##  [1] MASCULINO FEMENINO  FEMENINO  FEMENINO  MASCULINO FEMENINO  FEMENINO 
##  [8] FEMENINO  FEMENINO  FEMENINO  MASCULINO FEMENINO  FEMENINO  MASCULINO
## [15] MASCULINO MASCULINO MASCULINO MASCULINO FEMENINO  MASCULINO FEMENINO 
## [22] FEMENINO  MASCULINO FEMENINO  MASCULINO MASCULINO FEMENINO  FEMENINO 
## [29] FEMENINO  FEMENINO  MASCULINO FEMENINO  MASCULINO
## Levels: FEMENINO MASCULINO

O podemos usar la función levels(), para conocer los niveles del vector.¹²

levels(sexo1)

## [1] "FEMENINO"  "MASCULINO"

Por las dos formas podemos ver que el primer nivel es FEMENINO y el segundo es MASCULINO. Es así que el software le asignará el valor de 1 a femenino y 2 a masculino. Aquí surge una pregunta muy interesante ¿Por qué el software R empieza los índices con 1 y no con 0, como lo hacen otros softwares como python, java, stata, entre otros?

La respuesta no es clara al 100%, sólo lo saben los que programaron R, pero es una ventaja de R, ya que, si empezaría en 0 el índice al llamar elementos de los vectores. Por ejemplo, si queremos llamar al primer elemento de un vector x usamos x[1], en cambio, en python si queremos llamar al primer elemento tendremos que usar el índice 0, así x[0]. A mi parecer, el índice 0 para llamar al primer elemento me resulta extraño y confuso. Para mayor conocimiento y detalle del tema puede ingresar al siguiente enlace stackoverflow

Entonces, la cuestión es ¿se puede modificar el valor de los índices, es decir, que femenino tome 0 y masculino 1, manteniendo el nombre de las categorías? La respuesta es NO. Esto no es posible, pero no se observa la utilidad de colocar los índices con 0 y 1. Quizá piense que es necesario cuando desarrollará modelos de regresión o clasificación. En realidad, no, el software R sólo necesita que la variable sea factor o en su defecto que las variables sean convertidas en dummies. Esta cuestión se verá más a detalle en capítulos finales.

Otra cuestión podría ser que a usted le interesa que femenino valga 2 y masculino valga 1. Esto sí es posible, para esto usaremos la función factor().

Primero veamos los argumentos de la función factor().

factor(x = character(), levels, labels = levels, exclude = NA, ordered = is.ordered(x), nmax = NA)

Donde:

x = Es un vector.
levels = Son los niveles del vector x.
labels = Son las etiquetas que tomarán los niveles del vector x.
exclude = Son los niveles que se excluirán a la hora de convertir en factor al vector x.
ordered = Si deseamos que los niveles del vector x tengan un orden.
nmax = El número máximo de niveles que se desea tener.

Para verlo a detalle vamos a usar la variable sexo que teníamos creado.

sexo

##  [1] "MASCULINO" "FEMENINO"  "FEMENINO"  "FEMENINO"  "MASCULINO" "FEMENINO" 
##  [7] "FEMENINO"  "FEMENINO"  "FEMENINO"  "FEMENINO"  "MASCULINO" "FEMENINO" 
## [13] "FEMENINO"  "MASCULINO" "MASCULINO" "MASCULINO" "MASCULINO" "MASCULINO"
## [19] "FEMENINO"  "MASCULINO" "FEMENINO"  "FEMENINO"  "MASCULINO" "FEMENINO" 
## [25] "MASCULINO" "MASCULINO" "FEMENINO"  "FEMENINO"  "FEMENINO"  "FEMENINO" 
## [31] "MASCULINO" "FEMENINO"  "MASCULINO"

Por defecto, el software coloca los índices por orden alfabético. Por tal motivo, en los resultados anteriores colocaba a femenino el índice 1 y a masculino el índice 2. Pero si queremos cambiar el orden del indice, es decir, que el índice 2 sea para femenino y el índice 1 para masculino.

Para obtener estos resultados ejecutaríamos la siguiente sintaxis.

sexo2<-factor(sexo, levels = c("MASCULINO","FEMENINO"))

Lo que hemos realizado es colocar los niveles con el argumento levels, es así que como primer nivel hemos considerado a MASCULINO y como segundo nivel a FEMENINO. Al colocar los niveles en ese orden, el software asignará los indices en ese orden.

sexo2

##  [1] MASCULINO FEMENINO  FEMENINO  FEMENINO  MASCULINO FEMENINO  FEMENINO 
##  [8] FEMENINO  FEMENINO  FEMENINO  MASCULINO FEMENINO  FEMENINO  MASCULINO
## [15] MASCULINO MASCULINO MASCULINO MASCULINO FEMENINO  MASCULINO FEMENINO 
## [22] FEMENINO  MASCULINO FEMENINO  MASCULINO MASCULINO FEMENINO  FEMENINO 
## [29] FEMENINO  FEMENINO  MASCULINO FEMENINO  MASCULINO
## Levels: MASCULINO FEMENINO

En efecto, ahora el primer nivel es MASCULINO y el segundo es FEMENINO. También podemos observar con la función str().

str(sexo2)

##  Factor w/ 2 levels "MASCULINO","FEMENINO": 1 2 2 2 1 2 2 2 2 2 ...

Detalle importante a considerar en este punto es que no podemos cometer errores al escribir los niveles, si nosotros escribimos un nivel distinto al que está en nuestra variable, entonces, cometeremos un error y no estaremos considerando a esa categoría en el nivel esperado. Veamos un ejemplo, y observemos lo que sucede.

sexo3<-factor(sexo, levels = c("masculino","FEMENINO"))

Aquí podemos observar que en vez de colocar el nivel MASCULINO se ha colocado en minusculas masculino. Lo cual nos genera un error ya que al no encontrar el nivel masculino no podrá colocar el índice, y por ende, asiganará el valor de NA a cada observación que no tiene el nivel correcto. Observemos.

sexo3

##  [1] <NA>     FEMENINO FEMENINO FEMENINO <NA>     FEMENINO FEMENINO FEMENINO
##  [9] FEMENINO FEMENINO <NA>     FEMENINO FEMENINO <NA>     <NA>     <NA>    
## [17] <NA>     <NA>     FEMENINO <NA>     FEMENINO FEMENINO <NA>     FEMENINO
## [25] <NA>     <NA>     FEMENINO FEMENINO FEMENINO FEMENINO <NA>     FEMENINO
## [33] <NA>    
## Levels: masculino FEMENINO

En efecto, le asignó el valor de NA a todos los elementos que no encontró un nivel que se le asigno, en este caso, a todos los que son MASCULINO.

Entonces, aquí surge un cuestión ¿podemos cambiar los nombres de los niveles?, la respuesta es sí. Para realizar esto tenemos que usar el argumento labels. Veamos un ejemplo, en donde nuestros niveles estén en minúsculas.

sexo4<-factor(sexo, levels = c("MASCULINO", "FEMENINO"),
              labels = c("masculino", "femenino"))

Hemos hecho el mismo procedimiento que anteriormente, pero ahora estamos utilizando el argumento labels que son las etiquetas que se asignarán a cada nivel. Veamos el resultado.

sexo4

##  [1] masculino femenino  femenino  femenino  masculino femenino  femenino 
##  [8] femenino  femenino  femenino  masculino femenino  femenino  masculino
## [15] masculino masculino masculino masculino femenino  masculino femenino 
## [22] femenino  masculino femenino  masculino masculino femenino  femenino 
## [29] femenino  femenino  masculino femenino  masculino
## Levels: masculino femenino

Aquí lo fundamental, es el orden. Si nosotros consideramos primero a MASCULINO entonces su etiqueta debe de ser masculino, si nosotros hubiesemos considerado primero la etiqueta femenino en vez de masculino, se habría cambiado a todos los MASCULINOS por femenino. Por tal motivo, es fundamental el orden en el que se coloca los niveles y las etiquetas.

Otra cuestión que puede surgir es el no considerar a uno o más categorías. Para realizar esto vamos a usar el argumento exclude. Vamos a crear el vector x para desarrollar un nuevo ejemplo.

# Creando el vector x.
set.seed(2021)
x<-sample(c("A","B","C","D"), 30, T)
x

##  [1] "C" "B" "B" "B" "C" "D" "D" "B" "D" "B" "C" "B" "B" "A" "C" "C" "A" "C" "D"
## [20] "C" "D" "B" "C" "D" "A" "C" "B" "D" "B" "D"

Hemos creado el vector x que tiene 30 elementos, los cuales son las letras: A, B, C y D.

Entonces, si nosotros queremos convertir en factor a la variable x y no nos interesa el orden de los índices, entonces podemos correr la siguiente sintaxis.

factor(x)

##  [1] C B B B C D D B D B C B B A C C A C D C D B C D A C B D B D
## Levels: A B C D

Al no interesarnos el orden de los índices suficiente con colocar el vector x dentro de la función factor(). Como sabemos el software, asignará los índices en orden alfabético¹³.

El resultado que hemos obtenido es el esperado a asignado los niveles en orden alfabético es así que el primer índice es para A y el segundo para B, y así sucesivamente.

Pero si nosotros quisíeramos excluir al nivel B entonces usaríamos la siguiente sintaxis.

factor(x, exclude = "B")

##  [1] C    <NA> <NA> <NA> C    D    D    <NA> D    <NA> C    <NA> <NA> A    C   
## [16] C    A    C    D    C    D    <NA> C    D    A    C    <NA> D    <NA> D   
## Levels: A C D

Y en efecto, ya no estamos considerando al nivel B y asigna el valor de NA a todas los elementos que son B. Hasta ahora hemos visto ejemplos con factores en donde no es importante el orden de los niveles. Pero en la siguiente sección veremos a detalle como trabajar con niveles ordenados.

6.1.2 Factores con niveles ordenados.

En encuestas se suele preguntas sobre satisfacción, nivel de recomendación o percepción. En este tipo de preguntas el orden de los niveles tiene suma importancia, ya que no es lo mismo sentirse muy satisfecho con sentirse satisfecho. Entonces, si nosotros sabemos que los niveles de una variable se tienen que ordenar jerarqueicamente, tendremos que convertirlo a una variable factor ordenado. En R para conseguir esto, se puede usar la función ordered().

La función ordered() tiene los mismos argumentos que la función factor(), así que será sencillo su aplicación. Veamos un ejemplo en donde se tiene la satisfacción sobre el servicio de alcantarillado de un barrio.

# Creando la variable que representa la satisfacción 
# sobre el servicio de alcantarillado.
satis<-sample(c("MUY SATISFECHO","SATISFECHO","NEUTRAL",
                "INSATISFECHO","MUY SATISFECHO"), 30, T)
satis

##  [1] "MUY SATISFECHO" "SATISFECHO"     "NEUTRAL"        "INSATISFECHO"  
##  [5] "MUY SATISFECHO" "MUY SATISFECHO" "MUY SATISFECHO" "SATISFECHO"    
##  [9] "NEUTRAL"        "NEUTRAL"        "SATISFECHO"     "SATISFECHO"    
## [13] "MUY SATISFECHO" "NEUTRAL"        "SATISFECHO"     "MUY SATISFECHO"
## [17] "MUY SATISFECHO" "MUY SATISFECHO" "INSATISFECHO"   "INSATISFECHO"  
## [21] "NEUTRAL"        "NEUTRAL"        "SATISFECHO"     "MUY SATISFECHO"
## [25] "SATISFECHO"     "MUY SATISFECHO" "MUY SATISFECHO" "MUY SATISFECHO"
## [29] "MUY SATISFECHO" "MUY SATISFECHO"

Hemos creado el vector satis que contiene la satisfacción de 30 individuos sobre el servicio de alcantarillado de un barrio. La satisfacción tiene 5 niveles: muy satisfecho, satisfecho, neutral, insatisfecho, muy insatisfecho.

Nosotros tenemos que asignarle valores númericos a cada nivel, ya que en un futuro realizaremos análisis factorial con estas variable y otras. Entonces, si queremos asignarle valores y sabemos que tienen que tener un orden donde muy insatisfecho es el nivel más bajo y muy satisfecho el valor más alto. Tendremos que realizar la siguiente sintaxis.

# Convirtiendo en factor ordenado. 
satis1<-ordered(satis, levels=c("MUY INSATISFECHO","INSATISFECHO",
                                "NEUTRAL","SATISFECHO","MUY SATISFECHO"))
satis1

##  [1] MUY SATISFECHO SATISFECHO     NEUTRAL        INSATISFECHO   MUY SATISFECHO
##  [6] MUY SATISFECHO MUY SATISFECHO SATISFECHO     NEUTRAL        NEUTRAL       
## [11] SATISFECHO     SATISFECHO     MUY SATISFECHO NEUTRAL        SATISFECHO    
## [16] MUY SATISFECHO MUY SATISFECHO MUY SATISFECHO INSATISFECHO   INSATISFECHO  
## [21] NEUTRAL        NEUTRAL        SATISFECHO     MUY SATISFECHO SATISFECHO    
## [26] MUY SATISFECHO MUY SATISFECHO MUY SATISFECHO MUY SATISFECHO MUY SATISFECHO
## 5 Levels: MUY INSATISFECHO < INSATISFECHO < NEUTRAL < ... < MUY SATISFECHO

En efecto, hemos obtenido un factor donde los niveles están ordenados de menor a mayor. ¿Cómo se ha hecho? Al usar la función ordered() el primer argumento que se tiene que considerar es el vector que queremos ordenar (satis) y el segundo argumento son los niveles, pero los niveles tienen que estar en el orden que se desea, es decir, desde el que tendrá el valor más pequeño hasta el que tendrá el valor más grande, por eso los niveles empezó desde muy insatisfecho.

Este resultado también podemos obtenerlo con la función factor() siempre y cuando consideremos un argumento adicional, el cual es ordered = TRUE. Veamos como se haría lo mismo con la función factor().

# Obteniendo el mismo resultado con la función factor().
satis2<-factor(satis, levels = c("MUY INSATISFECHO","INSATISFECHO",
                                "NEUTRAL","SATISFECHO","MUY SATISFECHO"),
               ordered = T)
satis2

##  [1] MUY SATISFECHO SATISFECHO     NEUTRAL        INSATISFECHO   MUY SATISFECHO
##  [6] MUY SATISFECHO MUY SATISFECHO SATISFECHO     NEUTRAL        NEUTRAL       
## [11] SATISFECHO     SATISFECHO     MUY SATISFECHO NEUTRAL        SATISFECHO    
## [16] MUY SATISFECHO MUY SATISFECHO MUY SATISFECHO INSATISFECHO   INSATISFECHO  
## [21] NEUTRAL        NEUTRAL        SATISFECHO     MUY SATISFECHO SATISFECHO    
## [26] MUY SATISFECHO MUY SATISFECHO MUY SATISFECHO MUY SATISFECHO MUY SATISFECHO
## 5 Levels: MUY INSATISFECHO < INSATISFECHO < NEUTRAL < ... < MUY SATISFECHO

Como sabemos al asignarle un orden, los valores tendrán un orden. Lo que nos permitirá hacer futuros cálculos. Es asíq ue si lo queremos ver en números sólo tendríamos que aplicarle la función as.numeric() que convierte al factor en un vector numérico.

# Convirtiendo a numérico el factor ordenado. 
as.numeric(satis1)

##  [1] 5 4 3 2 5 5 5 4 3 3 4 4 5 3 4 5 5 5 2 2 3 3 4 5 4 5 5 5 5 5

En efecto, hemos obtenido los valores numéricos de cada categoría en donde se le asigna el valor de 1 al nivel más pequeño que es MUY INSATISFECHO y el valor de 5 al nivel MUY SATISFECHO.

6.2 Listas.

Uno de los objetos más importantes en R son las listas, las listas son capaces de almacenar a otros objetos, por ejemplo: vectores, matrices, factores, entre otros. La particularidad de las listas es que no permite que los objetos que contiene pierdan sus características. Es así que si yo tengo una lista de vectores y matrices, los vectores no perderán sus características y seguirán siendo vectores, lo mismo para las matrices.

Veamos un ejemplo en donde vamos a crear una lista que contenga 5 vectores.

# Creando los 5 vectores. 
x1<-c(1L,2L,5L,7L)
x2<-c("LUZ","OSCURIDAD","NIEBLA")
x3<-c(1.1,4.3,6.6,7.6)
x4<-c(1+4i,6i)
x5<-c(TRUE, FALSE,FALSE, TRUE)

Hemos creado 5 vectores: vector de enteros, de caracteres, númerico, complejo y lógico.

Si nosotros queremos tener todo en un mismo objeto, podríamos concatenarlo, pero al hacer eso se perdería la característica de cada vector, ya que lo convertiría en un vector character como se vio en el segundo capítulo.

x<-c(x1,x2,x3,x4,x5)

class(x)

## [1] "character"

Entonces, si no queremos que pierda sus características tendremos que integrarlo en una lista. Para crear una lista se usa la función list().

# Creando una lista que contenga a los 5 vectores. 
lista<-list(x1,x2,x3,x4,x5)

lista

## [[1]]
## [1] 1 2 5 7
## 
## [[2]]
## [1] "LUZ"       "OSCURIDAD" "NIEBLA"   
## 
## [[3]]
## [1] 1.1 4.3 6.6 7.6
## 
## [[4]]
## [1] 1+4i 0+6i
## 
## [[5]]
## [1]  TRUE FALSE FALSE  TRUE

La lista que acabamos de crear nos muestra los 5 vectores y cada uno no ha perdido sus características.

6.2.1 ¿Cómo se obtiene cada objeto de una lista?

Una vez que se ha creado la lista usted, puede tener la necesidad de usar uno o varios de los objetos, entonces, usted tiene que llamar a los objetos que contiene sus lista.

El procedimiento es similar al que se usa para llamar elementos de un vector, en esos casos se usaba los corchetes [], para el caso de listas se usa los doble corchetes [[]]. Por ejemplo si nosotros queremos llamar al primer vector de nuestra lista, entonces aplicaríamos la siguiente sintaxis.

# Llamando al primer objeto de nuestra lista. 
lista[[1]]

## [1] 1 2 5 7

en efecto al aplicar doble corchete a la lista y colocar dentro de ella el número 1, estamos llamando al primer objeto.

Como se mencionó anteriormente, al guardarlo en una lista no pierde sus características el vector, por lo cual el primero objeto de la lista es un vector integer.

# Viendo si se mantiene las características de los objetos. 
class(lista[[1]])

## [1] "integer"

En efecto, es de la clase integer.

Ahora, si queremos llamar al cuarto objeto, entonces, usaríamos la siguiente sintaxis.

# Llamando al cuarto objeto de la lista.
lista[[4]]

## [1] 1+4i 0+6i

6.2.2 Asignado nombres a los objetos de una lista.

Los objetos de una lista admiten nombres, por lo que se les puede asignar nombres y luego llamarlos por esos nombres. Con la función names() se obtiene o se les asigna nombres. Primero apliquemos la función names() a la lista que hemos creado con el fin de obtener los nombres de la lista, como sabemos que no tienen nombres nuestros objetos nos arrojará el valor de NULL.

# Obteniendo los nombres de nuestra lista. 
names(lista)

## NULL

En efecto, no arroja NULL. Lo que vamos hacer ahora es asignarle nombres. Los nombres serán las clases de cada vector.

# Asignando nombres a nuestra lista.
names(lista)<-c("entero","caracter","numerico","complejo","logico")

Veamos si nuestra lista ya tiene nombres.

names(lista)

## [1] "entero"   "caracter" "numerico" "complejo" "logico"

En efecto, ya tienen nombres, por lo cual ya podremos llamarlos por sus nombres. Por ejemplo, vamos a llamar al objeto llamado caracter, pero para llamarlo por sus nombres, ya no se necesitará usar el doble corchete [[]], sino el símbolo de dólar $.

# Llamando al objeto llamado caracter.
lista$caracter

## [1] "LUZ"       "OSCURIDAD" "NIEBLA"

El resultado, es el objeto que contiene elementos caracter. Entonces podemos llamar a los objetos de una lista de dos formas con el doble corchete [[]] cuando tenga o no tenga nombres nuestros objetos o con el $ siempre y cuando los objetos tengan nombres.

Como último ejemplo, veremos como llamar al segundo elemento del vector llamado entero de nuestra lista.

# Llamando al segundo elemento del vector entero de la lista.
lista$entero[2]

## [1] 2

# O también podemos llamarlo con:
lista[[1]][2]

## [1] 2

Al final obtenemos el mismo resultado.

En el siguiente capítulo se verá el tema de matrices, desde como crearlas hasta llamar elementos.

---

12. Podría dejar el directorio de trabajo en esa ruta, pero si quisiera importar el archivo que deseo tendría que especificar la ruta del archivo y eso me demoraría más tiempo, ya que tendría que escribir la ruta completa cada vez que deseo cargar un archivo.↩︎

13. En ejemplos posteriores se mostrará como importar archivos desde otra ruta.↩︎