Introducción a R y RStudio

Hoja de ruta

Enseñando: 45 min
Prácticas: 10 min

Preguntas

• ¿Cómo orientarse en RStudio?

• ¿Cómo interactuar con R?

• ¿Cómo administrar tu entorno?

• ¿Cómo instalar paquetes?

Objetivos

• Describir el propósito y el uso de cada panel del RStudio IDE

• Ubicar botones y opciones en RStudio IDE

• Definir una variable

• Asignar un dato a una variable

• Administrar un espacio de trabajo en una sesión R interactiva

• Usar operadores matemáticos y de comparación

• Llamar funciones

• Gestionar paquetes

Motivación

La ciencia es un proceso de varios pasos: una vez que hayas diseñado un experimento y recopilado datos, ¡comienza la verdadera diversión! Esta lección te enseñará cómo comenzar este proceso usando R y RStudio. Comenzaremos con datos brutos, realizaremos análisis exploratorios y aprenderemos a trazar gráficamente los resultados. Este ejemplo comienza con un conjunto de datos de gapminder.org que contiene información sobre la población de muchos países a lo largo del tiempo. ¿Puedes leer estos datos en R? ¿Puedes hacer un gráfico de la población de Senegal? ¿Puedes calcular el ingreso promedio de los países del continente asiático? Al final de estas lecciones, ¡podrás hacer cosas como graficar datos de poblaciones de estos países en menos de un minuto!

Antes de empezar el taller

Asegúrate de tener instalada la última versión de R y RStudio en tu máquina. Esto es importante, ya que algunos paquetes utilizados en el taller pueden no instalarse correctamente (o no funcionar) si R no está actualizado.

Descarga e instala la última versión de R aquí, descarga e instala RStudio aquí

Introducción a RStudio

Bienvenido a la parte R del taller de Software Carpentry.

A lo largo de esta lección, vamos a enseñarte algunos de los fundamentos del lenguaje R, así como algunas buenas prácticas para organizar el código de proyectos científicos que harán tu vida más fácil.

Usaremos RStudio: un entorno de desarrollo integrado y gratuito de código abierto. RStudio proporciona un editor incorporado, funciona en todas las plataformas (incluso en servidores) y ofrece muchas ventajas, como la integración de control de versiones y gestión de proyectos.

Diseño básico

Cuando abres por primera vez el RStudio, serás recibido por tres paneles:

• La consola interactiva de R (a la izquierda)
• Ambiente/Historial (en la esquina superior derecha)
• Archivos/Gráficos/Paquetes/Ayuda/Visor (abajo a la derecha)

Si abres archivos, como los scripts R, también se abrirá un panel de editor en la esquina superior izquierda.

Flujo de trabajo dentro de RStudio

Hay dos formas principales en que uno puede trabajar dentro de RStudio.

1. Probar y jugar dentro de la consola interactiva de R y luego copiar el código en un archivo .R para ejecutarlo más tarde.
   • Esto funciona bien cuando se hacen pequeñas pruebas y/o se está comenzando.
   • Rápidamente se vuelve laborioso.
2. Comienza a escribir un archivo en .R y usa las teclas de acceso directo de RStudio para ejecutar la línea actual, las líneas seleccionadas o modificadas en la consola interactiva.
   • Esta es una buena forma de comenzar; todo tu código estará guardado para después.
   • Podrás ejecutar el archivo que quieres desde RStudio o mediante la función source () de R.

Sugerencia: Ejecutando segmentos/secciones de tu código

RStudio ofrece gran flexibilidad para ejecutar código desde dentro de la ventana del editor Hay botones, opciones de menú y atajos de teclado. Para ejecutar la línea actual, puedes

1. hacer clic en el botón Run arriba en el panel del Editor, o 2. Seleccionar “Run Lines” desde el menú “Code”, o 3. Presionar Ctrl-Enter en Windows o Linux o Command-Enter en OS X. (Este atajo también se puede hacer colocando el mouse sobre el botón). Para ejecutar un bloque de código, selecciónalo y luego pulsa Run. Si has modificado una línea de código dentro de un bloque que acabas de ejecutar, no es necesario re-seleccionar el bloque y Run, puedes usar el botón Re-run the previous region. Esto ejecutará el bloque de código anterior, incluidas las modificaciones que hayas realizado.

Introducción a R

Gran parte de tu tiempo en R lo gastarás en la consola interactiva de R. Aquí es donde ejecutarás todo tu código, y puede ser un entorno útil para probar ideas antes de guardarlas en un script R. La consola en RStudio es la misma que obtendrías si escribieras R en la terminal de shell/linea de comandos.

Lo primero que verás en la sesión interactiva de R es un montón de información, seguido por un “>” y un cursor parpadeante. Esto es similar al entorno de la terminal de shell que aprendiste durante las lecciones de shell: R opera con la misma idea de “leer, evaluar, mostrar” (tú escribes comandos, R intenta ejecutarlos y luego devuelve un resultado).

Usando R como una calculadora

Lo más simple que podrías hacer con R es aritmética:

1 + 100

[1] 101

R te mostrará la respuesta, precedido de un “[1]”. No te preocupes por esto por ahora, lo explicaremos más adelante. Por ahora piensa en eso como parte de la salida.

Al igual que bash, si escribes un comando incompleto R esperará a que lo completes:

> 1 +

+

Cada vez que presionas Enter y R te muestra un “+” en lugar de “>”, significa que está esperando que completes el comando. Si deseas cancelar un comando, simplemente presiona “Esc” y RStudio te devolverá el “>” prompt.

Sugerencia: Cancelando comandos

Si usas R desde la línea de comandos en lugar de estar dentro de RStudio, debes usar Ctrl + C en lugar de Esc para cancelar el comando. ¡Esto se aplica también a los usuarios de Mac!

La cancelación de un comando no sólo es útil para matar comandos incompletos: también puedes usarlo para decirle a R que deje de ejecutar el código (por ejemplo, si tarda mucho más de lo que esperabas), o para deshacerte del código que estás escribiendo actualmente.

Cuando usas R como calculadora, el orden de las operaciones es el mismo que has aprendido en la escuela.

De mayor a menor precedencia:

• Paréntesis: (, )
• Exponente: ^ o **
• División: /
• Multiplicación: *
• Suma: +
• Resta: -

3 + 5 * 2

[1] 13

Usa paréntesis para agrupar las operaciones a fin de forzar el orden de la evaluación o para aclarar lo que deseas hacer.

(3 + 5) * 2

[1] 16

Esto puede ser difícil de manejar cuando no es necesario, pero aclara tus intenciones. Recuerda que otros pueden leer tu código.

(3 + (5 * (2 ^ 2))) # difícil de leer
3 + 5 * 2 ^ 2       # claro, si recuerdas las reglas
3 + 5 * (2 ^ 2)     # si olvidas algunas reglas, esto podría ayudar

El texto después de cada línea de código se llama “comentario”. Todo lo que sigue después del símbolo hash (o numeral) # es ignorado por R cuando se ejecuta el código.

Los números pequeños o grandes tienen una notación científica:

2/10000

[1] 2e-04

Es la abreviatura de “multiplicado por 10 ^ XX “. Entonces 2e-4 es la abreviatura de 2 * 10^(-4).

Tú también puedes escribir números en notación científica:

5e3  # nota la falta del signo menos aquí

[1] 5000

Funciones matemáticas

R tiene muchas funciones matemáticas integradas. Para llamar a una función, simplemente escribimos su nombre seguido de paréntesis ( ). Todo lo que escribas dentro de los paréntesis se llaman argumentos de la función:

sin(1)  # función trigonométrica

[1] 0.841471

log(1)  # logaritmo natural

[1] 0

log10(10) # logaritmo en base-10

[1] 1

exp(0.5) # e^(1/2)

[1] 1.648721

No te preocupes si no recuerdas todas las funciones en R. Simplemente puedes buscarlas en Google, o si puedes recordar el comienzo del nombre de la función, puedes usar el tabulador para completar su nombre en RStudio.

Esta es una de las ventajas que RStudio tiene sobre R, tiene capacidades de autocompletado que te permiten buscar funciones, sus argumentos y los valores que toman más fácilmente.

Escribir un ? antes del nombre de un comando abrirá la página de ayuda para ese comando. Además de proporcionar una descripción detallada del comando y cómo funciona, al desplazarse hacia la parte inferior de la página de ayuda generalmente se mostrarán ejemplos que ilustran el uso del comando. Veremos un ejemplo más adelante. Puedes consultar también las guías rápidas disponibles en el sitio de RStudio

Comparando

Podemos realizar comparaciones en R:

1 == 1  # igualdad (observa dos signos iguales, se lee como "es igual a")

[1] TRUE

1 != 2  # desigualdad (leída como "no es igual a")

[1] TRUE

1 < 2  # menor que

[1] TRUE

1 <= 1  # menor o igual que

[1] TRUE

1 > 0  # mayor que

[1] TRUE

1 >= -9 # mayor o igual que

[1] TRUE

Sugerencia: Comparando números

Una advertencia sobre la comparación de números: nunca debes usar == para comparar dos números a menos que sean enteros (integer es un tipo de datos que específica números enteros).

Las computadoras sólo pueden representar números decimales con un cierto grado de precisión, así que dos números que parecen iguales cuando se muestran por R, pueden tener diferentes representaciones subyacentes y por lo tanto ser diferentes por un pequeño margen de error (llamado tolerancia numérica de la máquina).

En su lugar, debes usar la función all.equal.

Lectura adicional: http://floating-point-gui.de/

Variables y asignaciones

Podemos almacenar valores en variables usando el operador de asignación <-, veamos un ejemplo:

x <- 1/40

Observa que la asignación no muestra el valor. En cambio, lo almacena para más adelante en algo llamado variable. x ahora contiene el valor 0.025:

x

[1] 0.025

Más precisamente, el valor almacenado es una aproximación decimal de esta fracción, llamado número de coma flotante o floating point.

Busca la pestaña Environment en uno de los paneles de RStudio, y verás que x y su valor han aparecido. Nuestra variable x se puede usar en lugar de un número en cualquier cálculo que espere un número:

log(x)

[1] -3.688879

Ten en cuenta que las variables pueden reasignarse, es decir, puedes cambiar el valor almacenado en la variable:

x <- 100

x tenía el valor 0.025 y ahora tiene el valor 100.

También, los valores de asignación pueden contener la variable asignada:

x <- x + 1 # observa cómo RStudio actualiza la descripción de x en la pestaña superior derecha
y <- x * 2

El lado derecho de la asignación puede ser cualquier expresión de R válida. La expresión del lado derecho se evalúa por completo antes de que se realice la asignación.

Los nombres de las variables pueden contener letras, números, guiones bajos y puntos. No pueden comenzar con un número ni contener espacios en absoluto. Diferentes personas usan diferentes convenciones para nombres largos de variables, estos incluyen

• puntos.entre.palabras
• guiones_bajos_entre_palabras
• MayúsculasMinúsculasParaSepararPalabras

Lo que uses depende de ti, pero sé consistente.

También es posible utilizar el operador = para la asignación:

x = 1/40

Esta forma es menos común entre los usuarios R. Lo más importante es ser consistente con el operador que usas. Ocasionalmente hay lugares donde es menos confuso usar <- que =, y es el símbolo más común usado en la comunidad. Entonces la recomendación es usar <-.

Desafío 1

De los siguientes ejemplos, ¿Cuáles son nombres de variables válidas en R?

min_height
max.height
_age
.mass
MaxLength
min-length
2widths
celsius2kelvin

Solución al desafío 1

Los siguientes nombres de variables son válidos en R:

min_height
max.height
MaxLength
celsius2kelvin

El punto al inicio crea una variable oculta:

.mass

Los siguientes no son nombres de variables válidos en R:

_age
min-length
2widths

Vectorización

Es muy importante tener en cuenta que R es vectorizado, lo que significa que las variables y funciones pueden tener vectores como valores y R puede operar en vectores completos a la vez. En contraste con los conceptos de vectores de física y matemáticas, un vector en R describe un conjunto de valores del mismo tipo de datos en un cierto orden. Por ejemplo:

1:5

[1] 1 2 3 4 5

2^(1:5)

[1]  2  4  8 16 32

x <- 1:5
2^x

[1]  2  4  8 16 32

Esto es increíblemente poderoso; discutiremos esto en una próxima lección.

Administrando tu entorno

Hay algunos comandos útiles que puedes usar para interactuar con la sesión de R.

ls listará todas las variables y funciones almacenadas en el entorno global (tu sesión de trabajo en R):

ls()

[1] "args"    "dest_md" "op"      "src_rmd" "x"       "y"      

Sugerencia: ocultando objetos

Al igual que en el shell, ls oculta por defecto cualquier variable o función que comience con un “.”. Para listar todos los objetos, escribe ls(all.names = TRUE)

Ten en cuenta que no se dió ningún argumento a ls, pero sí se necesita poner los paréntesis para decirle a R que llame a la función.

Si escribimos ls nada más, ¡R mostrará el código fuente de esa función!

ls

function (name, pos = -1L, envir = as.environment(pos), all.names = FALSE, 
    pattern, sorted = TRUE) 
{
    if (!missing(name)) {
        pos <- tryCatch(name, error = function(e) e)
        if (inherits(pos, "error")) {
            name <- substitute(name)
            if (!is.character(name)) 
                name <- deparse(name)
            warning(gettextf("%s converted to character string", 
                sQuote(name)), domain = NA)
            pos <- name
        }
    }
    all.names <- .Internal(ls(envir, all.names, sorted))
    if (!missing(pattern)) {
        if ((ll <- length(grep("[", pattern, fixed = TRUE))) && 
            ll != length(grep("]", pattern, fixed = TRUE))) {
            if (pattern == "[") {
                pattern <- "\\["
                warning("replaced regular expression pattern '[' by  '\\\\['")
            }
            else if (length(grep("[^\\\\]\\[<-", pattern))) {
                pattern <- sub("\\[<-", "\\\\\\[<-", pattern)
                warning("replaced '[<-' by '\\\\[<-' in regular expression pattern")
            }
        }
        grep(pattern, all.names, value = TRUE)
    }
    else all.names
}
<bytecode: 0x55b833a15408>
<environment: namespace:base>

Puedes usar rm para eliminar objetos que ya no necesitas:

rm(x)

Si tienes muchas cosas en tu entorno y deseas borrarlas todas, puedes pasar los resultados de ls y mandarlos a la función rm:

rm(list = ls())

