--- title: "[completar]" author: "[completar]" date: '[completar]' output: [completar] --- # Pasos previos: instalación Como recordatorio, indique aquí la dirección web de donde descargó R: ``` yaml ``` Y la dirección web desde donde descargó RStudio: ``` yaml ``` # Trabajando en un Rmd Ahora, procure dar un encabezado a este documento que contenga los siguientes elementos: ``` yaml --- title: "Apunte Sesión 1" author: "Su nombre" date: "La fecha de hoy" --- ``` Recuerde que este encabezado debe delimitarse por 3 guiones (`---`) antes de comenzar y otros 3 guiones después de terminar. Además, al final de este encabezado deberá escoger uno de los siguientes formatos para la emisión de un documento: - `output: html_document` - `output: word_document` - `output: powerpoint_document` Guarde su .Rmd apretando `File/Save As/` o bien, el botón con forma de "disquete" (💾) en la barra superior. También puede usar el atajo de teclado **Ctrl+S**. Haga la prueba de funcionamiento en este momento apretando el botón "**Knit**" en el menú superior. Si se genera un documento en el formato indicado (html, word o powerpoint), el documento está correctamente configurado. Si no se genera, hay algún error. Intente identificarlo usando la información que aparezca en la consola o el terminal, o pida asistencia a sus compañeres, ayudantes o profesores. Ahora que sabemos que podemos generar el documento que nos interesa, podemos continuar. A continuación, inserte un *chunk* de código. Puede hacerlo con el botón verde "^**+**^**c**" seguido por "**R**" en el menú superior, o bien, con el atajo de teclado **Alt+Ctrl+I** ```{r} ``` Fíjese que este *chunk* también tiene una estructura: Cuando trabajamos en vista *Source*, se inicia y cierra con 3 acentos graves (**```` ``` ````**). Además, seguido de los 3 acentos de apertura se encuentran paréntesis de llave abiertos y cerrado (`{ }`) que en su interior contienen a la letra "`r`". Esto indica que dentro del *chunk* de código usted podrá escribir en lenguaje R y que tanto en RStudio como en el documento generado, R leerá las instrucciones escritas en código y entregará una salida o resultado a partir de ellas. Veamos un ejemplo sencillo: Inserte un *chunk* de código de R y en su interior escriba la suma "*2 + 3*" (sin comillas): [**[inserte el chunk acá]**]{.underline} Para poder ejecutar esta instrucción, puede presionar el botón "**play**" en la esquina superior derecha del *chunk*, o bien, el atajo de teclado **Ctrl+Enter**. Ejecute la instrucción. Si aparece debajo del *chunk* una línea que indica `[1] 5` significa que hemos dado a R las instrucciones de la forma correcta. Si no ocurre esto, pida ayuda antes de continuar. Ahora que sabemos que la instrucción está correctamente escrita y su ejecución funciona, vuelva a compilar el documento apretando "**Knit**" para visualizar cómo se presenta este resultado en el producto final. Podemos observar que el código queda intercalado con el texto en el documento final, en el mismo orden en que aparece en este *script*. De esta forma, continuaremos. # Algunas funciones básicas de R ***¿Qué es una función?*** En R, una **función** es un objeto, y como tal tiene un nombre y un contenido. El contenido de un objeto puede ser, entre otros, un conjunto de datos, una constante numérica, o un conjunto de instrucciones escritas en código. Las funciones en R corresponden a este último caso. Para aplicar o llamar a una función, debemos ejecutar el nombre de la función seguido por un par de paréntesis **`( )`** dentro de los cuales indicamos los argumentos de la función. Los **argumentos de una función** son instrucciones adicionales que debe o puede recibir para funcionar, dependiendo de si tales entradas son obligatorias u optativas, respectivamente. Los argumentos tienen nombres y reciben objetos, los cuales serán de distinto tipo dependiendo de lo requerido por la función. Aunque algunas funciones pueden funcionar sin argumentos, la mayoría de las utilizadas para analizar datos tienen un argumento, por lo general el primero, que sirve para indicar cuál es el conjunto de datos al que se le desea aplicar la función. ## Carga del conjunto de datos La primera función que utilizaremos será aquella que dará a R la instrucción de cargar un conjunto de datos. Una de las estrategias es a través del botón "Import Dataset", el cual debes pinchar y luego cargar la base de datos "`ENS_2016_2017_samp_v2.csv`" usando el botón "From Excel..." Otra de las formas para poder utilizarla requiere que tengamos el conjunto de datos llamado "`ENS_2016_2017_samp_v2.csv`" en la misma carpeta en que hemos guardado nuestro Rmd. La función que utilizaremos se llama `read.csv2`. Para llamar a la aplicación de una función ejecutaremos su nombre seguido por un par de paréntesis **`( )`** dentro de los cuales indicaremos como único argumento `file =` seguido del nombre del archivo escrito entre comillas: ```{r eval=FALSE} ``` La instrucción anterior se interpreta como una llamada a la función `read.csv2` con argumento con el archivo "`ENS_2016_2017_samp_v2.csv`" en la posición del argumento `file`. Aunque no es obligatorio escribir el nombre del argumento, hacerlo puede ser una buena práctica para prevenir errores humanos en la escritura y confusiones en la lectura de los códigos, así como en la interpretación que hace R de tales instrucciones. Así tal cual, esta llamada de función carga el conjunto de datos, pero no lo guarda en el entorno de trabajo (*workspace*, *environment*). Para guardar la información cargada en un objeto que podamos manipular en R, debemos realizar una asignación. ***¿Qué es una asignación?*** Una **asignación** en R es una o más líneas de códigos que ordenan guardar en un objeto con nombre la información generada tras la ejecución del código. De esta forma, podríamos almacenar el resultado de la ejecución de `read.csv2("ENS_2016_2017_samp_v2.csv")` en un objeto llamado, por ejemplo, `dat`. Para esto ejecutaremos la siguiente línea de código: ```{r} ``` Notemos que para asignar o vincular la carga de los datos con el nombre que le estamos dando al objeto, utilizamos una *flecha* (`<-`). Esta flecha se llama operador "**asignación**" y lo que hace es crear un objeto al asignarle un nombre al resultado de la ejecución de una instrucción. Para ello, la palabra hacia la que apunta la flecha es el nombre que recibirá el objeto, en este caso `dat`. El resultado de la ejecución de lo que se encuentra en la cola de la flecha es aquello que se asociará al nombre `dat`, que en este caso es el conjunto de datos cargado, es decir, el resultado de la instrucción que dimos a R. Ahora que nuestro conjunto de datos está guardado en un objeto llamado `dat`, no es necesario tener que volver a cargarlo, sino que podemos llamarlo directamente usando su nombre: ```{r eval=FALSE} ``` ## Visualización de nuestros datos Para poder visualizar nuestro conjunto de datos completo en una planilla, podemos usar la función `View()`. ```{r} ``` Esta función desplegará una ventana adicional que nos permite filtrar, ordenar y buscar datos sin modificar el conjunto sobre el que estamos trabajando. Cuando llamamos a `dat`, R nos muestra la totalidad de observaciones que contiene el conjunto de datos. Por otra parte, cuando llamamos a `View(dat)` los datos se abren en una nueva ventana, pero no se imprimen en el informe. Cuando emitamos nuestros documentos podemos querer ver los datos, pero no todos ellos, para que tener una idea de cómo están registrados. En este caso, podemos usar la función `head`, cuyo primer argumento `x` indica el objeto al cual se le aplicará la función: ```{r} ``` Esta función nos muestra por defecto u omisión ("*by default*") las 6 primeras filas u observaciones del conjunto de datos que indicamos. Si queremos ver más o menos observaciones, debemos especificarlo a través de un argumento adicional. ***¿Cuáles son los argumentos de una función?*** Por supuesto, podemos acudir a Google, pero antes de eso tenemos a mano la documentación o ayuda de R. Por ejemplo, si queremos explorar la ayuda de la función `head` para conocer sus argumentos, podemos hacerlo yendo a la ventana de ayuda y buscando el nombre de la función. Otra alternativa es ejecutar en la consola una instrucción que parte con un de signo de pregunta (`?`) seguido del nombre de la función que nos interesa conocer: ```{r} ``` Allí encontraremos una descripción de la función, cómo se usa, los argumentos que recibe, entre otras informaciones. En el caso de head, vemos que su segundo argumento, `n`, es un número entero que indica cuántas filas u observaciones deseamos que se muestren: ```{r} ``` Notar que si omitimos los nombres de los argumentos, debemos escribirlos en el orden indicado en la documentación. Por ejemplo, ```{r} ``` funciona correctamente, pero ```{r eval=FALSE} ``` Error in checkHT(n, dx <- dim(x)) : invalid 'n' - must have length one when dim(x) is NULL, got 16 entrega un mensaje de error. En su primera línea, antes de los dos puntos, indica la posición de la instrucción, en este caso al interior de la función, donde sucedió el problema. Luego, en la segunda línea indica cuál fue el problema: `dat` fue interpretado como el argumento `n`, el cual debe ser de largo uno y no 16. ## Visualización de una variable Hasta ahora hemos revisado el conjunto completo de datos con el que trabajaremos, pero en muchos casos nos interesará trabajar con una única variable. Las variables son objetos que se encuentran agrupados dentro de un conjunto de datos. El conjunto de datos será un objeto con una estructura específica al que llamaremos `data.frame` y las variables en su interior son objetos que llamaremos "**vectores**" (o columnas). Podemos llamar a un vector dentro de un `data.frame` conectándolos con el operador **\$** de esta forma: ```{r} ``` Esta estructura nos muestra a los elementos del vector `Edad` contenido en el `data.frame` `dat`. Al igual que con un `data.frame`, podemos aplicar funciones sobre un vector. Por ejemplo, para visualizar las primeras 10 observaciones de la variable `Edad`: ```{r} ``` De forma similar, podemos visualizar las primeras 10 observaciones de la variable `Sexo`: ```{r} ``` ## Renombrar variables Para renombrar las variables de un `data.frame` deberemos acceder a los nombres de las columnas del mismo con la función `names`: ```{r} ``` Y realizar una asignación que reemplace el elemento que esté en la posición de tal vector que corresponda con el nombre que deseamos reemplazar. Por ejemplo, si queremos reemplazar el nombre `IdEncuenta` por simplemente `ID`, debemos realizar la siguiente asignación: ```{r} ``` Aquí `[1]` indica extraer o trabajar sobre el elemento que esté en la primera posición de lo resulte de ejecutar `names(dat)`. # Guardar nuestro trabajo ## Exportar datos Existen diferentes funciones para exportar un `data.frame` en diferentes formatos de archivos. En este taller exportaremos a archivos de valores separados por coma (csv), para lo que usaremos la función `write.csv2`: ```{r} ``` En este caso el argumento `file` indica el nombre del archivo a generar (incluyendo su extensión) y el argumento `row.names = FALSE` indica que no se deben incluir como primera columna los nombres de las filas. Aprovechamos de mencionar que `FALSE` y `TRUE` son valores lógicos en R y se suelen usar como entradas en algunos argumentos de varias funciones. ## Compilar informe final En este apunte, el documento que hemos generado hasta este momento nos muestra las líneas de código y el resultado de éstas, sin embargo, podemos modificar las instrucciones que damos al chunk de código de modo que sólo aparezca el resultado, sólo el código o ninguno de los dos. Para ello, ponemos una coma después de la "r" que se encuentra entre llaves al abrir el código, `{r, }`, seguida por uno de estos argumentos: - **`eval=FALSE`** indica que no se evalúe el *chunk*, es decir, que no se ejecute el código. - **`include=FALSE`** indica que no se incluya el código del *chunk*, pero el código sí se ejecuta. - **`echo=FALSE`** indica que se ejecute el código, pero no se muestre el resultado. Estas configuraciones por defecto toman el valor `TRUE`, y se desactivan cuando indicamos que son `FALSE`. Ahora, regrese atrás en el documento y agregue la instrucción de que el código no se ejecute en las instancias en que se carga el conjunto de datos en su totalidad. Para finalizar, ejecute el botón "**Knit"** y compile su apunte.