chapter5.Rmd

--- 
title_meta  : Capítulo 5
title       : Data frames
description : La mayoría de los datos con los que trabajarás en R van a ser guardados en data frames. Al finalizar este capítulo vas a ser capaz de crear data frames, seleccionar partes del mismo y ordenar los datos que contiene de acuerdo a cierta variable.

--- type:NormalExercise xp:100 key:55a417e856
## ¿Que es un data frame?

Quizás recuerdes de nuestro capítulo sobre matrices que todos los elementos que ponemos en una matriz deben de ser del mismo tipo. Por ejemplo, cuando trabajamos con matrices los datos de Star Wars eran todos numéricos.

Cuando trabajamos con datos de por ejemplo, estudios de mercado, las preguntas son como las siguientes:

- '¿Es usted casado?' o preguntas de 'si/no' (datos de tipo lógico o booleano)
- 'Indique su edad' (variable numérica)
- '¿Cuál es su opinión sobre este producto?' u otras 'preguntas abiertas'  (variables de tipo caracter)
- ...

Las respuestas de los encuestados a las preguntas anteriores constituyen un conjunto de datos con diferentes tipos. La mayoría de veces que analizamos datos nos encontramos trabajando con conjuntos que tienen varios tipos.

Un data frame es una estructura de datos rectangular, que contiene las variables en las columnas y las observaciones en las filas. Piensa en un data frame como una hoja de MS Excel o quizás estas familiarizado con otros paquetes estadísticos como SAS o SPSS.