En este caso, hemos combinado los dos. Al igual que el orden de las operaciones, todo lo que se encuentre dentro de los paréntesis más internos se evalúa primero, y así sucesivamente.

En este caso, hemos especificado que los resultados de ls se deben usar para el argumento list y luego remover la lista con rm. Cuando asignes valores a argumentos por su nombre, debes usar el operador =.

Si, en cambio, usamos <-, habrá efectos secundarios no deseados, o puedes recibir un mensaje de error:

rm(list <- ls())

Error in rm(list <- ls()): ... must contain names or character strings

Sugerencia: Advertencias vs. Errores

¡Presta atención cuando R hace algo inesperado! Los errores, como el anterior, se lanzan cuando R no puede proceder a un cálculo. Por otro lado, las advertencias generalmente significan que la función se ha ejecutado, pero probablemente no funcionó como se esperaba.

En ambos casos, el mensaje que muestra R usualmente te da pistas sobre cómo solucionar el problema.

Paquetes en R

Es posible agregar funciones a R escribiendo un paquete u obteniendo un paquete escrito por otra persona. Hay más de 10,000 paquetes disponibles en CRAN (la red completa de archivos R). R y RStudio tienen funcionalidad para administrar paquetes:

• Puedes ver qué paquetes están instalados escribiendo installed.packages()
• Puedes instalar paquetes escribiendo install.packages("nombre_de_paquete")
• Puedes actualizar los paquetes instalados escribiendo update.packages()
• Puedes eliminar un paquete con remove.packages("nombre_de_paquete")
• Puedes hacer que un paquete esté disponible para su uso con library(nombre_de_paquete)

Desafío 2

¿Cuál será el valor de cada variable después de cada comando en el siguiente programa?

mass <- 47.5
age <- 122
mass <- mass * 2.3
age <- age - 20

Solución al desafío 2

mass <- 47.5

Esto dará un valor de 47.5 para la variable mass

age <- 122

Esto dará un valor de 122 para la variable age

mass <- mass * 2.3

Multiplica el valor existente en mass 47.5 por 2.3 para dar un nuevo valor 109.25 a la variable mass.

age <- age - 20

Resta 20 del valor existente de 122 para obtener un nuevo valor de 102 para la variable age.

Desafío 3

Ejecuta el código del desafío anterior y escribe un comando para comparar la variable mass con age. ¿Es la variable mass más grande que age?

Solución del desafío 3

Una forma de responder esta pregunta en R es usar > para hacer lo siguiente:

mass > age

[1] TRUE

Esto debería dar un valor booleano TRUE ya que 109.25 es mayor que 102.

Desafío 4

Limpia tu entorno de trabajo borrando las variables de mass y age.

Solución al desafío 4

Podemos usar el comando rm para realizar esta tarea

rm(age, mass)

Desafío 5

Instala los siguientes paquetes: ggplot2, plyr, gapminder

Solución al desafío 5

Puedes utilizar el comando install.packages() para instalar los paquetes requeridos.

install.packages("ggplot2")
install.packages("plyr")
install.packages("gapminder")

Puntos Clave

• Usa RStudio para escribir y correr programas en R.

• R tiene operadores aritméticos y funciones matemáticas usuales.

• Utilizar <- para asignar valores a variables.

• Utilizar ls() para listar las variables en el programa.

• Utilizar rm() para eliminar objetos en el programa.

• Utilizar install.packages() para instalar paquetes (libraries).

Gestión de proyectos con RStudio

Hoja de ruta

Enseñando: 20 min
Prácticas: 10 min

Preguntas

• ¿Cómo puedo gestionar mis proyectos en R?

Objetivos

• Crear proyectos independientes en RStudio

Introducción

El proceso científico es naturalmente incremental, y la vida de muchos proyectos comienza como notas aleatorias, algún código, luego un manuscrito, y eventualmente todo está mezclado.

Managing your projects in a reproducible fashion doesn't just make your science reproducible, it makes your life easier.

— Vince Buffalo (@vsbuffalo) April 15, 2013

La mayoría de la gente tiende a organizar sus proyectos de esta manera:

Hay muchas razones de porqué debemos siempre evitar esto:

1. Es realmente difícil saber cuál versión de tus datos es la original y cuál es la modificada;
2. Es muy complicado porque se mezclan archivos con varias extensiones juntas;
3. Probablemente te lleve mucho tiempo encontrar realmente cosas, y relacionar las figuras correctas con el código exacto que ha sido utilizado para generarlas.

Un buen diseño del proyecto finalmente hará tu vida más fácil:

• Ayudará a garantizar la integridad de tus datos;
• Hace que sea más simple compartir tu código con alguien más (un compañero de laboratorio, colaborador, o supervisor);
• Permite cargar fácilmente tu código junto con el envío de tu manuscrito;
• Hace que sea más fácil retomar un proyecto después de un descanso.

Una posible solución

Afortunadamente hay herramientas y paquetes que pueden ayudarte a gestionar tu trabajo con efectividad.

Uno de los aspectos más poderosos y útiles de RStudio es su funcionalidad de gestión de proyectos. Lo utilizaremos hoy para crear un proyecto autocontenido y reproducible.

Desafío: Creando un proyecto autocontenido

Vamos a crear un proyecto en RStudio:

1. Hacer clic en el menú “File”, luego en “New Project”.
2. Hacer clic en “New Directory”.
3. Hacer clic en “Empty Project”.
4. Introducir el nombre del directorio para guardar tu proyecto, por ejemplo: “my_project”.
5. Si está disponible, seleccionar la casilla de verificación “Create a git repository.”
6. Hacer clic en el botón “Create Project”.

Ahora cuando inicies R en este directorio de proyectos, o abras este proyecto con RStudio, todo nuestro trabajo estará completamente autocontenido en este directorio.

Mejores prácticas para la organización del proyecto

Aunque no existe una “mejor” forma de diseñar un proyecto, existen algunos principios generales que deben cumplirse para facilitar su gestión:

Tratar los datos como de sólo lectura

Este es probablemente el objetivo más importante al configurar un proyecto. Los datos suelen consumir mucho tiempo y/o ser costosos de recolectar. Trabajando con ellos interactivamente (por ejemplo, en Excel) donde pueden ser modificados significa que nunca estás seguro de donde provienen, o cómo han sido modificados desde su recolección. Por lo tanto, es una buena idea manejar tus datos como de “sólo lectura”.

Limpieza de datos

En muchos casos tus datos estarán “sucios”: y necesitarán un preprocesamiento significativo para obtener un formato R (o cualquier otro lenguaje de programación) que te resulte útil. Esta tarea es algunas veces llamada “data munging”. Es útil almacenar estos scripts en una carpeta separada y crear una segunda carpeta de datos de “sólo lectura” para contener los datasets “limpios”.

Tratar la salida generada como disponible

Todo lo generado por tus scripts debe tratarse como descartable: todo debería poder regenerarse a partir de tus scripts.

Hay muchas diferentes maneras de gestionar esta salida. Es útil tener una carpeta de salida con diferentes subdirectorios para cada análisis por separado. Esto hace que sea más fácil después, ya que muchos de nuestros análisis son exploratorios y no terminan siendo utilizados en el proyecto final, y algunos de los análisis se comparten entre proyectos.

Tip: Good Enough Practices for Scientific Computing

Good Enough Practices for Scientific Computing brinda las siguientes recomendaciones para la organización de proyectos:

1. Coloque cada proyecto en su propio directorio, el cual lleva el nombre del proyecto.
2. Coloque documentos de texto asociados con proyecto en el directorio doc.
3. Coloque los datos sin procesar y los metadatos en el directorio data, y archivos generados durante la limpieza y análisis en el directorio results .
4. Coloque los scripts fuente del proyecto y los programas en el directorio src, y programas traídos de otra parte o compilados localmente en el directorio bin.
5. Nombre todos archivos de tal manera que reflejen su contenido o función.

Tip: ProjectTemplate - una posible solución

Una manera de automatizar la gestión de un proyecto es instalar el paquete ProjectTemplate. Este paquete configurará una estructura de directorios ideal para la gestión de proyectos. Esto es muy útil ya que te permite tener tu pipeline/workflow de análisis organizado y estructurado. Junto con la funcionalidad predeterminada del proyecto RStudio y Git, podrás realizar el seguimiento de tu trabajo y compartirlo con colaboradores.

1. Instala ProjectTemplate.
2. Carga la librería
3. Inicializa el proyecto:

install.packages("ProjectTemplate")
library("ProjectTemplate")
create.project("../my_project", merge.strategy = "allow.non.conflict")

Para más información de ProjectTemplate y su functionalidad visita la página ProjectTemplate

Separar la definición de funciones y la aplicación

Una de las maneras más efectivas de trabajar con R es comenzar escribiendo el código que deseas que se ejecute directamente en un script .R, y enseguida ejecutar las líneas seleccionadas (ya sea utilizando los atajos del teclado en RStudio o haciendo clic en el botón “Run”) en la consola interactiva de R.

Cuando tu proyecto se encuentra en sus primeras etapas, el archivo script inicial .R generalmente contendrá muchas líneas de código ejecutadas directamente. Conforme vaya madurando, fragmentos reutilizables podrán ser llevados a sus propias funciones. Es buena idea separar estas funciones en dos carpetas separadas; una para guardar funciones útiles que reutilizarás a través del análisis y proyectos, y una para guardar los scripts de análisis.

Tip: Evitando la duplicación

Puedes encontrarte utilizando datos o scripts de análisis a través de varios proyectos. Normalmente, deseas evitar la duplicación para ahorrar espacio y evitar actualizar el código en múltiples lugares.

En este caso, es útil hacer “links simbólicos”, los cuales son esencialmente accesos directos a archivos en otro lugar en un sistema de archivos. En Linux y OS X puedes utilizar el comando ln -s, y en Windows crear un acceso directo o utilizar el comando mklink desde la terminal de Windows.

Guardar los datos en el directorio de datos

Ahora que tenemos una buena estructura de directorios colocaremos/guardaremos los archivos de datos en el directorio data/.

Desafío 1

Descargar los datos gapminder de aquí.

1. Descargar el archivo (CTRL + S, clic botón derecho del ratón -> “Guardar como…”, o Archivo -> “Guardar página como…”)
2. Asegúrate de que esté guardado con el nombre gapminder-FiveYearData.csv
3. Guardar el archivo en la carpeta data/ dentro de tu proyecto.

Más delante cargaremos e inspeccionaremos estos datos.

Desafío 2

Es útil tener una idea general sobre el dataset, directamente desde la línea de comandos, antes de cargarlo en R. Comprender mejor el dataset será útil al tomar decisiones sobre cómo cargarlo en R. Utiliza la terminal de línea de comandos para contestar las siguientes preguntas:

1. ¿Cuál es el tamaño del archivo?
2. ¿Cuántas líneas de datos contiene?
3. ¿Cuáles tipos de valores están almacenados en este archivo?

Solución al desafío 2

Al ejecutar estos comandos en la terminal:

ls -lh data/gapminder-FiveYearData.csv

-rw-r--r-- 1 runner docker 80K Mar 14 14:06 data/gapminder-FiveYearData.csv

El tamaño del archivo es 80K.

wc -l data/gapminder-FiveYearData.csv

1705 data/gapminder-FiveYearData.csv

Hay 1705 líneas. Los datos se ven así:

head data/gapminder-FiveYearData.csv

country,year,pop,continent,lifeExp,gdpPercap
Afghanistan,1952,8425333,Asia,28.801,779.4453145
Afghanistan,1957,9240934,Asia,30.332,820.8530296
Afghanistan,1962,10267083,Asia,31.997,853.10071
Afghanistan,1967,11537966,Asia,34.02,836.1971382
Afghanistan,1972,13079460,Asia,36.088,739.9811058
Afghanistan,1977,14880372,Asia,38.438,786.11336
Afghanistan,1982,12881816,Asia,39.854,978.0114388
Afghanistan,1987,13867957,Asia,40.822,852.3959448
Afghanistan,1992,16317921,Asia,41.674,649.3413952

Tip: Línea de comandos en R Studio

Puedes abrir rápidamente una terminal en RStudio usando la opción del menú Tools -> Shell….

Control de versiones

Es importante llevar a cabo el control de versiones en un proyecto. Ve aquí para una buena lección donde se describe el uso de Git con R Studio.

Puntos Clave

• Usar RStudio para crear y gestionar proyectos con un diseño consistente.

• Tratar los datos brutos como de sólo lectura.

• Tratar la salida generada como disponible.

• Definición y aplicación de funciones separadas.

Buscando ayuda

Hoja de ruta

Enseñando: 10 min
Prácticas: 10 min

Preguntas

• ¿Cómo puedo obtener ayuda en R?

Objetivos

• Poder leer archivos de ayuda de R, para funciones y operadores especiales

• Poder usar vistas de tareas CRAN para identificar paquetes para resolver un problema

• Para poder buscar ayuda de tus compañeros

Palabras clave

Comando : Traducción

help : ayuda

vignette : viñeta

Lectura de archivos de ayuda

R, y cada paquete, proporciona archivos de ayuda para las funciones. La sintaxis general para buscar ayuda en cualquier función, “function_name”, de una función específica que esté en un paquete cargado dentro de tu namespace (tu sesión interactiva en R):

?function_name
help(function_name)

Esto cargará una página de ayuda en RStudio (o como texto sin formato en R por sí mismo).

Cada página de ayuda se divide en secciones:

• Descripción: una descripción extendida de lo que hace la función.
• Uso: los argumentos de la función y sus valores predeterminados.
• Argumentos: una explicación de los datos que espera cada argumento.
• Detalles: cualquier detalle importante a tener en cuenta.
• Valor: los datos que regresa la función.
• Ver también: cualquier función relacionada que pueda serte útil.
• Ejemplos: algunos ejemplos de cómo usar la función.

Las diferentes funciones pueden tener diferentes secciones, pero estas son las principales que debes tener en cuenta.

Sugerencia: Lectura de archivos de ayuda

Uno de los aspectos más desalentadores de R es la gran cantidad de funciones disponibles. Es muy difícil, si no imposible, recordar el uso correcto para cada función que usas. Afortunadamente, están los archivos de ayuda ¡lo que significa, que no tienes que hacerlo!

Operadores especiales

Para buscar ayuda en operadores especiales, usa comillas:

?"<-"

Obteniendo ayuda en los paquetes

Muchos paquetes vienen con “viñetas”: tutoriales y documentación de ejemplo extendida. Sin ningún argumento, vignette() listará todas las viñetas disponibles para todos los paquetes instalados; vignette(package="package-name") listará todas las viñetas disponibles para package-name, y vignette("vignette-name") abrirá la viñeta especificada.

Si un paquete no tiene viñetas, generalmente puedes encontrar ayuda escribiendo help("package-name").

Cuando recuerdas un poco sobre la función

Si no estás seguro de en qué paquete está una función, o cómo se escribe específicamente, puedes hacer una búsqueda difusa:

??function_name

Cuando no tienes idea de dónde comenzar

Si no sabes qué función o paquete necesitas usar, utiliza CRAN Task Views es una lista especialmente mantenida de paquetes agrupados en campos. Este puede ser un buen punto de partida.

Cuando tu código no funciona: busca ayuda de tus compañeros

Si tienes problemas para usar una función, 9 de cada 10 veces, las respuestas que estas buscando ya han sido respondidas en Stack Overflow. Puedes buscar usando la etiqueta [r].

Si no puedes encontrar la respuesta, hay algunas funciones útiles para ayudarte a hacer una pregunta a tus compañeros:

?dput

Descargará los datos con los que estás trabajando en un formato para que puedan ser copiados y pegados por cualquier otra persona en su sesión de R.

sessionInfo()

R version 4.2.2 Patched (2022-11-10 r83330)
Platform: x86_64-pc-linux-gnu (64-bit)
Running under: Ubuntu 20.04.5 LTS

Matrix products: default
BLAS:   /usr/lib/x86_64-linux-gnu/blas/libblas.so.3.9.0
LAPACK: /usr/lib/x86_64-linux-gnu/lapack/liblapack.so.3.9.0

locale:
 [1] LC_CTYPE=C.UTF-8       LC_NUMERIC=C           LC_TIME=C.UTF-8       
 [4] LC_COLLATE=C.UTF-8     LC_MONETARY=C.UTF-8    LC_MESSAGES=C.UTF-8   
 [7] LC_PAPER=C.UTF-8       LC_NAME=C              LC_ADDRESS=C          
[10] LC_TELEPHONE=C         LC_MEASUREMENT=C.UTF-8 LC_IDENTIFICATION=C   

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
[1] knitr_1.42

loaded via a namespace (and not attached):
 [1] compiler_4.2.2  magrittr_2.0.3  cli_3.6.0       tools_4.2.2    
 [5] glue_1.6.2      vctrs_0.5.2     stringi_1.7.12  stringr_1.5.0  
 [9] xfun_0.37       lifecycle_1.0.3 rlang_1.1.0     evaluate_0.20  

Imprimirá tu versión actual de R, así como cualquier paquete que hayas cargado. Esto puede ser útil para otros para ayudar a reproducir y depurar tu problema.

Desafío 1

Buscar la ayuda para la función c. ¿Qué tipo de vector crees que crearás si evalúas lo siguiente?:

c(1, 2, 3)
c('d', 'e', 'f')
c(1, 2, 'f')

Solución al desafío 1

La función c() crea un vector, en el cual todos los elementos son del mismo tipo. En el primer caso, los elementos son numéricos, en el segundo, son character, y en el tercero son character: los valores numéricos son “forzados” para ser characters.

Desafío 2

Buscar la ayuda para la función paste. Tendrás que usar esto más tarde. ¿Cuál es la diferencia entre los argumentos sep y collapse?

Solución para el desafío 2

Busca la ayuda de la función paste(), usa:

help("paste")
?paste

La diferencia entre sep y collapse es un poco complicada. La función paste acepta cualquier número de argumentos, cada uno de los cuales puede ser un vector de cualquier longitud. El argumento sep especifica la cadena usada entre términos concatenados — por defecto, un espacio. El resultado es un vector tan largo como el argumento más largo proporcionado a paste. En cambio, collapse especifica que después de la concatenación los elementos son colapsados juntos utilizando el separador dado, y el resultado es una sola cadena. e.g.

paste(c("a","b"), "c")

[1] "a c" "b c"

paste(c("a","b"), "c", sep = ",")

[1] "a,c" "b,c"

paste(c("a","b"), "c", collapse = "|")

[1] "a c|b c"

paste(c("a","b"), "c", sep = ",", collapse = "|")

[1] "a,c|b,c"

(Para más información, ve a la parte inferior de la página de ayuda ?paste y busca los ejemplos, o prueba example('paste').)

Desafío 3

Usa la ayuda para encontrar una función (y sus parámetros asociados) que tu puedas usar para cargar datos de un archivo csv en los cuales las columnas están delimitadas con “\ t” (tab) y el punto decimal es un “.” (punto). Esta comprobación para el separador decimal es importante, especialmente si estás trabajando con colegas internacionales ya que diferentes países tienen diferentes convenciones para el punto decimal (i.e. coma vs. punto). sugerencia: usa ??csv para buscar funciones relacionadas con csv.

Solución para el desafío 3