*** =instructions
Da clic a 'Submit Answer'. Los datos en el ejemplo que verás en la consola corresponden al conjunto de datos llamado [`mtcars`](http://www.rdocumentation.org/packages/datasets/functions/mtcars).

*** =hint
Solo da clic a 'Submit Answer' y observa la magia!

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
mtcars # conjunto de datos que viene con R
```

*** =solution
```{r eval=FALSE}
mtcars # conjunto de datos que viene con R
```

*** =sct
```{r eval=FALSE}
set_language("es")
test_output_contains("mtcars", incorrect_msg = "No cambies nada del código en el editor, el código muestra el conjunto <code>mtcars</code>.");
success_msg("Bien! vamos al siguiente ejercicio")
```

*** =skills
1

--- type:NormalExercise xp:100 key:b1c40a20ff
## Una rápida mirada a nuestros datos

Vaya! que montón de carros!

Trabajar con conjuntos de datos grandes es muy común en análisis de datos. Cuando este es el caso, tu primera tarea como analista de datos es desarrollar un entendimiento claro de la estructura de sus elementos. Frecuentemente, el primer paso para lograr esto es mostrar solo una pequeña parte del conjunto de datos.

¿Cómo lo hacemos? muy fácil! utilizamos la función [`head()`](http://www.rdocumentation.org/packages/utils/functions/head) que nos permite solo ver las primeras observaciones de un data frame (o algún otro objeto de R). Por otro lado, la función [`tail()`](http://www.rdocumentation.org/packages/utils/functions/head) nos permite ver las ultimas observaciones del data frame.

Ambas funciones [`head()`](http://www.rdocumentation.org/packages/utils/functions/head) y [`tail()`](http://www.rdocumentation.org/packages/utils/functions/head) imprimen una primera línea de encabezados o 'header' la cual contiene los nombres de las variables en el conjunto de datos.

*** =instructions
Echa una primera mirada a [`mtcars`](http://www.rdocumentation.org/packages/datasets/functions/mtcars) imprimiendo las primeras observaciones de este data frame.

*** =hint
Usa la función [`head()`](http://www.rdocumentation.org/packages/utils/functions/head) con el argumento [`mtcars`](http://www.rdocumentation.org/packages/datasets/functions/mtcars).

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Echa un vistazo a los datos

```

*** =solution
```{r eval=FALSE}
# Echa un vistazo a los datos
head(mtcars)
```

*** =sct
```{r eval=FALSE}
set_language("es")
test_function("head", "x", incorrect_msg = "¿Usaste el par&#224;metro correcto en la funci&#243;n <code>head()</code>? Aseg&#250;rate de pasar el data frame que deseas examinar, <code>mtcars</code> en este caso.")
test_output_contains("head(mtcars)", incorrect_msg = "Aseg&#250;rate de usar <code>head()</code> con el argumento <code>mtcars</code>.")
success_msg("Excelente! Bueno... ¿Que tenemos en este conjunto de datos?, Por ejemplo, <code>hp</code> representa los caballos de fuerza del carro (horsepower); el Datsun tiene la menor cantidad de caballos de fuerza de los 6 carros mostrados. Para una informaci&#243;n completa de las variables escribe <code>?mtcars</code> en la consola y lee la p&#224;gina de ayuda. Vamos al siguiente ejercicio!");
```

*** =skills
1

--- type:NormalExercise xp:100 key:80ca5dcd87
## Veamos la estructura

Otro método frecuentemente usado para echar un vistazo rápido a los datos es la función [`str()`](http://www.rdocumentation.org/packages/utils/functions/str). Esta función muestra la estructura de un data frame (u otro objeto de R). En este caso, el comando `str(mtcars)` muestra:

- El número total de observaciones (32 tipos de carros)
- El número total de variables (11 características de los carros)
- Una lista completa de las variables (e.g. mpg, cyl ... )
- El tipo de dato de cada variable (e.g. num for car features)
- Las primeras observaciones

Aplicar la función [`str()`](http://www.rdocumentation.org/packages/utils/functions/str) será lo primero que hagas cuando recibas un nuevo conjunto de datos. Es una excelente manera de conocer los datos antes de comenzar cualquier análisis.

*** =instructions
Investiga la estructura de [`mtcars`](http://www.rdocumentation.org/packages/datasets/functions/mtcars). Asegúrate de ver la misma información que mencionamos arriba (números, variables, etc.).

*** =hint
Usa la función [`str()`](http://www.rdocumentation.org/packages/utils/functions/str) con [`mtcars`](http://www.rdocumentation.org/packages/datasets/functions/mtcars) como argumento.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Para empezar, echa un vistazo a la estructura de mtcars 
```

*** =solution
```{r eval=FALSE}
# Para empezar, echa un vistazo a la estructura de mtcars 
str(mtcars)
```

*** =sct
```{r eval=FALSE}
set_language("es")
test_function("str","object",incorrect_msg = "Aseg&#250;rate de ver la estructura del data frame <code>mtcars</code>.")
test_output_contains("str(mtcars)", incorrect_msg = "Usa la funci&#243;n <code>str()</code> con el argumento <code>mtcars</code>.")
success_msg("Buen trabajo! ¿Pudiste ver toda la informaci&#243;n de la que hablamos? Bien, vamos al siguiente ejercicio.")
```

*** =skills
1

--- type:NormalExercise xp:100 key:5183cbfdc6
## Creando un data frame

Debido a que estamos usando conjuntos de datos que vienen con R, nos estamos perdiendo de más de la mitad de la diversión de crear nuestros propios data frames, el resto del capítulo está basado en tu propio conjunto de datos. ¿Qué tal si exploramos el espacio?

Como primer objetivo, queremos construir un data frame que describa las características de los ocho planetas del sistema solar. Según un buen amigo llamado Buzz Aldrin, las características principales de un planeta son:

- Tipo de planeta (terrestre o gigante gaseoso).
- Diámetro del planeta relativo al diámetro de la Tierra.
- La rotación del planeta del planeta a través del sol relativo a la Tierra.
- Si el planeta tiene anillos: Verdadero/Falso (TRUE/FALSE).

Después de hacer una investigación de primera clase en [Wikipedia](http://en.wikipedia.org/wiki/Planet), ya estás listo para crear los siguientes vectores: `planetas`, `tipo`, `diametro`, `rotacion` y `anillos` (mira el editor, date cuenta que los elementos de cada vector están relacionados a los demás por medio de la posición).

Un data frame se construye con la función [`data.frame()`](http://www.rdocumentation.org/packages/base/functions/data.frame). Como argumentos, debes dar los vectores mencionados arriba y éstos se convertirán en las diferentes columnas (variables) del data frame, por lo tanto, es muy importante que cada vector tenga el mismo tamaño. Pero no olvides que lo más probable que los vectores contengan tipos diferentes de datos.

*** =instructions
Usa la función [`data.frame()`](http://www.rdocumentation.org/packages/base/functions/data.frame) para construir un data frame llamado `planetas_df`.

*** =hint
La función `data.frame(col1, col2, col3,...)` toma como argumentos los vectores que se convertirán en las columnas del data frame. Las columnas son en este caso, (en este orden): `planeta`, `tipo`, `diametro`, `rotacion` and `anillos`.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
planetas <- c("Mercurio", "Venus", "Tierra", "Marte", "Jupiter", "Saturno", "Urano", "Neptuno");
tipo <- c("Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso")
diametro <- c(0.382, 0.949, 1, 0.532, 11.209, 9.449, 4.007, 3.883); 
rotacion <- c(58.64, -243.02, 1, 1.03, 0.41, 0.43, -0.72, 0.67);
anillos <- c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE);

# Crea el data frame:
planetas_df  <-

```

*** =solution
```{r eval=FALSE}
planetas <- c("Mercurio", "Venus", "Tierra", "Marte", "Jupiter", "Saturno", "Urano", "Neptuno");
tipo <- c("Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso")
diametro <- c(0.382, 0.949, 1, 0.532, 11.209, 9.449, 4.007, 3.883); 
rotacion <- c(58.64, -243.02, 1, 1.03, 0.41, 0.43, -0.72, 0.67);
anillos <- c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE);

# Crea el data frame:

planetas_df   <- data.frame(planetas, tipo, diametro, rotacion, anillos)

```

*** =sct
```{r eval=FALSE}
set_language("es")
test_correct({
  test_object("planetas_df",
              undefined_msg = "¿Creaste la variable <code>planetas_df</code>?",
              incorrect_msg = "Aseg&#250;rate de poner en orden correcto a los elementos al crear el data frame <code>planetas_df</code>. El orden correcto es planetas, tipo, diametro, rotacion y anillos.")  
}, {
  msg = "No cambies el c&#243;digo que define a los vectores! Solo a&#241;ade el c&#243;digo para crear el data frame <code>planetas_df</code>."
  test_object("planetas", undefined_msg = msg, incorrect_msg = msg)
  test_object("tipo", undefined_msg = msg, incorrect_msg = msg)
  test_object("diametro", undefined_msg = msg, incorrect_msg = msg)
  test_object("rotacion", undefined_msg = msg, incorrect_msg = msg)
  test_object("anillos", undefined_msg = msg, incorrect_msg = msg)
})

success_msg("Excelente! Continuemos al siguiente ejercicio. El siguiente paso l&#243;gico es dar una inspecci&#243;n r&#224;pida al data frame que acabamos de crear. Hag&#224;moslo!");
```

*** =skills
1

--- type:NormalExercise xp:100 key:e606aa210b
## Creando un data frame (2)

Asegúrate que tienes 8 observaciones y 5 variables. El data frame `planetas_df` está en tu espacio de trabajo (workspace) y ahora lo puedes explorar.

*** =instructions
Usa la función [`str()`](http://www.rdocumentation.org/packages/utils/functions/str) para investigar la estructura de data frame `planetas_df`.

*** =hint
Este ejercicio es muy fácil, nada de pistas!

*** =pre_exercise_code
```{r eval=FALSE}
# no pec

planetas <- c("Mercurio", "Venus", "Tierra", "Marte", "Jupiter", "Saturno", "Urano", "Neptuno");
tipo <- c("Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso")
diametro <- c(0.382, 0.949, 1, 0.532, 11.209, 9.449, 4.007, 3.883); 
rotacion <- c(58.64, -243.02, 1, 1.03, 0.41, 0.43, -0.72, 0.67);
anillos <- c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE);
planetas_df   <- data.frame(planetas, tipo, diametro, rotacion, anillos)
```

*** =sample_code
```{r eval=FALSE}
# Da un vistazo a la estructura de planetas_df
```

*** =solution
```{r eval=FALSE}
# Da un vistazo a la estructura de planetas_df
str(planetas_df)
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No borres o modifiques el data frame <code>planetas_df</code>!"
test_object("planetas_df", undefined_msg = msg, incorrect_msg = msg)
test_function("str", "object", incorrect_msg = "Usa la funci&#243;n <code>str()</code> en el data frame <code>planetas_df</code>.")
success_msg("Bien! Ahora que ya tenemos un entendimiento de nuestros datos es hora de que seleccionemos elementos de nuestro data frame. Esto hacemos en el siguiente ejercicio!")
```

*** =skills
1

--- type:NormalExercise xp:100 key:a89fcaf9ac
## Selección de elementos

De manera similar a los vectores y matrices, seleccionamos elementos de un data frame con los corchetes `[ ]`. Usando una coma, separamos los índices que deseamos seleccionar de las filas y las columnas respectivamente. Por ejemplo:

- `mi_data_frame[1,2]` selecciona el elemento ubicado en la primera fila y segunda columna del data frame `mi_data_frame`.
- `mi_data_frame[1:3,2:4]` selecciona los elementos ubicados en las filas 1,2,3 y columnas 2,3,4 de `mi_data_frame`.

A veces queremos seleccionar todos los elementos de una fila o de una columna. Para hacer esto dejamos en blanco el espacio de la fila o la columna: por ejemplo `mi_data_frame[1,]` selecciona todos los elementos de la primera fila (primera fila y todas las columnas). Apliquemos estas técnicas en `planetas_df`!

*** =instructions
- Crea el data frame ` planetas_cercanos_df ` que contenga todos las datos de los primeros tres planetas.
- Crea el data frame `planetas_lejanos_df` que contenga todos los datos de los últimos tres planetas.

*** =hint
`planetas_df[1:3,]` seleccionará las primeras tres filas.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec

planetas <- c("Mercurio", "Venus", "Tierra", "Marte", "Jupiter", "Saturno", "Urano", "Neptuno");
tipo <- c("Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso")
diametro <- c(0.382, 0.949, 1, 0.532, 11.209, 9.449, 4.007, 3.883); 
rotacion <- c(58.64, -243.02, 1, 1.03, 0.41, 0.43, -0.72, 0.67);
anillos <- c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE);
planetas_df   <- data.frame(planetas, tipo, diametro, rotacion, anillos)
```

*** =sample_code
```{r eval=FALSE}
# El data frame planetas_df de los ejercicios previos está en tu workspace, lo puedes usar

# Selecciona todos los datos de los primeros tres planetas
planetas_cercanos_df <- 

# Selecciona todos los datos de los últimos tres planetas
planetas_lejanos_df <- 

# Observemos los datos:
closest_planets_df
furthest_planets_df
```

*** =solution
```{r eval=FALSE}
# El data frame planetas_df de los ejercicios previos está en tu workspace, lo puedes usar

# Selecciona todos los datos de los primeros tres planetas
planetas_cercanos_df <- planetas_df[1:3, ]

# Selecciona todos los datos de los últimos tres planetas
planetas_lejanos_df <- planetas_df[6:8, ]

# Observemos los datos:
planetas_cercanos_df
planetas_lejanos_df
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No borres o cambies el data fame <code>planetas_df</code>!"
test_object("planetas_df", undefined_msg = msg, incorrect_msg = msg)
test_object("planetas_cercanos_df",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>planetas_cercanos_df</code>.",
            incorrect_msg = "¿Seleccionaste las primeras tres filas de <code>planetas_df</code>?")
test_object("planetas_lejanos_df",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>planetas_lejanos_df</code>.",
            incorrect_msg = "¿Seleccionaste las &#250;ltimas tres filas de <code>planetas_df</code>?")
success_msg("Muy bien! Adem&#224;s de poder seleccionar las columnas de un data frame por n&#250;meros tambi&#233;n los puedes seleccionar los nombres de las columnas. Para aprender c&#243;mo vamos al siguiente ejercicio.")
```

*** =skills
1

--- type:NormalExercise xp:100 key:f34f617752
## Selección de elementos (2)

En lugar de usar los índices de las columnas para seleccionar elementos de un data frame también puedes usar los nombres de las columnas para seleccionar datos.

Supongamos que necesitas los primeros 3 elementos de la variable 'tipo'. Una manera de hacerlo es: `planetas_df[1:3,1]`. Una desventaja de este método es que tienes que saber la posición de la variable 'tipo'. Cuanto tienes pocas variables como en este caso, es fácil saber la posición de cada una, pero cuando tienes muchas variables se vuelve complicado. A veces es más fácil solo usar el nombre de la variable por ejemplo `planetas_df[1:3,"tipo"]`

*** =instructions
Selecciona las últimas seis filas de la variable `diametro` y asigna esta selección a la variable `diametros_planetas_lejanos`.

*** =hint
Selecciona las filas de la 3 a la 8 usando `3:8` y usa `"diametro"` para seleccionar la columna. Recuerda la notación de `[,]`.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec

planetas <- c("Mercurio", "Venus", "Tierra", "Marte", "Jupiter", "Saturno", "Urano", "Neptuno");
tipo <- c("Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso")
diametro <- c(0.382, 0.949, 1, 0.532, 11.209, 9.449, 4.007, 3.883); 
rotacion <- c(58.64, -243.02, 1, 1.03, 0.41, 0.43, -0.72, 0.67);
anillos <- c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE);
planetas_df   <- data.frame(planetas, tipo, diametro, rotacion, anillos)
```

*** =sample_code
```{r eval=FALSE}
# El data frame planetas_df de los ejercicios anteriores ha sido cargado en tu espacio de trabajo

# Selecciona el diámetro de los 6 planetas más lejanos
diametros_planetas_lejanos <- 
```

*** =solution
```{r eval=FALSE}
# El data frame planetas_df de los ejercicios anteriores ha sido cargado en tu espacio de trabajo

# Selecciona el diámetro de los 6 planetas más lejanos
diametros_planetas_lejanos <- planetas_df[3:8,"diametro"]
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No cambies o modifiques el data frame <code>planetas_df</code>."
test_object("planetas_df", undefined_msg = msg, incorrect_msg = msg)
test_object("diametros_planetas_lejanos",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>diametros_planetas_lejanos</code>.",
            incorrect_msg = "¿Escogiste las &#250;ltimas 6 filas de la columna <code>diametro</code>?")
success_msg("Excelente! vamos al siguiente ejercicio!")
```

*** =skills
1

--- type:NormalExercise xp:100 key:60adb8f4e8
## Solamente planetas con anillos

Frecuentemente vas a querer seleccionar una columna entera, es decir, una variable específica de un data frame. Por ejemplo si quieres seleccionar todos los elementos de la variable `anillos` ambas notaciones servirán: `planetas_df[,5]` ó `planetas_df[,"anillos"]`.

Sin embargo, existe otra manera de hacerlo, puedes usar el signo `$` para pedirle a R que extraiga una variable de un data frame de la siguiente manera:

```
data_frame$variable
```

*** =instructions
- Utiliza el signo `$` para crear la variable `vector_anillos` que contiene todos los elementos de la variable `anillos` del data frame `planetas_df`.

*** =hint
`data_frame$variable` es la manera más conveniente de seleccionar una variable de un data frame. En este caso estamos usando el data frame `planetas_df` y la variable `anillos`.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec

planetas <- c("Mercurio", "Venus", "Tierra", "Marte", "Jupiter", "Saturno", "Urano", "Neptuno");
tipo <- c("Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso")
diametro <- c(0.382, 0.949, 1, 0.532, 11.209, 9.449, 4.007, 3.883); 
rotacion <- c(58.64, -243.02, 1, 1.03, 0.41, 0.43, -0.72, 0.67);
anillos <- c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE);
planetas_df   <- data.frame(planetas, tipo, diametro, rotacion, anillos)
```

*** =sample_code
```{r eval=FALSE}
# El data frame planetas_df de los ejercicios anteriores ha sido cargado en tu espacio de trabajo

# Crea el vector_anillos
vector_anillos <- 
```

*** =solution
```{r eval=FALSE}
# El data frame planetas_df de los ejercicios anteriores ha sido cargado en tu espacio de trabajo

# Crea el vector_anillos
vector_anillos <- planetas_df$anillos
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No cambies o modifiques el data frame <code>planetas_df</code>."
test_object("planetas_df", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_anillos",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>vector_anillos</code>.",
            incorrect_msg = "Parece que <code>vector_anillos</code> no contiene todos los elementos de la variable <code>anillos</code> del data frame <code>planetas_df</code>.")
success_msg("Excelente! Vamos al siguiente ejercicio para descubrir otra manera importante de seleccionar elementos de un data frame")
```

*** =skills
1

--- type:NormalExercise xp:100 key:edc0f93d4c
## Solamente planetas con anillos (2)

Quizás recuerdes de la secundaria que algunos planetas del sistema solar tienen anillos y otros no. Pero debido a tus prioridades de esa época (¿recuerdas la pubertad?) no puedes recordar los nombres de los planetas con anillos, mucho menos su rotación, velocidad, etc...

¿Es posible que R pueda ayudarnos? (por supuesto que puede!)

Si escribes `vector_anillos` en la consola obtendrás:

```
[1] FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE
```

Esto significa que las primeras cuatro observaciones (o planetas) no tienen anillos (por eso leemos `FALSE`), pero los otros cuatro sí tienen (`TRUE`). Sin embargo no tenemos los nombres de los planetas, su diámetro, etc. Como siguiente paso, usa `vector_anillos` para seleccionar todos las variables (es decir, todas las columnas) de los cuatro planetas con anillos de `planetas_df`.

Puedes utilizar un vector con valores lógicos para seleccionar elementos de un data frame, por ejemplo `datos[vector_logico, 1]` seleccionará la primera columna del data frame `datos` y las filas para las cuales `vector_logico` tenga elementos verdaderos. 

*** =instructions
Asigna a `planetas_con_anillos_df` todos los datos del data frame `planetas_df` de aquellos planetas que tienen anillos, es decir aquellos donde `vector_anillos` es igual a `TRUE`.

*** =hint
Selecciona elementos de `planetas_df` usando los corchetes `[]`. El vector  `vector_anillos` contiene los valores lógicos y R seleccionará solamente aquellas filas en donde los elementos sean verdaderos (`TRUE`). Además quieres todas las columnas.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec

planetas <- c("Mercurio", "Venus", "Tierra", "Marte", "Jupiter", "Saturno", "Urano", "Neptuno");
tipo <- c("Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso")
diametro <- c(0.382, 0.949, 1, 0.532, 11.209, 9.449, 4.007, 3.883); 
rotacion <- c(58.64, -243.02, 1, 1.03, 0.41, 0.43, -0.72, 0.67);
anillos <- c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE);
planetas_df   <- data.frame(planetas, tipo, diametro, rotacion, anillos)
vector_anillos <- planetas_df$anillos
```

*** =sample_code
```{r eval=FALSE}
# El data frame planetas_df de los ejercicios anteriores ha sido cargado en tu espacio de trabajo, también puedes usar el vector_anillos

# Selecciona la información de los planetas con anillos:
planetas_con_anillos_df <- 
```

*** =solution
```{r eval=FALSE}
# El data frame planetas_df de los ejercicios anteriores ha sido cargado en tu espacio de trabajo, también puedes usar el vector_anillos

# Selecciona la información de los planetas con anillos:
planetas_con_anillos_df <- planetas_df[vector_anillos,]
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No borres o modifiques <code>planetas_df</code> o <code>vector_anillos</code>!"
test_object("planetas_df", undefined_msg = msg, incorrect_msg = msg)
test_object("vector_anillos", undefined_msg = msg, incorrect_msg = msg)
test_object("planetas_con_anillos_df",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>planetas_con_anillos_df</code>.",
            incorrect_msg = "Parece que <code>planetas_con_anillos_df</code> no tiene todos los datos de los planetas con anillos.");
success_msg("Grandioso! Aunque a decir verdad esto fue una soluci&#243;n un poco tediosa, en el siguiente ejercicio veremos una manera m&#224;s concisa de hacerlo.")
```

*** =skills
1

--- type:NormalExercise xp:100 key:0d223f169a
## Solamente planetas con anillos, pero más eficiente

¿Que fue exactamente lo que hicimos en los ejercicios anteriores? Básicamente seleccionamos un subconjunto del data frame `planetas_df` basándonos en que cierta condición fuera verdadera (tiene o no tiene anillos). En el ejercicio pasado pudimos obtener esa información, quizás ya estés listo para trabajar en la NASA ;-).

Ahora vamos al siguiente nivel usando la función [`subset()`](http://www.rdocumentation.org/packages/base/functions/subset). Básicamente la función  `subset()` hace lo mismo que hicimos en los ejercicios anteriores, de la siguiente manera: 

```
subset(mi_data_frame, subset = alguna_condicion)
``` 

El primer argumento de [`subset()`](http://www.rdocumentation.org/packages/base/functions/subset) especifica los datos de los cuales queremos el subconjunto. En el siguiente argumento especificamos la condición que deseamos que tenga nuestro subconjunto. 

Por ejemplo: 
```
subset(planetas_df, subset = planetas_df$anillos == TRUE)
``` 
Te dará el mismo resultado del ejercicio anterior pero sin la necesidad de usar `vector_anillos`.

*** =instructions
Crea un data frame llamado `planetas_pequenos_df` que contenga los datos de los planetas que tengan un diámetro menor al de la Tierra. (Menor que 1 porque los diámetros están dados relativos al de la Tierra.) 

*** =hint
Lo siento, tendrás que resolver este ejercicio tú sólo.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec

planetas <- c("Mercurio", "Venus", "Tierra", "Marte", "Jupiter", "Saturno", "Urano", "Neptuno");
tipo <- c("Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso")
diametro <- c(0.382, 0.949, 1, 0.532, 11.209, 9.449, 4.007, 3.883); 
rotacion <- c(58.64, -243.02, 1, 1.03, 0.41, 0.43, -0.72, 0.67);
anillos <- c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE);
planetas_df   <- data.frame(planetas, tipo, diametro, rotacion, anillos)
```

*** =sample_code
```{r eval=FALSE}
# planetas_df está cargado en tu espacio de trabajo

# Datos de los planetas más pequeños que la tierra:
planetas_pequenos_df  <- 
```

*** =solution
```{r eval=FALSE}
# planetas_df está cargado en tu espacio de trabajo

# Datos de los planetas más pequeños que la tierra:
planetas_pequenos_df  <- subset(planetas_df, subset = planetas_df$diametro < 1)
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No borres o cambies el data frame <code>planetas_df</code>!"
test_object("planetas_df", undefined_msg = msg, incorrect_msg = msg)
test_object("planetas_pequenos_df",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>planetas_pequenos_df</code>.",
            incorrect_msg = "Parece que el data frame <code>planetas_pequenos_df</code> no tiene todos los datos necesarios de planetas_df.");
success_msg("Muy bien! El c&#243;digo que usamos ahora con la función <code>subset()</code> es m&#224;s conciso, adem&#224;s quiz&#224;s sea m&#224;s entendible para la gente que lea tu c&#243;digo. Vamos al siguiente ejercicio.");
```

*** =skills
1

--- type:NormalExercise xp:100 key:ccde2e8c73
## Ordenando

Hacer rankings es uno de los pasatiempos favoritos de la humanidad. Estos rankings pueden ser útiles (países menos violentos en el mundo), entretenidos (estrellas de cine más influyentes) o sin sentido (las mujeres más parecidas a Lady Gaga). Cualquiera sea el propósito de tu ranking, R te puede ayudar.

Cuando analizas datos puedes ordenarlos de acuerdo a los valores de cierta variable en tu conjunto de datos. En R, esto se hace con la función [`order()`](http://www.rdocumentation.org/packages/base/functions/order). 

[`order()`](http://www.rdocumentation.org/packages/base/functions/order) te devuelve la **posición** del ranking de cada elemento. Esto es un poco complicado de comprender al principio, veamos un ejemplo: definamos el vector `a`: `a <- c(100, 15, 200, 9)`.

```
order(a)
``` 

regresa el vector (4, 2, 1, 3) que es un vector de posiciones, el cual nos dice lo siguiente: el elemento más pequeño de `a` (9) está en la posición 4, el segundo elemento más pequeño (15) se encuentra en la posición dos, el tercer elemento más pequeño (100) se encuentra en la posición 1 y el elemento más grande se encuentra en la posición 3. Como consecuencia de esto, el código:
    
```
a[order(a)]
``` 
nos devolverá el vector `a` ordenado, es decir (9, 15, 100, 200), porque el vector de índices `order(a) = c(4, 2, 1, 3)` primero extrae el cuarto elemento (9) que es el más pequeño, luego el segundo más pequeño (15), luego... esperamos que ahora este claro. Usa la consola para experimentar con la función [`order()`](http://www.rdocumentation.org/packages/base/functions/order).

*** =instructions
Experimenta con la función [`order()`](http://www.rdocumentation.org/packages/base/functions/order) en la consola. Crea tus propios vectores y usa la función `order()` para ordenarla. Da click en 'Submit Answer' cuando estés listo para continuar.

*** =hint
Sólo juega con la función [`order()`](http://www.rdocumentation.org/packages/base/functions/order) en la consola.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec
```

*** =sample_code
```{r eval=FALSE}
# Experimenta con la función order() creando tus propios vectores para ver cómo funciona!
```

*** =solution
```{r eval=FALSE}
# Experimenta con la función order() creando tus propios vectores para ver cómo funciona!
# Agunos ejemplos:
order(1:10)
order(2:11)
order(c(50,4,61,75))
```

*** =sct
```{r eval=FALSE}
set_language("es")
success_msg("Bien! ahora usemos la función <code>order()</code> para ordenar nuestro data frame!")
```

*** =skills
1

--- type:NormalExercise xp:100 key:a8bdfa4dae
## Ordenando un data frame

Ok, ahora que entendemos cómo funciona [`order()`](http://www.rdocumentation.org/packages/base/functions/order) hagamos algo útil con ella. Qué tal si ordenamos nuestros datos empezando por el planeta más grande, o sea ordenemos usando la columna `diametro`.

*** =instructions
- Asigna a la variable `posiciones` el orden deseado para el data frame que vamos a crear en el siguiente paso. Usa la función [`order()`](http://www.rdocumentation.org/packages/base/functions/order) para eso, usa el argumento `decreasing = TRUE`.
- Crea un nuevo data frame llamado `planetas_por_tamano`, el cual contiene la misma información que `planetas_df`, pero con los planetas ordenados por tamaño del más grande al más pequeño.

*** =hint
```
order(planetas_df$diametro, decreasing = TRUE)
``` 
Te dará el vector de posiciones de los planetas acuerdo con la variable `diametro` del más grande al más pequeño. Usa este vector para seleccionar las filas del data frame `planetas_df`.

*** =pre_exercise_code
```{r eval=FALSE}
# no pec

planetas <- c("Mercurio", "Venus", "Tierra", "Marte", "Jupiter", "Saturno", "Urano", "Neptuno");
tipo <- c("Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Planeta Terrestre", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso", "Gigante Gaseoso")
diametro <- c(0.382, 0.949, 1, 0.532, 11.209, 9.449, 4.007, 3.883); 
rotacion <- c(58.64, -243.02, 1, 1.03, 0.41, 0.43, -0.72, 0.67);
anillos <- c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE);
planetas_df   <- data.frame(planetas, tipo, diametro, rotacion, anillos)
```

*** =sample_code
```{r eval=FALSE}
# planetas_df está cargado en tu espacio de trabajo.

# Genera el vector de posiciones basándote en la variable planetas_df$diametro
posiciones <-  

# Crea el data frame ordenado:
planetas_por_tamano <- 
```

*** =solution
```{r eval=FALSE}
# planetas_df esta cargado en tu espacio de trabajo.

# Genera el vector de posiciones basándote en la variable planetas_df$diametro
posiciones <- order(planetas_df$diametro, decreasing = TRUE)

# Crea el data frame ordenado:
planetas_por_tamano <- planetas_df[posiciones, ]
```

*** =sct
```{r eval=FALSE}
set_language("es")
msg = "No borres o cambies el data frame <code>planetas_df</code>."
test_object("planetas_df", undefined_msg = msg, incorrect_msg = msg)
test_object("posiciones",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>posiciones</code>.",
            incorrect_msg = "Parece que el vector <code>posiciones</code> no contiene las posiciones correctas.")
test_object("planetas_por_tamano",
            undefined_msg = "Aseg&#250;rate de definir la variable <code>planetas_por_tamano</code>.",
            incorrect_msg = "Parece que <code>planetas_por_tamano</code> no contiene los datos ornedados de <code>planetas_df</code>.")
success_msg("Muy bien! ¿C&#243;mo se ve el data frame resultante? Escribe <code>planetas_por_tamano</code> para poder verlo! Este ejercicio concluye nuestro cap&#237;tulo sobre data frames. Recuerda que los data frames son extremadamente importantes en R, los necesitar&#224;s casi siempre que analices datos. Otra estructura muy com&#250;n e importante son las listas, el tema de nuestro pr&#243;ximo cap&#237;tulo!")
```

*** =skills
1