La función R estándar para leer archivos delimitados por tabuladores con un separador de punto decimal es read.delim(). Tu puedes hacer esto también con read.table(file, sep="\t") (el punto es el separador decimal por defecto para read.table(), aunque es posible que tengas que cambiar también el argumento comment.char si tu archivo de datos contiene caracteres numeral (#)

Otros recursos útiles

• Quick R
• RStudio cheat sheets
• Cookbook for R

Puntos Clave

• Usar help() para obtener ayuda online de R.

Estructuras de datos

Hoja de ruta

Enseñando: 40 min
Prácticas: 15 min

Preguntas

• ¿Cómo puedo leer datos en R?

• ¿Cuáles son los tipos de datos básicos en R?

• ¿Cómo represento la información categórica en R?

Objetivos

• Conocer los distintos tipos de datos.

• Comenzar a explorar los data frames y entender cómo se relacionan con vectors, factors y lists.

• Ser capaz de preguntar sobre el tipo, clase y estructura de un objeto en R.

• Conocer y entender qué es coerción y cuáles son los distintos tipos de coerciones.

Palabras clave

Comando : Significado

data set : conjunto de datos

c : combinar

dim : dimensión

nrow : número de filas

ncol: número de columnas

Una de las características más poderosas de R es su habilidad para manejar datos tabulares - como los que puedes tener en una planilla de cálculo o un archivo CSV. Comencemos creando un dataset llamado gatos que se vea de la siguiente forma:

color,peso,le_gusta_cuerda
mixto,2.1,1
negro,5.0,0
atigrado,3.2,1

Podemos usar la función data.frame para crearlo.

gatos <- data.frame(color = c("mixto", "negro", "atigrado"),
                      peso = c(2.1, 5.0, 3.2),
                      le_gusta_cuerda = c(1, 0, 1))                    
gatos                   

     color peso le_gusta_cuerda
1    mixto  2.1               1
2    negro  5.0               0
3 atigrado  3.2               1

Consejo: Edición de archivos de texto en R

Crea el archivo data/gatos-data.csv usando un editor de texto (Nano), o en RStudio usando el ítem del Menú File -> New File -> Text File. Recuerda que debes tener creado el directorio data para poder guardar dentro el archivo gatos-data.csv

Podemos leer el archivo en R con el siguiente comando:

gatos <- read.csv(file = "data/gatos-data.csv", stringsAsFactors = TRUE)
gatos

     color peso le_gusta_cuerda
1    mixto  2.1               1
2    negro  5.0               0
3 atigrado  3.2               1

La función read.table se usa para leer datos tabulares almacenados en un archivo de texto donde las columnas de datos están separadas por caracteres de puntuación, por ejemplo archivos CSV (csv = valores separados por comas). Las tabulaciones y las comas son los caracteres de puntuación más utilizados para separar o delimitar datos en archivos csv. Para mayor comodidad, R proporciona otras 2 versiones de “read.table”. Estos son: read.csv para archivos donde los datos están separados por comas y read.delim para archivos donde los datos están separados por tabulaciones. De estas tres funciones, read.csv es el más utilizado. Si fuera necesario, es posible anular o modificar el delimitador predeterminado para read.csv y ` read.delim`.

Podemos empezar a explorar el dataset inmediatamente proyectando las columnas usando el operador $:

gatos$peso

[1] 2.1 5.0 3.2

gatos$color

[1] mixto    negro    atigrado
Levels: atigrado mixto negro

Podemos hacer otras operaciones sobre las columnas. Por ejemplo, podemos aumentar el peso de todos los gatos con:

gatos$peso + 2

[1] 4.1 7.0 5.2

Podemos imprimir los resultados en una oración

paste("El color del gato es", gatos$color)

[1] "El color del gato es mixto"    "El color del gato es negro"   
[3] "El color del gato es atigrado"

Pero qué pasa con:

gatos$peso + gatos$color

Warning in Ops.factor(gatos$peso, gatos$color): '+' not meaningful for factors

[1] NA NA NA

Si adivinaste que el último comando iba a resultar en un error porque 2.1 más "negro" no tiene sentido, estás en lo cierto - y ya tienes alguna intuición sobre un concepto importante en programación que se llama tipos de datos.

No importa cuán complicado sea nuestro análisis, todos los datos en R se interpretan con uno de estos tipos de datos básicos. Este rigor tiene algunas consecuencias importantes.

Hay 5 tipos de datos principales: double, integer, complex, logical and character.

Podemos preguntar cuál es la estructura de datos si usamos la función class:

class(gatos$color)

[1] "factor"

class(gatos$peso)

[1] "numeric"

También podemos ver que gatos es un data.frame si usamos la función class:

class(gatos)

[1] "data.frame"

Vectores y Coerción de Tipos

Para entender mejor este comportamiento, veamos otra de las estructuras de datos en R: el vector.

Un vector en R es esencialmente una lista ordenada de cosas, con la condición especial de que todos los elementos en un vector tienen que ser del mismo tipo de datos básico. Si no eliges un tipo de datos, por defecto R elige el tipo de datos logical. También puedes declarar un vector vacío de cualquier tipo que quieras.

Una indicación del número de elementos en el vector - específicamente los índices del vector, en este caso [1:3] y unos pocos ejemplos de los elementos del vector - en este caso strings vacíos.

Podemos ver que gatos$peso es un vector usando la funcion str.

str(gatos$peso)

 num [1:3] 2.1 5 3.2

Las columnas de datos que cargamos en data.frames de R son todas vectores y este es el motivo por el cual R requiere que todas las columnas sean del mismo tipo de datos básico.

Discusión 1

¿Por qué R es tan obstinado acerca de lo que ponemos en nuestras columnas de datos? ¿Cómo nos ayuda esto?

Discusión 1

Al mantener todos los elementos de una columna del mismo tipo, podemos hacer suposiciones simples sobre nuestros datos; si puedes interpretar un elemento en una columna como un número, entonces puedes interpretar todos los elementos como números, y por tanto no hace falta comprobarlo cada vez. Esta consistencia es lo que se suele mencionar como datos limpios; a la larga, la consistencia estricta hace nuestras vidas más fáciles cuando usamos R.

También puedes crear vectores con contenido explícito con la función combine o c():

mi_vector <- c(2,6,3)
mi_vector

[1] 2 6 3

str(mi_vector)

 num [1:3] 2 6 3

Dado lo que aprendimos hasta ahora, ¿qué crees que hace el siguiente código?

otro_vector <- c(2,6,'3')

Esto se denomina coerción de tipos de datos y es motivo de muchas sorpresas y la razón por la cual es necesario conocer los tipos de datos básicos y cómo R los interpreta. Cuando R encuentra una mezcla de tipos de datos (en este caso numeric y character) para combinarlos en un vector, va a forzarlos a ser del mismo tipo.

Considera:

vector_coercion <- c('a', TRUE)
str(vector_coercion)

 chr [1:2] "a" "TRUE"

otro_vector_coercion <- c(0, TRUE)
str(otro_vector_coercion)

 num [1:2] 0 1

Las reglas de coerción son: logical -> integer -> numeric -> complex -> character, donde -> se puede leer como se transforma en. Puedes intentar forzar la coerción de acuerdo a esta cadena usando las funciones as.:

vector_caracteres <- c('0','2','4')
vector_caracteres

[1] "0" "2" "4"

str(vector_caracteres)

 chr [1:3] "0" "2" "4"

caracteres_coercionados_numerico <- as.numeric(vector_caracteres)
caracteres_coercionados_numerico

[1] 0 2 4

numerico_coercionado_logico <- as.logical(caracteres_coercionados_numerico)
numerico_coercionado_logico

[1] FALSE  TRUE  TRUE

Como puedes notar, es sorprendete ver qué pasa cuando R forza la conversión de un tipo de datos a otro. Es decir, si tus datos no lucen como pensabas que deberían lucir, puede ser culpa de la coerción de tipos. Por lo tanto, asegúrate que todos los elementos de tus vectores y las columnas de tus data.frames sean del mismo tipo o te encontrarás con sorpresas desagradables.

Pero la coerción de tipos también puede ser muy útil. Por ejemplo, en los datos de gatos, le_gusta_cuerda es numérica, pero sabemos que los 1s y 0s en realidad representan TRUE y FALSE (una forma habitual de representarlos). Deberíamos usar el tipo de datos logical en este caso, que tiene dos estados: TRUE o FALSE, que es exactamente lo que nuestros datos representan. Podemos convertir esta columna al tipo de datos logical usando la función as.logical:

gatos$le_gusta_cuerda

[1] 1 0 1

class(gatos$le_gusta_cuerda)

[1] "integer"

gatos$le_gusta_cuerda <- as.logical(gatos$le_gusta_cuerda)
gatos$le_gusta_cuerda

[1]  TRUE FALSE  TRUE

class(gatos$le_gusta_cuerda)

[1] "logical"

La función combine, c(), también agregará elementos al final de un vector existente:

ab <- c('a', 'b')
ab

[1] "a" "b"

abc <- c(ab, 'c')
abc

[1] "a" "b" "c"

También puedes hacer una serie de números así:

mySerie <- 1:5
mySerie

[1] 1 2 3 4 5

str(mySerie)

 int [1:5] 1 2 3 4 5

class(mySerie)

[1] "integer"

Finalmente, puedes darle nombres a los elementos de tu vector:

names(mySerie) <- c("a", "b", "c", "d", "e")
mySerie

a b c d e 
1 2 3 4 5 

str(mySerie)

 Named int [1:5] 1 2 3 4 5
 - attr(*, "names")= chr [1:5] "a" "b" "c" "d" ...

class(mySerie)

[1] "integer"

Desafío 1

Comienza construyendo un vector con los números del 1 al 26. Multiplica el vector por 2 y asigna al vector resultante, los nombres de A hasta Z (Pista: hay un vector pre-definido llamado LETTERS)

Solución del desafío 1

x <- 1:26
x <- x * 2
names(x) <- LETTERS

Factores

Otra estructura de datos importante se llama factor.

str(gatos$color)

 Factor w/ 3 levels "atigrado","mixto",..: 2 3 1

Los factores usualmente parecen caracteres, pero se usan para representar información categórica. Por ejemplo, construyamos un vector de strings con etiquetas para las coloraciones para todos los gatos en nuestro estudio:

capas <- c('atigrado', 'carey', 'carey', 'negro', 'atigrado')
capas

[1] "atigrado" "carey"    "carey"    "negro"    "atigrado"

str(capas)

 chr [1:5] "atigrado" "carey" "carey" "negro" "atigrado"

Podemos convertir un vector en un factor de la siguiente manera:

categorias <- factor(capas)
class(categorias)

[1] "factor"

str(categorias)

 Factor w/ 3 levels "atigrado","carey",..: 1 2 2 3 1

Ahora R puede interpretar que hay tres posibles categorías en nuestros datos - pero también hizo algo sorprendente: en lugar de imprimir los strings como se las dimos, imprimió una serie de números. R ha reemplazado las categorías con índices numéricos, lo cual es necesario porque muchos cálculos estadísticos usan esa representación para datos categóricos:

class(capas)

[1] "character"

class(categorias)

[1] "factor"

Desafío 2

¿Hay algún factor en nuestro data.frame gatos? ¿Cuál es el nombre? Intenta usar ?read.csv para darte cuenta cómo mantener las columnas de texto como vectores de caracteres en lugar de factores; luego escribe uno o más comandos para mostrar que el factor en gatos es en realidad un vector de caracteres cuando se carga de esta manera.

Solución al desafío 2

Una solución es usar el argumento stringAsFactors:

gatos <- read.csv(file="data/gatos-data.csv", stringsAsFactors=FALSE)
str(gatos$color)

Otra solución es usar el argumento colClasses que permiten un control más fino.

gatos <- read.csv(file="data/gatos-data.csv", colClasses=c(NA, NA, "character"))
str(gatos$color)

Nota: Los nuevos estudiantes encuentran los archivos de ayuda difíciles de entender; asegúrese de hacerles saber que esto es normal, y anímelos a que tomen su mejor opción en función del significado semántico, incluso si no están seguros.

En las funciones de modelado, es importante saber cuáles son los niveles de referencia. Se asume que es el primer factor, pero por defecto los factores están etiquetados en orden alfabetico. Puedes cambiar esto especificando los niveles:

misdatos <- c("caso", "control", "control", "caso")
factor_orden <- factor(misdatos, levels = c("control", "caso"))
str(factor_orden)

 Factor w/ 2 levels "control","caso": 2 1 1 2

En este caso, le hemos dicho explícitamente a R que “control” debería estar representado por 1, y “caso” por 2. Esta designación puede ser muy importante para interpretar los resultados de modelos estadísticos!

Listas

Otra estructura de datos que querrás en tu bolsa de trucos es list. Una lista es más simple en algunos aspectos que los otros tipos, porque puedes poner cualquier cosa que tú quieras en ella:

lista <- list(1, "a", TRUE, 1+4i)
lista

[[1]]
[1] 1

[[2]]
[1] "a"

[[3]]
[1] TRUE

[[4]]
[1] 1+4i

otra_lista <- list(title = "Numbers", numbers = 1:10, data = TRUE )
otra_lista

$title
[1] "Numbers"

$numbers
 [1]  1  2  3  4  5  6  7  8  9 10

$data
[1] TRUE

Ahora veamos algo interesante acerca de nuestro data.frame; ¿Qué pasa si corremos la siguiente línea?

typeof(gatos)

[1] "list"

Vemos que los data.frames parecen listas ‘en su cara oculta’ - esto es porque un data.frame es realmente una lista de vectores y factores, como debe ser - para mantener esas columnas que son una combinación de vectores y factores, el data.frame necesita algo más flexible que un vector para poner todas las columnas juntas en una tabla. En otras palabras, un data.frame es una lista especial en la que todos los vectores deben tener la misma longitud.

En nuestro ejemplo de gatos, tenemos una variable integer, una double y una logical. Como ya hemos visto, cada columna del data.frame es un vector.

gatos$color

[1] mixto    negro    atigrado
Levels: atigrado mixto negro

gatos[,1]

[1] mixto    negro    atigrado
Levels: atigrado mixto negro

typeof(gatos[,1])

[1] "integer"

str(gatos[,1])

 Factor w/ 3 levels "atigrado","mixto",..: 2 3 1

Cada fila es una observación de diferentes variables del mismo data.frame, y por lo tanto puede estar compuesto de elementos de diferentes tipos.

gatos[1,]

  color peso le_gusta_cuerda
1 mixto  2.1            TRUE

typeof(gatos[1,])

[1] "list"

str(gatos[1,])

'data.frame':	1 obs. of  3 variables:
 $ color          : Factor w/ 3 levels "atigrado","mixto",..: 2
 $ peso           : num 2.1
 $ le_gusta_cuerda: logi TRUE

Desafío 3

Hay varias maneras sutilmente diferentes de indicar variables, observaciones y elementos de data.frames:

• gatos[1]
• gatos[[1]]
• gatos$color
• gatos["color"]
• gatos[1, 1]
• gatos[, 1]
• gatos[1, ]

Investiga cada uno de los ejemplos anteriores y explica el resultado de cada uno.

Sugerencia: Usa la función typeof() para examinar el resultado en cada caso.

Solución al desafío 3

gatos[1]

     color
1    mixto
2    negro
3 atigrado

Podemos interpretar un data frame como una lista de vectores. Un único par de corchetes [1] resulta en la primera proyección de la lista, como otra lista. En este caso es la primera columna del data frame.

gatos[[1]]

[1] mixto    negro    atigrado
Levels: atigrado mixto negro

El doble corchete [[1]] devuelve el contenido del elemento de la lista. En este caso, es el contenido de la primera columna, un vector de tipo factor.

gatos$color

[1] mixto    negro    atigrado
Levels: atigrado mixto negro

Este ejemplo usa el caracter $ para direccionar elementos por nombre. color es la primera columna del data frame, de nuevo un vector de tipo factor.

gatos["color"]

     color
1    mixto
2    negro
3 atigrado

Aquí estamos usando un solo corchete ["color"] reemplazando el número del índice con el nombre de la columna. Como el ejemplo 1, el objeto devuelto es un list.

gatos[1, 1]

[1] mixto
Levels: atigrado mixto negro

Este ejemplo usa un solo corchete, pero esta vez proporcionamos coordenadas de fila y columna. El objeto devuelto es el valor en la fila 1, columna 1. El objeto es un integer pero como es parte de un vector de tipo factor, R muestra la etiqueta “mixto” asociada con el valor entero.

gatos[, 1]

[1] mixto    negro    atigrado
Levels: atigrado mixto negro

Al igual que en el ejemplo anterior, utilizamos corchetes simples y proporcionamos las coordenadas de fila y columna. La coordenada de la fila no se especifica, R interpreta este valor faltante como todos los elementos en este column vector.

gatos[1, ]

  color peso le_gusta_cuerda
1 mixto  2.1            TRUE

De nuevo, utilizamos el corchete simple con las coordenadas de fila y columna. La coordenada de la columna no está especificada. El valor de retorno es una list que contiene todos los valores en la primera fila.

Matrices

Por último, pero no menos importante, están las matrices. Podemos declarar una matriz llena de ceros de la siguiente forma:

matrix_example <- matrix(0, ncol=6, nrow=3)
matrix_example

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    0    0    0    0    0    0
[2,]    0    0    0    0    0    0
[3,]    0    0    0    0    0    0

Y de manera similar a otras estructuras de datos, podemos preguntar cosas sobre la matriz:

class(matrix_example)

[1] "matrix" "array" 

typeof(matrix_example)

[1] "double"

str(matrix_example)

 num [1:3, 1:6] 0 0 0 0 0 0 0 0 0 0 ...

dim(matrix_example)

[1] 3 6

nrow(matrix_example)

[1] 3

ncol(matrix_example)

[1] 6

Desafío 4

¿Cuál crees que es el resultado del comando length(matrix_example)? Inténtalo. ¿Estabas en lo correcto? ¿Por qué / por qué no?

Solución al desafío 4

¿Cuál crees que es el resultado del comando length(matrix_example)?

matrix_example <- matrix(0, ncol=6, nrow=3)
length(matrix_example)

[1] 18

Debido a que una matriz es un vector con atributos de dimensión añadidos, length proporciona la cantidad total de elementos en la matriz.

Desafío 5

Construye otra matriz, esta vez conteniendo los números 1:50, con 5 columnas y 10 renglones. ¿Cómo llenó la función matrix de manera predeterminada la matriz, por columna o por renglón? Investiga como cambiar este comportamento. (Sugerencia: lee la documentación de la función matrix.)

Solución al desafío 5

Construye otra matriz, esta vez conteniendo los números 1:50, con 5 columnas y 10 renglones. ¿Cómo llenó la función matrix de manera predeterminada la matriz, por columna o por renglón? Investiga como cambiar este comportamento. (Sugerencia: lee la documentación de la función matrix.)

x <- matrix(1:50, ncol=5, nrow=10)
x <- matrix(1:50, ncol=5, nrow=10, byrow = TRUE) # to fill by row

Desafío 6

Crea una lista de longitud dos que contenga un vector de caracteres para cada una de las secciones en esta parte del curso:

• tipos de datos
• estructura de datos

Inicializa cada vector de caracteres con los nombres de los tipos de datos y estructuras de datos que hemos visto hasta ahora.

Solución al desafío 6

dataTypes <- c('double', 'complex', 'integer', 'character', 'logical')
dataStructures <- c('data.frame', 'vector', 'factor', 'list', 'matrix')
answer <- list(dataTypes, dataStructures)

Nota: es útil hacer una lista en el pizarrón o en papel colgado en la pared listando todos los tipos y estructuras de datos y mantener la lista durante el resto del curso para recordar la importancia de estos elementos básicos.

Desafío 7

Considera la salida de R para la siguiente matriz:

     [,1] [,2]
[1,]    4    1
[2,]    9    5
[3,]   10    7

¿Cuál fué el comando correcto para escribir esta matriz? Examina cada comando e intenta determinar el correcto antes de escribirlos. Piensa en qué matrices producirán los otros comandos.

1. matrix(c(4, 1, 9, 5, 10, 7), nrow = 3)
2. matrix(c(4, 9, 10, 1, 5, 7), ncol = 2, byrow = TRUE)
3. matrix(c(4, 9, 10, 1, 5, 7), nrow = 2)
4. matrix(c(4, 1, 9, 5, 10, 7), ncol = 2, byrow = TRUE)

Solución al desafío 7

Considera la salida de R para la siguiente matriz:

     [,1] [,2]
[1,]    4    1
[2,]    9    5
[3,]   10    7

¿Cuál era el comando correcto para escribir esta matriz? Examina cada comando e intenta determinar el correcto antes de escribirlos. Piensa en qué matrices producirán los otros comandos.

matrix(c(4, 1, 9, 5, 10, 7), ncol = 2, byrow = TRUE)

Puntos Clave

• Usar read.csv para leer los datos tabulares en R.

• Los tipos de datos básicos en R son double, integer, complex, logical, y character.

• Usar factors para representar categorías en R.

Explorando data frames

Hoja de ruta

Enseñando: 20 min
Prácticas: 10 min

Preguntas

• ¿Cómo puedo manipular un data frame?

Objetivos

• Poder agregar y quitar filas y columnas.

• Poder quitar filas con valores NA.

• Poder anexar dos data frames.

• Poder articular qué es un factor y cómo convertir entre factor y character.

• Poder entender las propiedades básicas de un data frame, incluyendo tamaño, clase o tipo de columnas, nombres y primeras filas.

A esta altura, ya viste los tipos y estructuras de datos básicos de R y todo lo que hagas va a ser una manipulación de esas herramientas. Ahora pasaremos a aprender un par de cosas sobre cómo trabajar con la clase data frame (la estructura de datos que usarás la mayoría del tiempo y que será la estrella del show). Un data frame es la tabla que creamos al cargar información de un archivo csv.

Palabras clave

Comando : Traducción

nrow: número de filas

ncol: número de columnas

rbind: combinar filas

cbind: combinar columnas

Agregando columnas y filas a un data frame

Aprendimos que las columnas en un data frame son vectores. Por lo tanto, sabemos que nuestros datos son consistentes con el tipo de dato dentro de esa columna. Si queremos agregar una nueva columna, podemos empezar por crear un nuevo vector:

gatos

     color peso legusta_la_cuerda
1    mixto  2.1                 1
2    negro  5.0                 0
3 atigrado  3.2                 1

edad <- c(2,3,5)

Podemos entonces agregarlo como una columna via:

cbind(gatos, edad)

     color peso legusta_la_cuerda edad
1    mixto  2.1                 1    2
2    negro  5.0                 0    3
3 atigrado  3.2                 1    5

Tenga en cuenta que fallará si tratamos de agregar un vector con un número diferente de entradas que el número de filas en el marco de datos.

edad <- c(2, 3, 5, 12)
cbind(gatos, edad)

Error in data.frame(..., check.names = FALSE): arguments imply differing number of rows: 3, 4

edad <- c(2, 3)
cbind(gatos, edad)

Error in data.frame(..., check.names = FALSE): arguments imply differing number of rows: 3, 2

¿Por qué no funcionó? Claro, R quiere ver un elemento en nuestra nueva columna para cada fila de la tabla:

Para que funcione, debemos tener nrow(gatos) = length(edad). Vamos a sobrescribir el contenido de los gatos con nuestro nuevo marco de datos.

edad <- c(2, 3, 5)
gatos <- cbind(gatos, edad)
gatos

     color peso legusta_la_cuerda edad
1    mixto  2.1                 1    2
2    negro  5.0                 0    3
3 atigrado  3.2                 1    5

Ahora, qué tal si agregamos filas, en este caso, la última vez vimos que las filas de un data frame están compuestas por listas:

nueva_fila <- list("carey", 3.3, TRUE, 9)
gatos <- rbind(gatos, nueva_fila)

Warning in `[<-.factor`(`*tmp*`, ri, value = "carey"): invalid factor level, NA
generated

Qué significa el error que nos da R? ‘invalid factor level’ nos dice algo acerca de factores (factors)… pero qué es un factor? Un factor es un tipo de datos en R. Un factor es una categoría (por ejemplo, color) con la que R puede hacer ciertas operaciones. Por ejemplo:

colores <- factor(c("negro","canela","canela","negro"))
levels(colores)

[1] "canela" "negro" 

nlevels(colores)

[1] 2

Se puede reorganizar el orden de los factores para que en lugar de que aparezcan por orden alfabético sigan el orden elegido por el usuario.

colores ## el orden actual

[1] negro  canela canela negro 
Levels: canela negro

colores <- factor(colores, levels = c("negro", "canela"))
colores # despues de re-organizar

[1] negro  canela canela negro 
Levels: negro canela

Factores

Los objetos de la clase factor son otro tipo de datos que debemos usar con cuidado. Cuando R crea un factor, únicamente permite los valores que originalmente estaban allí cuando cargamos los datos. Por ejemplo, en nuestro caso ‘negro’, ‘canela’ y ‘atigrado’. Cualquier categoría nueva que no entre en esas categorías será rechazada (y se conviertirá en NA).

La advertencia (Warning) nos está diciendo que agregamos ‘carey’ a nuestro factor color. Pero los otros valores, 3.3 (de tipo numeric), TRUE (de tipo logical), y 9 (de tipo numeric) se añadieron exitosamente a peso, le_gusta_cuerda, y edad, respectivamente, dado que esos valores no son de tipo factor. Para añadir una nueva categoría ‘carey’ al data frame gatos en la columna color, debemos agregar explícitamente a ‘carey’ como un nuevo nivel (level) en el factor:

levels(gatos$color)

[1] "atigrado" "mixto"    "negro"   

levels(gatos$color) <- c(levels(gatos$color), 'carey')
gatos <- rbind(gatos, list("carey", 3.3, TRUE, 9))

De manera alternativa, podemos cambiar la columna a tipo character. En este caso, perdemos las categorías, pero a partir de ahora podemos incorporar cualquier palabra a la columna, sin problemas con los niveles del factor.

str(gatos)

'data.frame':	5 obs. of  4 variables:
 $ color            : Factor w/ 4 levels "atigrado","mixto",..: 2 3 1 NA 4
 $ peso             : num  2.1 5 3.2 3.3 3.3
 $ legusta_la_cuerda: num  1 0 1 1 1
 $ edad             : num  2 3 5 9 9

gatos$color <- as.character(gatos$color)
str(gatos)

'data.frame':	5 obs. of  4 variables:
 $ color            : chr  "mixto" "negro" "atigrado" NA ...
 $ peso             : num  2.1 5 3.2 3.3 3.3
 $ legusta_la_cuerda: num  1 0 1 1 1
 $ edad             : num  2 3 5 9 9

Desafío 1

Imaginemos que, como los perros, 1 año humano es equivalente a 7 años en los gatos (La compañía Purina usa un algoritmo más sofisticado).

1. Crea un vector llamado human.edad multiplicando gatos$edad por 7.
2. Convierte human.edad a factor.
3. Convierte human.edad de nuevo a un vector numérico usando la función as.numeric(). Ahora, divide por 7 para regresar a las edades originales. Explica lo sucedido.

Solución al Desafío 1

1. human.edad <- gatos$edad * 7
2. human.edad <- factor(human.edad) o as.factor(human.edad) las dos opciones funcionan igual de bien.
3. as.numeric(human.edad) produce 1 2 3 4 4 porque los factores se guardan como objetos de tipo entero integer (1:4), cada uno de los cuales tiene asociado una etiqueta label (28, 35, 56, y 63). Convertir un objeto de un tipo de datos a otro, por ejemplo de factor a numeric nos dá los enteros, no las etiquetas labels. Si queremos los números originales, necesitamos un paso intermedio, debemos convertir human.edad al tipo character y luego a numeric (¿cómo funciona esto?). Esto aparece en la vida real cuando accidentalmente incluimos un character en alguna columna de nuestro archivo .csv, que se suponía que únicamente contendría números. Tendremos este problema, si al leer el archivo olvidamos incluir stringsAsFactors=FALSE.

Quitando filas

Ahora sabemos cómo agregar filas y columnas a nuestro data frame en R, pero en nuestro primer intento para agregar un gato llamado ‘carey’ agregamos una fila que no sirve.

gatos

     color peso legusta_la_cuerda edad
1    mixto  2.1                 1    2
2    negro  5.0                 0    3
3 atigrado  3.2                 1    5
4     <NA>  3.3                 1    9
5    carey  3.3                 1    9

Podemos pedir el data frame sin la fila errónea:

gatos[-4,]

     color peso legusta_la_cuerda edad
1    mixto  2.1                 1    2
2    negro  5.0                 0    3
3 atigrado  3.2                 1    5
5    carey  3.3                 1    9

Notar que -4 significa que queremos remover la cuarta fila, la coma sin nada detrás indica que se aplica a todas las columnas. Podríamos remover ambas filas en un llamado usando ambos números dentro de un vector: gatos[c(-4,-5),]

Alternativamente, podemos eliminar filas que contengan valores NA:

na.omit(gatos)

     color peso legusta_la_cuerda edad
1    mixto  2.1                 1    2
2    negro  5.0                 0    3
3 atigrado  3.2                 1    5
5    carey  3.3                 1    9

Volvamos a asignar el nuevo resultado output al data frame gatos, así nuestros cambios son permanentes:

gatos <- na.omit(gatos)

Eliminando columnas

También podemos eliminar columnas en un data frame. Hay dos formas de eliminar una columna: por número o nombre de índice.

gatos[,-4]

     color peso legusta_la_cuerda
1    mixto  2.1                 1
2    negro  5.0                 0
3 atigrado  3.2                 1
5    carey  3.3                 1

Observa la coma sin nada antes, lo que indica que queremos mantener todas las filas.

Alternativamente, podemos quitar la columna usando el nombre del índice.

drop <- names(gatos) %in% c("edad")
gatos[,!drop]

     color peso legusta_la_cuerda
1    mixto  2.1                 1
2    negro  5.0                 0
3 atigrado  3.2                 1
5    carey  3.3                 1

Añadiendo filas o columnas a un data frame

La clave que hay que recordar al añadir datos a un data frame es que las columnas son vectores o factores, mientras que las filas son listas. Podemos pegar dos data frames usando rbind que significa unir las filas (verticalmente):

gatos <- rbind(gatos, gatos)
gatos

      color peso legusta_la_cuerda edad
1     mixto  2.1                 1    2
2     negro  5.0                 0    3
3  atigrado  3.2                 1    5
5     carey  3.3                 1    9
11    mixto  2.1                 1    2
21    negro  5.0                 0    3
31 atigrado  3.2                 1    5
51    carey  3.3                 1    9

Pero ahora los nombres de las filas rownames son complicados. Podemos removerlos y R los nombrará nuevamente, de manera secuencial:

rownames(gatos) <- NULL
gatos

     color peso legusta_la_cuerda edad
1    mixto  2.1                 1    2
2    negro  5.0                 0    3
3 atigrado  3.2                 1    5
4    carey  3.3                 1    9
5    mixto  2.1                 1    2
6    negro  5.0                 0    3
7 atigrado  3.2                 1    5
8    carey  3.3                 1    9

Desafío 2

Puedes crear un nuevo data frame desde R con la siguiente sintaxis:

df <- data.frame(id = c('a', 'b', 'c'),
                 x = 1:3,
                 y = c(TRUE, TRUE, FALSE),
                 stringsAsFactors = FALSE)

Crear un data frame que contenga la siguiente información personal:

• nombre
• apellido
• número favorito

Luego usa rbind para agregar una entrada para la gente sentada alrededor tuyo. Finalmente, usa cbind para agregar una columna con espacio para que cada persona conteste a la siguiente pregunta: “¿Es hora de una pausa?”

Solución al Desafío 2

df <- data.frame(first = c('Grace'),
                 apellido = c('Hopper'),
                 numero_favorito = c(0),
                 stringsAsFactors = FALSE)
df <- rbind(df, list('Marie', 'Curie', 238) )
df <- cbind(df, cafe = c(TRUE,TRUE))

Ejemplo realista

Hasta ahora, hemos visto las manipulaciones básicas que pueden hacerse en un data frame. Ahora, vamos a extender esas habilidades con un ejemplo más real. Vamos a importar el gapminder dataset que descargamos previamente:

La función read.table se usa para leer datos tabulares que están guardados en un archivo de texto, donde las columnas de datos están separadas por un signo de puntuación como en los archivos CSV (donde csv es comma-separated values en inglés, es decir, valores separados por comas).

Los signos de puntuación más comunmente usados para separar o delimitar datos en archivos de texto son tabuladores y comas. Por conveniencia, R provee dos versiones de la función read.table. Estas versiones son: read.csv para archivos donde los datos están separados por comas y read.delim para archivos donde los datos están separados por tabuladores. De las tres variantes, read.csv es la más comúnmente usada. De ser necesario, es posible sobrescribir el signo de puntuación usado por defecto para ambas funciones: read.csv y read.delim.

gapminder <- read.csv("data/gapminder-FiveYearData.csv")

Tips misceláneos

• Otro tipo de archivo que puedes encontrar es el separado por tabuladores (.tsv). Para especificar este separador, usa "\t" o read.delim().

• Los archivos pueden descargarse de Internet a una carpeta local usando download.file. La función read.csv puede ser ejecutada para leer el archivo descargado, por ejemplo:

download.file("https://raw.githubusercontent.com/swcarpentry/r-novice-gapminder/gh-pages/_episodes_rmd/data/gapminder-FiveYearData.csv", destfile = "data/gapminder-FiveYearData.csv")
gapminder <- read.csv("data/gapminder-FiveYearData.csv")

• De manera alternativa, puedes leer los archivos directamente en R, usando una dirección web y read.csv. Es importante notar que, si se hace esto último, no habrá una copia local del archivo csv en tu computadora. Por ejemplo,

gapminder <- read.csv("https://raw.githubusercontent.com/swcarpentry/r-novice-gapminder/gh-pages/_episodes_rmd/data/gapminder-FiveYearData.csv")

• Puedes leer directamente planillas de Excel sin necesidad de convertirlas a texto plano usando el paquete readxl.

Vamos a investigar gapminder un poco; lo primero que hay que hacer siempre es ver cómo se ve el dataset usando str:

str(gapminder)

'data.frame':	1704 obs. of  6 variables:
 $ country  : chr  "Afghanistan" "Afghanistan" "Afghanistan" "Afghanistan" ...
 $ year     : int  1952 1957 1962 1967 1972 1977 1982 1987 1992 1997 ...
 $ pop      : num  8425333 9240934 10267083 11537966 13079460 ...
 $ continent: chr  "Asia" "Asia" "Asia" "Asia" ...
 $ lifeExp  : num  28.8 30.3 32 34 36.1 ...
 $ gdpPercap: num  779 821 853 836 740 ...

También podemos examinar columnas individuales del data frame con la función typeof:

typeof(gapminder$year)

[1] "integer"

typeof(gapminder$country)

[1] "character"

str(gapminder$country)

 chr [1:1704] "Afghanistan" "Afghanistan" "Afghanistan" "Afghanistan" ...

También podemos interrogar al data frame por la información sobre sus dimensiones; recordando que str(gapminder) dijo que había 1704 observaciones de 6 variables en gapminder, ¿qué piensas que el siguiente código producirá y por qué?

length(gapminder)

[1] 6

Un intento certero hubiera sido decir que el largo (length) de un data frame es el número de filas (1704), pero no es el caso; recuerda, un data frame es una lista de vectores y factors.

typeof(gapminder)

[1] "list"

Cuando length devuelve 6, es porque gapminder está construida por una lista de 6 columnas. Para conseguir el número de filas, intenta:

nrow(gapminder)

[1] 1704

ncol(gapminder)

[1] 6

O, para obtener ambos de una vez:

dim(gapminder)

[1] 1704    6

Probablemente queremos saber los nombres de las columnas. Para hacerlo, podemos pedir:

colnames(gapminder)

[1] "country"   "year"      "pop"       "continent" "lifeExp"   "gdpPercap"

A esta altura, es importante preguntarnos si la estructura de R está en sintonía con nuestra intuición y nuestras expectativas, ¿tienen sentido los tipos de datos reportados para cada columna? Si no lo tienen, necesitamos resolver cualquier problema antes de que se conviertan en sorpresas ingratas luego. Podemos hacerlo usando lo que aprendimos sobre cómo R interpreta los datos y la importancia de la estricta consistencia con la que registramos los datos.

Una vez que estamos contentos con el tipo de datos y que la estructura parece razonable, es tiempo de empezar a investigar nuestros datos. Mira las siguientes líneas:

head(gapminder)

      country year      pop continent lifeExp gdpPercap
1 Afghanistan 1952  8425333      Asia  28.801  779.4453
2 Afghanistan 1957  9240934      Asia  30.332  820.8530
3 Afghanistan 1962 10267083      Asia  31.997  853.1007
4 Afghanistan 1967 11537966      Asia  34.020  836.1971
5 Afghanistan 1972 13079460      Asia  36.088  739.9811
6 Afghanistan 1977 14880372      Asia  38.438  786.1134

Desafío 3

También es útil revisar algunas líneas en el medio y el final del data frame ¿Cómo harías eso?

Buscar líneas exactamente en el medio no es tan difícil, pero simplemente revisar algunas lineas al azar es suficiente. ¿cómo harías eso?

Solución al desafío 3

Para revisar las últimas líneas del data frame R tiene una función para esto:

tail(gapminder)

      country year      pop continent lifeExp gdpPercap
1699 Zimbabwe 1982  7636524    Africa  60.363  788.8550
1700 Zimbabwe 1987  9216418    Africa  62.351  706.1573
1701 Zimbabwe 1992 10704340    Africa  60.377  693.4208
1702 Zimbabwe 1997 11404948    Africa  46.809  792.4500
1703 Zimbabwe 2002 11926563    Africa  39.989  672.0386
1704 Zimbabwe 2007 12311143    Africa  43.487  469.7093

tail(gapminder, n = 15)

      country year      pop continent lifeExp gdpPercap
1690   Zambia 1997  9417789    Africa  40.238 1071.3538
1691   Zambia 2002 10595811    Africa  39.193 1071.6139
1692   Zambia 2007 11746035    Africa  42.384 1271.2116
1693 Zimbabwe 1952  3080907    Africa  48.451  406.8841
1694 Zimbabwe 1957  3646340    Africa  50.469  518.7643
1695 Zimbabwe 1962  4277736    Africa  52.358  527.2722
1696 Zimbabwe 1967  4995432    Africa  53.995  569.7951
1697 Zimbabwe 1972  5861135    Africa  55.635  799.3622
1698 Zimbabwe 1977  6642107    Africa  57.674  685.5877
1699 Zimbabwe 1982  7636524    Africa  60.363  788.8550
1700 Zimbabwe 1987  9216418    Africa  62.351  706.1573
1701 Zimbabwe 1992 10704340    Africa  60.377  693.4208
1702 Zimbabwe 1997 11404948    Africa  46.809  792.4500
1703 Zimbabwe 2002 11926563    Africa  39.989  672.0386
1704 Zimbabwe 2007 12311143    Africa  43.487  469.7093

Para revisar algunas lineas al azar?

sugerencia: Hay muchas maneras de hacer esto

La solución que presentamos aquí utiliza funciones anidadas, por ejemplo una función es el argumento de otra función. Esto te puede parecer nuevo, pero ya lo haz usado. Recuerda my_dataframe[rows, cols] imprime el data frame con la sección de filas y columnas definidas (incluso puedes seleccionar un rando de filas y columnas usando : por ejemplo). Para obtener un número al azar o varios números al azar R tiene una función llamada sample.

gapminder[sample(nrow(gapminder), 5), ]

       country year      pop continent lifeExp gdpPercap
462      Egypt 1977 38783863    Africa  53.319  2785.494
134    Bolivia 1957  3211738  Americas  41.890  2127.686
984  Mauritius 2007  1250882    Africa  72.801 10956.991
1475    Sweden 2002  8954175    Europe  80.040 29341.631
1422     Spain 1977 36439000    Europe  74.390 13236.921

Para que nuestro análisis sea reproducible debemos poner el código en un script al que podremos volver y editar en el futuro.

Desafío 4

Ve a Archivo -> nuevo -> R script, y crea un script de R llamado load-gapminder.R para cargar el dataset gapminder. Ponlo en el directorio scripts/ y agrégalo al control de versiones.

Ejecuta el script usando la función source, usando el path como su argumento o apretando el botón de “source” en RStudio.

Solución al desafío 4

Los contenidos de scripts/load-gapminder.R:

download.file("https://raw.githubusercontent.com/swcarpentry/r-novice-gapminder/gh-pages/_episodes_rmd/data/gapminder-FiveYearData.csv", destfile = "data/gapminder-FiveYearData.csv")
gapminder <- read.csv(file = "data/gapminder-FiveYearData.csv")

Para ejecutar el script y cargar los archivos en la variable gapminder:

Para ejecutar el script y cargar los archivos en la variable gapminder:

source(file = "scripts/load-gapminder.R")

Desafío 5

Leer el output de str(gapminder) de nuevo; esta vez, usar lo que has aprendido de factores, listas y vectores, las funciones como colnames y dim para explicar qué significa el output de str. Si hay partes que no puedes entender, discútelo con tus compañeros.

Solución desafío 5

El objeto gapminder es un data frame con columnas

• country y continent como factors.
• year como integer vector.
• pop, lifeExp, and gdpPercap como numeric vectors.

Puntos Clave

• Usar cbind() para agregar una nueva columna a un data frame

• Usar rbind() para agregar una nueva fila a un data frame

• Quitar filas de un data frame

• Usar na.omit() para remover filas de un data frame con valores NA

• Usar levels() y as.character() para explorar y manipular columnas de clase factor

• Usar str(), nrow(), ncol(), dim(), colnames(), rownames(), head() y typeof() para entender la estructura de un data frame

• Leer un archivo csv usando read.csv()

• Entender el uso de length() en un data frame

Haciendo subconjuntos de datos

Hoja de ruta

Enseñando: 35 min
Prácticas: 15 min

Preguntas

• ¿Cómo puedo trabajar con subconjuntos de datos en R?

Objetivos

• Ser capaz de hacer subconjuntos de vectores, factores, matrices, listas y data frames.

• Ser capaz de extraer uno o multiples elementos: por posición, por nombre, o usando operaciones de comparación.

• Ser capaz de saltar y quitar elementos de diferentes estructuras de datos.

R dispone de muchas operaciones para generar subconjuntos. Dominarlas te permitirá hacer fácilmente operaciones muy complejas en cualquier dataset.

Existen seis maneras distintas por las cuales se puede hacer un subconjunto de datos de cualquier objeto, y existen tres operadores distintos para hacer subconjuntos para las diferentes estructuras de datos.

Empecemos con el caballito de batalla de R: un vector numérico.

x <- c(5.4, 6.2, 7.1, 4.8, 7.5)
names(x) <- c('a', 'b', 'c', 'd', 'e')
x

  a   b   c   d   e 
5.4 6.2 7.1 4.8 7.5 

Vectores atómicos

En R, un vector puede contener palabras, números o valores lógicos. Estos son llamados vectores atómicos ya que no se pueden simplificar más.

Ya que creamos un vector ejemplo juguemos con él, ¿cómo podemos acceder a su contenido?

Accediendo a los elementos del vector usando sus índices

Para extraer elementos o datos de un vector podemos usar su índice correspondiente, empezando por uno:

x[1]

  a 
5.4 

x[4]

  d 
4.8 

No lo parece, pero el operador corchetes es una función. Para los vectores (y las matrices), esto significa “dame el n-ésimo elemento”.

También podemos pedir varios elementos al mismo tiempo:

x[c(1, 3)]

  a   c 
5.4 7.1 

O podemos tomar un rango del vector:

x[1:4]

  a   b   c   d 
5.4 6.2 7.1 4.8 

el operador : crea una sucesión de números del valor a la izquierda hasta el de la derecha.

1:4

[1] 1 2 3 4

c(1, 2, 3, 4)

[1] 1 2 3 4

También podemos pedir el mismo elemento varias veces:

x[c(1,1,3)]

  a   a   c 
5.4 5.4 7.1 

Si pedimos por índices mayores a la longitud del vector, R regresará un valor faltante.

x[6]

<NA> 
  NA 

<NA> 
  NA 

Error: <text>:1:1: unexpected '<'
1: <
    ^

Este es un vector de longitud uno que contiene un NA, cuyo nombre también es NA.

Si pedimos el elemento en el índice 0, obtendremos un vector vacío.

x[0]

named numeric(0)

La numeración de R comienza en 1

En varios lenguajes de programación (C y Python por ejemplo), el primer elemento de un vector tiene índice 0. En R, el primer elemento tiene el índice 1.

Saltando y quitando elementos

Si usamos un valor negativo como índice para un vector, R regresará cada elemento excepto lo que se ha especificado:

x[-2]

  a   c   d   e 
5.4 7.1 4.8 7.5 

También podemos saltar o no mostrar varios elementos:

x[c(-1, -5)]  # o bien x[-c(1,5)]

  b   c   d 
6.2 7.1 4.8 

Sugerencia: Orden de las operaciones

Un pequeño obstáculo para los novatos ocurre cuando tratan de saltar rangos de elementos de un vector. Es natural tratar de filtrar una sucesión de la siguiente manera:

x[-1:3]

Esto nos devuelve un error algo críptico:

Error in x[-1:3]: only 0's may be mixed with negative subscripts

Pero recuerda el orden de las operaciones. : es en realidad una función. Toma como primer elemento -1 y como segundo 3, por lo que se genera la sucesión de números: c(-1, 0, 1, 2, 3).

La solución correcta sería empaquetar la llamada de la función dentro de paréntesis, de está manera el operador - se aplica al resultado:

x[-(1:3)]

  d   e 
4.8 7.5 

Para quitar los elementos de un vector, será necesario que asignes el resultado de vuelta a la variable:

x <- x[-4]
x

  a   b   c   e 
5.4 6.2 7.1 7.5 

Desafío 1

Dado el siguiente código:

x <- c(5.4, 6.2, 7.1, 4.8, 7.5)
names(x) <- c('a', 'b', 'c', 'd', 'e')
print(x)

  a   b   c   d   e 
5.4 6.2 7.1 4.8 7.5 

Encuentra al menos 3 comandos distintos que produzcan la siguiente salida:

  b   c   d 
6.2 7.1 4.8 

Después de encontrar los tres comandos distintos, compáralos con los de tu vecino. ¿Tuvieron distintas estrategias?

Solución al desafío 1

x[2:4]

  b   c   d 
6.2 7.1 4.8 

x[-c(1,5)]

  b   c   d 
6.2 7.1 4.8 

x[c("b", "c", "d")]

  b   c   d 
6.2 7.1 4.8 

x[c(2,3,4)]

  b   c   d 
6.2 7.1 4.8 

Haciendo subconjuntos por nombre

Podemos extraer elementos usando sus nombres, en lugar de extraerlos por índice:

x <- c(a=5.4, b=6.2, c=7.1, d=4.8, e=7.5) # podemos nombrar un vector en la misma línea
x[c("a", "c")]

  a   c 
5.4 7.1 

Esta forma es mucho más segura para hacer subconjuntos: las posiciones de muchos elementos pueden cambiar a menudo cuando estamos creando una cadena de subconjuntos, ¡pero los nombres siempre permanecen iguales!

Creando subconjuntos usando operaciones lógicas

También podemos usar un vector con elementos lógicos para hacer subconjuntos:

x[c(FALSE, FALSE, TRUE, FALSE, TRUE)]

  c   e 
7.1 7.5 

Dado que los operadores de comparación (e.g. >, <, ==) dan como resultado valores lógicos, podemos usarlos para crear subconjuntos de manera mas sintética: la siguiente instrucción tiene el mismo resultado que el anterior.

x[x > 7]

  c   e 
7.1 7.5 

Explicando un poco lo que sucedió, la instrucción x>7, genera un vector lógico c(FALSE, FALSE, TRUE, FALSE, TRUE) y después éste selecciona los elementos de x correspondientes a los valores TRUE.

Podemos usar == para imitar el método anterior de indexar con nombre (recordemos que se usa == en vez de = para comparar):

x[names(x) == "a"]

  a 
5.4 

Sugerencia: Combinando condiciones lógicas

Muchas veces queremos combinar varios criterios lógicos. Por ejemplo, tal vez queramos encontrar todos los países en Asia o (en inglés or) Europe y (en inglés and) con esperanza de vida en cierto rango. Existen muchas operaciones para combinar vectores con elementos lógicos en R:

• &, el operador “lógico AND”: regresa TRUE si tanto la derecha y la izquierda son TRUE.
• |, el operador “lógico OR”: regresa TRUE, si la derecha o la izquierda (o ambos) son TRUE.

A veces encontrarás && y ̣|| en vez de & y |. Los operadores de dos caracteres solo comparan los primeros elementos de cada vector e ignoran las demás elementos. En general no debes usar los operadores de dos caracteres en el análisis de datos; déjalos para la programación, i.e. para decir cuando se ejecutara una instrucción.

• !, el operador “lógico NOT”: convierte TRUE a FALSE y FALSE a TRUE. Puede negar una sola condición lógica (e.g. !TRUE se vuelve FALSE), o un vector logical (e.g. !c(TRUE, FALSE) se vuelve c(FALSE, TRUE)).

Más aún, puedes comparar todos los elementos de un vector entre ellos usando la función all (que regresa TRUE si todos los elementos del vector son TRUE) y la función any (que regresa TRUE si uno o más elementos del vector son TRUE).

Desafío 3

Dado el siguiente código:

x <- c(5.4, 6.2, 7.1, 4.8, 7.5)
names(x) <- c('a', 'b', 'c', 'd', 'e')
print(x)

  a   b   c   d   e 
5.4 6.2 7.1 4.8 7.5 

Escribe un comando para crear el subconjunto de valores de x que sean mayores a 4 pero menores que 7.

Solución al desafío 3

x_subset <- x[x<7 & x>4]
print(x_subset)
```
> {: .solution}
{: .challenge}


> ## Sugerencia: Nombres no únicos
>
> Debes tener en cuenta que es posible que múltiples elementos en un vector tengan el mismo nombre. (Para un
> **data frame**, las columnas pueden tener el mismo nombre ---aunque R intenta evitarlo--- pero los nombres 
> de las filas deben ser únicos).
> Considera estos ejemplos:
>
>
>```{r}
> x <- 1:3
> x
> names(x) <- c('a', 'a', 'a')
> x
> x['a']  # solo devuelve el primer valor
> x[names(x) == 'a']  # devuelve todos los tres valores
> ```
{: .callout}

> ## Sugerencia: Obteniendo ayuda para los operadores
>
> Recuerda que puedes obtener ayuda para los operadores empaquetándolos entre
> comillas:
> `help("%in%")` o `?"%in%"`.
>
{: .callout}

## Saltarse los elementos nombrados

Saltarse o eliminar elementos con nombre es un poco más difícil. Si tratamos de omitir un elemento con nombre al negar la cadena, R se queja (de una manera un poco oscura) de que no sabe cómo tomar el valor negativo de una cadena:

```{r}
x <- c(a=5.4, b=6.2, c=7.1, d=4.8, e=7.5) # comenzamos nuevamente nombrando un vector en la misma línea
x[-"a"]
```

Sin embargo, podemos usar el operador `!=` (no igual) para construir un vector
con elementos lógicos, que es lo que nosotros queremos:

```{r}
x[names(x) != "a"]
```

Saltar varios índices con nombre es un poco más difícil. Supongamos
que queremos excluir los elementos `"a"` y `"c"`, entonces intentamos lo siguiente:

```{r}
x[names(x)!=c("a","c")]
```

R hizo *algo*, pero también nos lanzó una advertencia que debemos atender
-¡y aparentemente *nos dió la respuesta incorrecta*!
(el elemento `"c"` se encuentra todavía en el vector).

¿Entonces qué hizo el operador `!=` en este caso? Esa es una excelente
pregunta.

### Reciclando

Tomemos un momento para observar al operador de comparación en este código:

```{r}
names(x) != c("a", "c")
```

¿Por qué R devuelve `TRUE` como el tercer elemento de este vector, cuando
`names(x)[3] != "c"` es obviamente falso?. Cuando tú usas `!=`, R trata
de comparar cada elemento de la izquierda con el correspondiente elemento
de la derecha. ¿Qué pasa cuando tu comparas dos elementos de diferentes
longitudes?

![Inequality testing](../fig/06-rmd-inequality.1.png)

Cuando uno de los vectores es más corto que el otro, este se *recicla*:

![Inequality testing: results of recycling](../fig/06-rmd-inequality.2.png)

En este caso R **repite** `c("a", "c")` tantas veces como sea necesario
para emparejar `names(x)`, i.e. tenemos `c("a","c","a","c","a")`. Ya que
el valor reciclado `"a"`no es igual a `names(x)`, el valor de `!=` es
`TRUE`. En este caso, donde el vector de mayor longitud (5) no es múltiplo
del más pequeño (2), R lanza esta advertencia. Si
hubiéramos sido lo suficientemente desafortunados y `names(x)` tuviese seis
elementos, R *silenciosamente* hubiera hecho las cosas incorrectas (i.e.,
no lo que deseábamos hacer). Esta regla de reciclaje puede introducir
**bugs** difíciles de encontrar.

La manera de hacer que R haga lo que en verdad queremos (emparejar *cada uno*
de los elementos del argumento de la izquierda con *todos* los elementos del
argumento de la derecha) es usando el operador `%in%`. El operador `%in%`
toma cada uno de los elementos del argumento de la izquierda, en este caso
los nombres de `x`, y pegunta, "¿este elemento ocurre en el segundo argumento?"
Aquí, como queremos *excluir* los valores, nosotros también necesitamos el
operador `!` para cambiar la inclusión por una *no* inclusión:

```{r}
x[! names(x) %in% c("a","c") ]
```

> ## Desafío 2
>
> Seleccionar elementos de un vector que empareje con cualquier valor de
> una lista es una tarea muy común en el análisis de datos. Por ejemplo,
> el **data set** de *gapminder* contiene las variables `country` y
> `continent`, pero no incluye información de la escala.
> Supongamos que queremos extraer la información de el
> sureste de Asia: ¿cómo podemos escribir una operación que resulte en un
> vector lógico que sea `TRUE` para todos los países en el sureste de
> Asia y `FALSE` en otros casos?
>
> Supongamos que se tienen los siguientes datos:
>
>```{r}
> seAsia <- c("Myanmar","Thailand","Cambodia","Vietnam","Laos")
> ## leer los datos de gapminder que bajamos en el episodio 2
> gapminder <- read.csv("data/gapminder-FiveYearData.csv", header=TRUE)
> ## extraer la columna `country` de la **data frame** (veremos esto luego);
> ## convertir de factor a caracter;
> ## y quedarse solo con los elementos no repetidos
> countries <- unique(as.character(gapminder$country))
> ```
>
> Existe una manera incorrecta (usando solamente `==`), la cual te
> dará una advertencia (*warning*); una manera enredada de hacerlo
> (usando los operadores lógicos `==` y `|`) y una manera elegante
> (usando `%in%`). Prueba encontrar esas maneras y explica cómo
> funcionan (o no).
>
## Solución al desafío 2

- La manera **incorrecta** de hacer este problema es `countries==seAsia`.
Esta lanza una advertencia (`"In countries == seAsia : longer object length is not a multiple of shorter object length"`)
y la respuesta incorrecta (un vector con todos los valores `FALSE`), ya
que ninguno de los valores reciclados de `seAsia` se emparejaron correctamente
para coincidir con los valores de `country`.
- La manera **enredada** (pero técnicamente correcta) de resolver
este problema es
```{r results="hide"}
 (countries=="Myanmar" | countries=="Thailand" |
 countries=="Cambodia" | countries == "Vietnam" | countries=="Laos")

Error: attempt to use zero-length variable name

(o countries==seAsia[1] | countries==seAsia[2] | ...). Esto da los valores correctos, pero esperamos que veas lo raro que se ve (¿qué hubiera pasado si hubiéramos querido seleccionar países de una lista mucho más larga?).

• La mejor manera de resolver este problema es countries %in% seAsia, la cual es la correcta y la más sencilla de escribir (y leer).

Manejando valores especiales

En algún momento encontraremos funciones en R que no pueden manejar valores faltantes, infinito o datos indefinidos.

Existen algunas funciones especiales que puedes usar para filtrar estos datos:

• is.na regresa todas las posiciones de un vector, matrix o data frame que contengan NA (o NaN)
• de la misma manera, is.nan y is.infinite hacen lo mismo para NaN e Inf.
• is.finite regresa todas las posiciones de un vector, matrix o data frame que no contengan NA, NaN o Inf.
• na.omit filtra todos los valores faltantes de un vector

Haciendo subconjuntos de factores

Habiendo explorado las distintas manera de hacer subconjuntos de vectores, ¿cómo podemos hacer subconjuntos de otras estructuras de datos?

Podemos hacer subconjuntos de factores de la misma manera que con los vectores.

f <- factor(c("a", "a", "b", "c", "c", "d"))
f[f == "a"]

[1] a a
Levels: a b c d

f[f %in% c("b", "c")]

[1] b c c
Levels: a b c d

f[1:3]

[1] a a b
Levels: a b c d

Saltar elementos no quita el nivel, incluso cuando no existan datos en esa categoría del factor:

f[-3]

[1] a a c c d
Levels: a b c d

Haciendo subconjuntos de matrices

También podemos hacer subconjuntos de matrices usando la función [ En este caso toma dos argumentos: el primero se aplica a las filas y el segundo a las columnas:

set.seed(1)
m <- matrix(rnorm(6*4), ncol=4, nrow=6)
m[3:4, c(3,1)]

            [,1]       [,2]
[1,]  1.12493092 -0.8356286
[2,] -0.04493361  1.5952808

Siempre puedes dejar el primer o segundo argumento vacío para obtener todas las filas o columnas respectivamente:

m[, c(3,4)]

            [,1]        [,2]
[1,] -0.62124058  0.82122120
[2,] -2.21469989  0.59390132
[3,]  1.12493092  0.91897737
[4,] -0.04493361  0.78213630
[5,] -0.01619026  0.07456498
[6,]  0.94383621 -1.98935170

Si quisieramos acceder a solo una fila o una columna, R automáticamente convertirá el resultado a un vector:

m[3,]

[1] -0.8356286  0.5757814  1.1249309  0.9189774

Si quieres mantener la salida como una matriz, necesitas especificar un tercer argumento; drop = FALSE:

m[3, , drop=FALSE]

           [,1]      [,2]     [,3]      [,4]
[1,] -0.8356286 0.5757814 1.124931 0.9189774

A diferencia de los vectores, si tratamos de acceder a una fila o columna fuera de la matriz, R arrojará un error:

m[, c(3,6)]

Error in m[, c(3, 6)]: subscript out of bounds

Sugerencia: Arrays de más dimensiones

Cuando estamos lidiando con arrays multi-dimensionales, cada uno de los argumentos de [ corresponden a una dimensión. Por ejemplo,en un array 3D, los primeros tres argumentos corresponden a las filas, columnas y profundidad.

Como las matrices son vectores, podemos también hacer subconjuntos usando solo un argumento:

m[5]

[1] 0.3295078

Normalmente esto no es tan útil y muchas veces difícil de leer. Sin embargo es útil notar que las matrices están acomodadas en un formato column-major por defecto. Esto significa que los elementos del vector están acomodados por columnas:

matrix(1:6, nrow=2, ncol=3)

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

Si quisieramos llenar una matriz por filas, usamos byrow=TRUE:

matrix(1:6, nrow=2, ncol=3, byrow=TRUE)

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6

Podemos también hacer subconjuntos de las matrices usando los nombres de sus filas y de sus columnas en vez de usar sus índices.

Desafío 4

Dado el siguiente código:

m <- matrix(1:18, nrow=3, ncol=6)
print(m)

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    4    7   10   13   16
[2,]    2    5    8   11   14   17
[3,]    3    6    9   12   15   18

1. ¿Cuál de los siguientes comandos extraerá los valores 11 y 14?

A. m[2,4,2,5]

B. m[2:5]

C. m[4:5,2]

D. m[2,c(4,5)]

Solución al desafío 4

D

Haciendo subconjuntos de listas

Ahora introduciremos un nuevo operador para hacer subconjuntos. Existen tres funciones para hacer subconjuntos de listas. Ya las hemos visto cuando aprendimos los vectores atómicos y las matrices: [, [[ y $.

Usando [ siempre se obtiene una lista. Si quieres un subconjunto de una lista, pero no quieres extraer un elemento, entonces probablemente usarás [.

xlist <- list(a = "Software Carpentry", b = 1:10, data = head(mtcars))
xlist[1]

$a
[1] "Software Carpentry"

Esto regresa una lista de un elemento.

Podemos hacer subconjuntos de elementos de la lista de la misma manera que con los vectores atómicos usando [. Las operaciones de comparación sin embargo no funcionan, ya que no son recursivas, estas probarán la condición en la estructura de datos de los elementos de la lista, y no en los elementos individuales de dichas estructuras de datos.

xlist[1:2]

$a
[1] "Software Carpentry"

$b
 [1]  1  2  3  4  5  6  7  8  9 10

Para extraer elementos individuales de la lista, tendrás que hacer uso de la función doble corchete: [[.

xlist[[1]]

[1] "Software Carpentry"

Nota que ahora el resultados es un vector, no una lista.

No puedes extraer más de un elemento al mismo tiempo:

xlist[[1:2]]

Error in xlist[[1:2]]: subscript out of bounds

Tampoco puedes usarlo para saltar elementos:

xlist[[-1]]

Error in xlist[[-1]]: invalid negative subscript in get1index <real>

Pero tú puedes usar los nombres para hacer subconjuntos y extraer elementos:

xlist[["a"]]

[1] "Software Carpentry"

La función $ es una manera abreviada para extraer elementos por nombre:

xlist$data

                   mpg cyl disp  hp drat    wt  qsec vs am gear carb
Mazda RX4         21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
Mazda RX4 Wag     21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
Valiant           18.1   6  225 105 2.76 3.460 20.22  1  0    3    1

Desafío 5

Dada la siguiente lista:

xlist <- list(a = "Software Carpentry", b = 1:10, data = head(mtcars))

Usando tu conocimiento para hacer subconjuntos de listas y vectores, extrae el número 2 de xlist. Pista: el número 2 está contenido en el elemento “b” de la lista.

Solución al desafío 5

xlist$b[2]

[1] 2

xlist[[2]][2]

[1] 2

xlist[["b"]][2]

[1] 2

Desafío 6

Dado un modelo lineal:

mod <- aov(pop ~ lifeExp, data=gapminder)

Extrae los grados de libertad residuales (pista: attributes() te puede ayudar)

Solución del desafío 6

attributes(mod) ## `df.residual` es uno de los nombres de `mod`

mod$df.residual

Data frames

Recordemos que las data frames son listas, por lo que aplican reglas similares. Sin embargo estos también son objetos de dos dimensiones:

[ con un argumento funcionará de la misma manera que para las listas, donde cada elemento de la lista corresponde a una columna. El objeto devuelto será una data frame:

head(gapminder[3])

       pop
1  8425333
2  9240934
3 10267083
4 11537966
5 13079460
6 14880372

Similarmente, [[ extraerá una sola columna:

head(gapminder[["lifeExp"]])

[1] 28.801 30.332 31.997 34.020 36.088 38.438

Con dos argumentos, [ se comporta de la misma manera que para las matrices:

gapminder[1:3,]

      country year      pop continent lifeExp gdpPercap
1 Afghanistan 1952  8425333      Asia  28.801  779.4453
2 Afghanistan 1957  9240934      Asia  30.332  820.8530
3 Afghanistan 1962 10267083      Asia  31.997  853.1007

Si nuestro subconjunto es una sola fila, el resultado será una data frame (porque los elementos son de distintos tipos):

gapminder[3,]

      country year      pop continent lifeExp gdpPercap
3 Afghanistan 1962 10267083      Asia  31.997  853.1007

Pero para una sola columna el resultado será un vector (esto puede cambiarse con el tercer argumento, drop = FALSE).

Desafío 7

Corrige cada uno de los siguientes errores para hacer subconjuntos de data frames:

1. Extraer observaciones colectadas en el año 1957

   gapminder[gapminder$year = 1957,]
   

2. Extraer todas las columnas excepto de la 1 a la 4

   gapminder[,-1:4]

1. Extraer las filas donde la esperanza de vida es mayor a 80 años

   gapminder[gapminder$lifeExp > 80]
   

2. Extraer la primer fila, y la cuarta y quinta columna (lifeExp y gdpPercap).

   gapminder[1, 4, 5]
   

3. Avanzado: extraer las filas que contienen información para los años 2002 y 2007

   gapminder[gapminder$year == 2002 | 2007,]
   

Solución del desafío 7

Corrige cada uno de los siguientes errores para hacer subconjuntos de data frames:

1. Extraer observaciones colectadas en el año 1957

   # gapminder[gapminder$year = 1957,]
   gapminder[gapminder$year == 1957,]
   

2. Extraer todas las columnas excepto de la 1 a la 4

   # gapminder[,-1:4]
   gapminder[,-c(1:4)]
   

3. Extraer las filas donde la esperanza de vida es mayor a 80 años

   # gapminder[gapminder$lifeExp > 80]
   gapminder[gapminder$lifeExp > 80,]
   

4. Extraer la primer fila, y la cuarta y quinta columna (lifeExp y gdpPercap).

   # gapminder[1, 4, 5]
   gapminder[1, c(4, 5)]
   

5. Avanzado: extraer las filas que contienen información para los años 2002 y 2007

    # gapminder[gapminder$year == 2002 | 2007,]
    gapminder[gapminder$year == 2002 | gapminder$year == 2007,]
    gapminder[gapminder$year %in% c(2002, 2007),]
   

Desafío 8

1. ¿Por qué gapminder[1:20] regresa un error? ¿En qué difiere de gapminder[1:20, ]?

2. Crea un data.frame llamado gapminder_small que solo contenga las filas del 1 al 9 y del 19 al 23. Puedes hacerlo en uno o dos pasos.

Solución al desafío 8

1. gapminder es un data.frame por lo que para hacer un subconjunto necesita dos dimensiones. gapminder[1:20, ] genera un subconjunto de los datos de las primeras 20 filas y todas las columnas.

2.

gapminder_small <- gapminder[c(1:9, 19:23),]

Puntos Clave

• Los índices en R comienzan con 1, no con 0.

• Acceso a un elemento por posición usando [].

• Acceso a un rango de datos usando [min:max].

• Acceso a subconjuntos arbitrarios usando [c(...)].

• Usar operaciones lógicas y vectores lógicos para acceder a subconjuntos de datos

Control de flujo

Hoja de ruta

Enseñando: 45 min
Prácticas: 20 min

Preguntas

• ¿Cómo puedo hacer elecciones dependiendo de mis datos en R?

• ¿Cómo puedo repetir operaciones en R?

Objetivos

• Escribir declaraciones condicionales utilizando if() y else().

• Escribir y entender los bucles con for().

Cuando estamos programando puede que queramos controlar el flujo de nuestras acciones. Esto se puede realizar estableciendo acciones que ocurran solo si se cumple una condición o un conjunto de condiciones. A su vez, podemos hacer que una acción ocurra un número determinado de veces.

Hay varias maneras de controlar el flujo en R. Para declaraciones condicionales, los enfoques más comúnmente utilizados son los constructs:

# if
if (la condición es verdad) {
  realizar una acción
}

# if ... else
if (la condición es verdad) {
  realizar una acción
} else {  # es decir, si la condición es falsa,
  realizar una acción alternativa
}

Digamos, por ejemplo, que queremos que R imprima un mensaje si una variable x tiene un valor en particular:

x <- 8

if (x >= 10) {
  print("x es mayor o igual que 10")
}

x

## [1] 8

La sentencia print “x es mayor o igual que 10” no aparece en la consola porque x no es mayor o igual a 10. Para imprimir un mensaje diferente para numeros menores a 10, podemos agregar una sentencia else

x <- 8

if (x >= 10) {
  print("x es mayor o igual a 10")
} else {
  print("x es menor a 10")
}

## [1] "x es menor a 10"

También podemos testear múltiples condiciones usando else if

x <- 8

if (x >= 10) {
  print("x es mayor o igual a 10")
} else if (x > 5) {
  print("x es mayor a 5, pero menor a 10")
} else{
  print("x es menor a 5")
}

## [1] "x es mayor a 5, pero menor a 10"

Importante: cuando R evalúa las condiciones dentro de if() esta buscando elementos lógicos como TRUE o FALSE. Entender esto puede ser un dolor de cabeza para los principiantes. Por ejemplo:

x  <-  4 == 3
if (x) {
  "4 igual a 3"
} else {
  "4 no es igual a 3"
}

## [1] "4 no es igual a 3"

Como podemos observar se muestra el mensaje es igual porque el vector x es FALSE

x <- 4 == 3
x

## [1] FALSE

Desafío 1

Usa una declaración if() para mostrar un mensaje adecuado reportando si hay algún registro del año 2002 en el dataset gapminder. Luego haz lo mismo para el año 2012.

Solución al Desafío 1

Primero veremos una solución al Desafío 1 que no usa la función any(). Primero obtenemos un vector lógico que describe que el elemento gapminder$year es igual a 2002:

gapminder[(gapminder$year == 2002),]

Luego, contamos el número de filas del data.frame gapminder que corresponde al año 2002:

rows2002_number <- nrow(gapminder[(gapminder$year == 2002),])

La presencia de cualquier registro para el año 2002 es equivalente a la petición de que rows2002_number sea mayor o igual a uno:

rows2002_number >= 1

Entonces podríamos escribir:

if(nrow(gapminder[(gapminder$year == 2002),]) >= 1){
   print("Se encontraron registro(s) para el año 2002.")
}

Todo esto se puede hacer más rápido con any(). En dicho caso la condición lógica se puede expresar como:

if(any(gapminder$year == 2002)){
   print("Se encontraron registro(s) para el año 2002.")
}

¿Alguien recibió un mensaje de advertencia como este?

## Error in eval(expr, envir, enclos): object 'gapminder' not found

Si tu condición se evalúa como un vector con más de un elemento lógico, la función if() todavía se ejecutará, pero solo evaluará la condición en el primer elemento. Aquí debes asegurarte que tu condición sea de longitud 1.

Tip: any() y all()

La función any() devolverá TRUE si hay al menos un valor TRUE dentro del vector, en caso contrario devolverá FALSE. Esto se puede usar de manera similar al operador %in%. La función all(), como el nombre sugiere, devolvera TRUE siempre y cuando todos los valores en el vector son TRUE.

Operaciones repetidas

Si quieres iterar sobre un conjunto de valores, el orden de la iteración es importante y debes realizar la misma operación en cada uno, un bucle for() es lo que estas buscando. Vimos los bucles for() en las lecciones anteriores de terminal. Si bien esta es la operación de bucle más flexible es también la más difícil de usar correctamente. Evita usar bucles for() a menos que el orden de la iteración sea importante como cuando el cálculo de cada iteración dependa del resultado de la iteración previa.

La estructura básica de un bucle for() es:

for(iterador in conjunto de valores){
  haz alguna acción
}

Por ejemplo:

for(i in 1:10){
  print(i)
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9
## [1] 10

El rango 1:10 crea un vector sobre la marcha; puedes iterar sobre cualquier otro vector también.

Podemos usar un bucle for() anidado con otro bucle for() para iterar sobre dos cosas a la vez.

for(i in 1:5){
  for(j in c('a', 'b', 'c', 'd', 'e')){
    print(paste(i,j))
  }
}

## [1] "1 a"
## [1] "1 b"
## [1] "1 c"
## [1] "1 d"
## [1] "1 e"
## [1] "2 a"
## [1] "2 b"
## [1] "2 c"
## [1] "2 d"
## [1] "2 e"
## [1] "3 a"
## [1] "3 b"
## [1] "3 c"
## [1] "3 d"
## [1] "3 e"
## [1] "4 a"
## [1] "4 b"
## [1] "4 c"
## [1] "4 d"
## [1] "4 e"
## [1] "5 a"
## [1] "5 b"
## [1] "5 c"
## [1] "5 d"
## [1] "5 e"

En lugar de mostrar los resultados en la pantalla podríamos guardarlos en un nuevo objeto.

output_vector <- c()
for(i in 1:5){
  for(j in c('a', 'b', 'c', 'd', 'e')){
    temp_output <- paste(i, j)
    output_vector <- c(output_vector, temp_output)
  }
}
output_vector

##  [1] "1 a" "1 b" "1 c" "1 d" "1 e" "2 a" "2 b" "2 c" "2 d" "2 e" "3 a" "3 b"
## [13] "3 c" "3 d" "3 e" "4 a" "4 b" "4 c" "4 d" "4 e" "5 a" "5 b" "5 c" "5 d"
## [25] "5 e"

Este enfoque puede ser útil, pero aumentar o incrementar tus resultados (es decir, construir el objeto resultante de forma incremental) es computacionalmente ineficiente por lo que conviene evitarlo cuando estés iterando a través de muchos valores.

Tip: no incrementes tus resultados

Una de las cosas que más frecuentemente hace tropezar tanto a los principiantes como a los usuarios experimentados de R es la construcción de un objeto de resultados (vector, lista, matriz, data frame) a medida que tu bucle for progresa. Las computadoras son muy malas para manejar esto lo cual puede hacer que tus cálculos se enlentezcan rápidamente. En este caso es mejor definir un objeto de resultados vacío con las dimensiones apropiadas. Si sabes que el resultado final se almacenará en una matriz como la anterior es una buena idea crear una matriz vacía con 5 filas y 5 columnas y luego en cada iteración almacenar los resultados en la ubicación adecuada.

Una mejor manera es definir el objeto de salida (vacío) antes de completar los valores. Aunque para este ejemplo parece más complicado, es aún más eficiente.

output_matrix <- matrix(nrow=5, ncol=5)
j_vector <- c('a', 'b', 'c', 'd', 'e')
for(i in 1:5){
  for(j in 1:5){
    temp_j_value <- j_vector[j]
    temp_output <- paste(i, temp_j_value)
    output_matrix[i, j] <- temp_output
  }
}
output_vector2 <- as.vector(output_matrix)
output_vector2

##  [1] "1 a" "2 a" "3 a" "4 a" "5 a" "1 b" "2 b" "3 b" "4 b" "5 b" "1 c" "2 c"
## [13] "3 c" "4 c" "5 c" "1 d" "2 d" "3 d" "4 d" "5 d" "1 e" "2 e" "3 e" "4 e"
## [25] "5 e"

Tip: Bucles While

Algunas veces tendrás la necesidad de repetir una operación hasta que cierta condición se cumpla. Puedes hacer esto con un bucle while().

while(mientras esta condición es verdad){
  haz algo
}

A modo de ejemplo aquí hay un bucle while que genera números aleatorios a partir de una distribución uniforme (la función runif() ) entre 0 y 1 hasta que obtiene uno que es menor a 0.1.

z <- 1
while(z > 0.1){
  z <- runif(1)
  print(z)
}

Los bucles while() no siempre serán la elección apropiada. Debes ser particularmente cuidadoso de que tu condición se cumpla y no terminar en un bucle infinito.

Desafío 2

Compara los objetos output_vector y output_vector2. ¿Son lo mismo? Si no, ¿por qué no? ¿Cómo cambiarías el último bloque de código para hacer output_vector2 igual a output_vector?

Solución al Desafío 2

Podemos verificar si dos vectores son idénticos usando la función all() :

all(output_vector == output_vector2)

Sin embargo todos los elementos de output_vector se pueden encontrar en output_vector2:

all(output_vector %in% output_vector2)

y viceversa:

all(output_vector2 %in% output_vector)

Por lo tanto, los elementos en output_vector y output_vector2 están en distinto orden. Esto es porque as.vector () genera los elementos leyendo la matriz de entrada por columnas. Si observamos output_matrix podemos notar que deseamos obtener sus elementos ordenados por filas. La solución es transponer la output_matrix. Podemos hacerlo llamando a la función de transposición t () o ingresando los elementos en el orden correcto. La primera solución requiere cambiar el original

output_vector2 <- as.vector(output_matrix)

por

output_vector2 <- as.vector(t(output_matrix))

La segunda solución requiere cambiar

output_matrix[i, j] <- temp_output

por

output_matrix[j, i] <- temp_output

Desafío 3

Escribe un script que a través de bucles recorra los datos gapminder por continente e imprima si la esperanza de vida media es menor o mayor de 50 años.

Solución al Desafío 3

Paso 1: Queremos asegurarnos de que podamos extraer todos los valores únicos del vector continente

gapminder <- read.csv("data/gapminder-FiveYearData.csv")
unique(gapminder$continent)

Paso 2: También tenemos que recorrer cada uno de estos continentes y calcular la esperanza de vida promedio para cada “subconjunto” de datos. Podemos hacer eso de la siguiente manera:

1. Recorre cada uno de los valores únicos de ‘continente’
2. Para cada valor de continente, crea una variable temporal que almacene la vida útil para ese subconjunto,
3. Regresar la expectativa de vida calculada al usuario imprimiendo el resultado:

for( iContinent in unique(gapminder$continent) ){
   tmp <- mean(subset(gapminder, continent==iContinent)$lifeExp)
   cat("Average Life Expectancy in", iContinent, "is", tmp, "\n")
   rm(tmp)
}

Paso 3: El ejercicio solo requiere que se imprima el resultado si la expectativa de vida promedio es menor a 50 o superior a 50. Por lo tanto, debemos agregar una condición ‘if’ antes de imprimir, lo cual evalúa si la expectativa de vida promedio calculada es superior o inferior a un umbral, e imprime una salida condicional en el resultado. Necesitamos corregir (3) desde arriba:

3a. Si la esperanza de vida calculada es menor que algún umbral (50 años), devuelve el continente e imprime la frase “la esperanza de vida es menor que el umbral”, de lo contrario devuelve el continente e imprime la frase “la esperanza de vida es mayor que el umbral”:

thresholdValue <- 50

for( iContinent in unique(gapminder$continent) ){
   tmp <- mean(subset(gapminder, continent==iContinent)$lifeExp)
   
   if(tmp < thresholdValue){
       cat("Average Life Expectancy in", iContinent, "is less than", thresholdValue, "\n")
   }
   else{
       cat("Average Life Expectancy in", iContinent, "is greater than", thresholdValue, "\n")
        } # end if else condition
   rm(tmp)
   } # end for loop

Desafío 4

Modifica el script del Desafío 4 para obtener resultados para cada uno de los países. En esta oportunidad que imprima si la esperanza de vida es menor que 50, se encuentra entre 50 y 70 o es mayor que 70.

Solución al Desafío 4

Modificamos nuestra solución al Reto 3 agregando ahora dos umbrales, lowerThreshold y upperThreshold y extendiendo nuestras declaraciones if-else:

 lowerThreshold <- 50
 upperThreshold <- 70

for( iCountry in unique(gapminder$country) ){
    tmp <- mean(subset(gapminder, country==iCountry)$lifeExp)

    if(tmp < lowerThreshold){
        cat("Average Life Expectancy in", iCountry, "is less than", lowerThreshold, "\n")
    }
    else if(tmp > lowerThreshold && tmp < upperThreshold){
        cat("Average Life Expectancy in", iCountry, "is between", lowerThreshold, "and", upperThreshold, "\n")
    }
    else{
        cat("Average Life Expectancy in", iCountry, "is greater than", upperThreshold, "\n")
    }
    rm(tmp)
}

## Error in unique(gapminder$country): object 'gapminder' not found

Desafío 5 - Avanzado

Escribir un script que con un bucle recorra cada país en el dataset gapminder, probar si el país comienza con una ‘B’ y graficar la esperanza de vida contra el tiempo como un gráfico de líneas si la esperanza de vida media es menor de 50 años.

Solución para el Desafío 5

Lo primero que vamos a hacer es usar el comando grep que se introdujo en la lección Shell de Unix para encontrar países que comiencen con” B “.”

Si seguimos la lección de Shell de Unix podríamos vernos tentados de probar lo siguiente

grep("^B", unique(gapminder$country))

Pero cuando evaluamos este comando obtenemos los índices de la variable del factor country que comienza con “B”. Para obtener los valores, debemos agregar la opción value = TRUE al comando grep:

grep("^B", unique(gapminder$country), value=TRUE)

A continuación almacenaremos estos países en una variable llamada candidateCountries y luego con un bucle recorreremos cada entrada en la variable.

Dentro del bucle se evaluará la expectativa de vida promedio para cada país y de ser menor a 50 usamos un gráfico base para trazar la evolución de la expectativa de vida promedio:

thresholdValue <- 50
candidateCountries <- grep("^B", unique(gapminder$country), value=TRUE)

for( iCountry in candidateCountries){
    tmp <- mean(subset(gapminder, country==iCountry)$lifeExp)

    if(tmp < thresholdValue){
        cat("Average Life Expectancy in", iCountry, "is less than", 
             thresholdValue, "plotting life expectancy graph... \n")

        with(subset(gapminder, country==iCountry),
                plot(year,lifeExp,
                     type="o",
                     main = paste("Life Expectancy in", iCountry, "over time"),
                     ylab = "Life Expectancy",
                     xlab = "Year"
                   ) # end plot
              ) # end with
    } # end for loop
    rm(tmp)
 }