appliedepi/introexercises

Package index
Search the appliedepi/introexercises package
Functions
0
Source code
2
Man pages
0
Home
/
GitHub
/
appliedepi/introexercises
/

In appliedepi/introexercises: 

library(introexercises)  # get data for exercises 
library(learnr)          # create lessons from rmd
library(gradethis)       # evaluate exercises
library(dplyr)           # wrangle data
library(flair)           # highlight code
library(ggplot2)         # visualise data
library(lubridate)       # work with dates
library(fontawesome)     # for emojis
library(janitor)         # clean data
# library(RMariaDB)        # connect to sql database

## set options for exercises and checking ---------------------------------------

## Define how exercises are evaluated 
gradethis::gradethis_setup(
  ## note: the below arguments are passed to learnr::tutorial_options
  ## set the maximum execution time limit in seconds
  exercise.timelimit = 60, 
  ## set how exercises should be checked (defaults to NULL - individually defined)
  # exercise.checker = gradethis::grade_learnr
  ## set whether to pre-evaluate exercises (so users see answers)
  exercise.eval = FALSE 
)

# ## event recorder ---------------------------------------------------------------
# ## see for details:
# ## https://pkgs.rstudio.com/learnr/articles/publishing.html#events
# ## https://github.com/dtkaplan/submitr/blob/master/R/make_a_recorder.R
# 
# ## connect to your sql database
# sqldtbase <- dbConnect(RMariaDB::MariaDB(),
#                        user = 'sander', 
#                        password = 'E9hqb2Tr5GumHHu',
#                        # user     = Sys.getenv("userid"),
#                        # password = Sys.getenv("pwd"),
#                        dbname   = 'excersize_log',
#                        host     = "144.126.246.140")
# 
# 
# ## define a function to collect data
# ## note that tutorial_id is defined in YAML
#     ## you could set the tutorial_version too (by specifying version:) but use package version instead
# recorder_function <- function(tutorial_id, tutorial_version, user_id, event, data) {
# 
#   ## define a sql query
#   ## first bracket defines variable names
#   ## values bracket defines what goes in each variable
#   event_log <- paste("INSERT INTO responses (
#                        tutorial_id,
#                        tutorial_version,
#                        date_time,
#                        user_id,
#                        event,
#                        section,
#                        label,
#                        question,
#                        answer,
#                        code,
#                        correct)
#                        VALUES('", tutorial_id,  "',
#                        '", tutorial_version, "',
#                        '", format(Sys.time(), "%Y-%M%-%D %H:%M:%S %Z"), "',
#                        '", Sys.getenv("SHINYPROXY_PROXY_ID"), "',
#                        '", event, "',
#                        '", data$section, "',
#                        '", data$label,  "',
#                        '", paste0('"', data$question, '"'),  "',
#                        '", paste0('"', data$answer,   '"'),  "',
#                        '", paste0('"', data$code,     '"'),  "',
#                        '", data$correct, "')",
#                        sep = '')
# 
#     # Execute the query on the sqldtbase that we connected to above
#     rsInsert <- dbSendQuery(sqldtbase, event_log)
# 
# }
# 
# options(tutorial.event_recorder = recorder_function)

# hide non-exercise code chunks ------------------------------------------------
knitr::opts_chunk$set(echo = FALSE)

# data prep --------------------------------------------------------------------
vig_cruda <- rio::import(system.file("dat/listado_vigilancia_20141201.csv", package = "introexercises"))

pruebas <- rio::import(system.file("dat/datos_prueba.csv", package = "introexercises"))

Introducción a R para Epidemiología Aplicada y Salud Pública

Bienvenido/a

Bienvenido/a al curso "Introducción a R para epidemiología aplicada", ofrecido por Applied Epi - una organización sin ánimo de lucro y el principal proveedor de formación, apoyo y herramientas de R para profesionales de primera línea en salud pública.

knitr::include_graphics("images/logo.png", error = F)

Preparando R, sintaxis básica e importación de datos

Este ejecicio se centra en configurar R por primera vez y en la introducción de códigos básicos de R

Formato

Este ejercicio te guía a través de las tareas que debes realizar en RStudio en tu ordenador.

Obtener ayuda

Hay varias formas de obtener ayuda:

1) Busca la sección de ayuda (ver más abajo) 2) Pide ayuda al instructor/a o facilitador/a de tu curso en directo 3) Programa una llamada 1 a 1 con un/a instructor/a para "Tutoría del curso". 4) Publica una pregunta en Comunidad Epi Aplicada

Este es el aspecto que tendrán esa sección de ayuda:

r fontawesome::fa("lightbulb", fill = "gold") Haz clic para leer una pista

¡Aquí verás una pista útil!


r fontawesome::fa("check", fill = "red")Haz clic para ver una solución (¡pruébalo tú primero!) 

vig %>% 
  filter(
    edad > 25,
    distrito == "Bolo"
  )

Aquí tienes más explicaciones sobre por qué funciona la solución.


Preguntas del cuestionario

Responder a las preguntas del cuestionario te ayudará a comprender el material. Las respuestas no se registran.

Para practicar, responde a las siguientes preguntas:

quiz(
  question_radio("¿Cuándo debería mirar las secciones de ayuda en rojo?",
    answer("Tras intentar escribir el código yo mismo", correct = TRUE),
    answer("Antes de intentar escribir el código", correct = FALSE),
    correct = "Revisar el código de ejemplo después de intentar escribirlo usted mismo puede ayudarle a mejorar",
    incorrect = "Por favor, intente completar el ejercicio usted mismo, o use las pistas disponibles, antes de mirar la respuesta."
  )
)

question_numeric(
 "¿Qué tan preocupado/a estás ante la idea de empezar este tutorial, en una escala de 1 (nada nervioso) a 10 (extremadamente preocupado/a)?",
 answer(10, message = "Intenta no preocuparte, ¡te ayudaremos a conseguirlo!", correct = T),
 answer(9, message = "Intenta no preocuparte, ¡te ayudaremos a conseguirlo!", correct = T),
 answer(8, message = "Intenta no preocuparte, ¡te ayudaremos a conseguirlo!", correct = T),
 answer(7, message = "Intenta no preocuparte, ¡te ayudaremos a conseguirlo!", correct = T),
 answer(6, message = "De acuerdo, lo conseguiremos juntos", correct = T),
 answer(5, message = "De acuerdo, lo conseguiremos juntos", correct = T),
 answer(4, message = "¡Me gusta tu confianza!", correct = T),
 answer(3, message = "¡Me gusta tu confianza!", correct = T),
 answer(2, message = "¡Me gusta tu confianza!", correct = T),
 answer(1, message = "¡Me gusta tu confianza!", correct = T),
 allow_retry = TRUE,
 correct = "Gracias por responder",
 min = 1,
 max = 10,
 step = 1
)

Licencia

Por favor, envía un correo electrónico a contact@appliedepi.org si tienes preguntas sobre el uso de estos materiales.

Objetivos de aprendizaje

Preparación previa al curso

Si no has podido completar las instalaciones antes del curso, avisa ahora a uno de los/as instructores/as.

Instalar software

Ten instalado en tu ordenador el siguiente software antes del inicio del curso.

1) R (versión más reciente) 2) RStudio (versión más reciente) 3) RTools (sólo se necesita para máquinas Windows, y no es estrictamente necesario)

Si tienes dificultades, consulta a un/a instructor/a o la guía de instalación en la carpeta del curso para obtener consejos (ver paso siguiente).

Descargar los archivos del curso

Si aún no lo has hecho, descarga la carpeta comprimida del curso en este enlace.

Descomprime y extrae la carpeta, y guárdala en el escritorio de tu ordenador (no en una unidad compartida).

Para "descomprimir" una carpeta una vez descargada, haz clic con el botón derecho del ratón en la carpeta y selecciona "Extraer todo". Si se te ofrece la opción de guardar la carpeta descomprimida, guárdala en tu escritorio.

La estructura de la carpeta debería ser la siguiente

Instalar paquetes R

Ya deberías haber instalado los paquetes de R para el curso.

Si aún no lo has hecho, sigue estas instrucciones:

1) Entra en la carpeta "intro_curso", y abre el archivo "paquetes_a_instalar.R". Si es la primera vez que abres un script de R en tu ordenador, puede que tengas que especificar que quieres abrir el archivo utilizando RStudio.

2) Sigue las instrucciones de la parte superior del script. Selecciona TODO el texto del guión y, a continuación, pulsa el botón "Ejecutar" situado cerca de la parte superior central de RStudio. Alternativamente, resalta todo el texto y luego pulsa las teclas Ctrl y Enter.

Este script tardará varios minutos en instalar la mayoría de los paquetes de R que necesitas para este curso.

Comprender R y RStudio

Si aún no lo has hecho, abre RStudio ahora.

Comprender R

R es un lenguaje utilizado para realizar cálculos estadísticos y gráficos. Desarrollado en 1991 y basado en el lenguaje S, se diferencia de otros lenguajes de programación en que su propósito original es el análisis de datos (lee más sobre la historia de R aquí).

R es distinto de otros lenguajes de análisis de datos porque

¿Por qué importa que R sea de "código abierto"?

R no es una empresa y no tiene una 'sede central'. Debido a que es de código abierto, sus herramientas son creadas y revisadas por millones de usuarios. Esta descentralización del poder es intrínsecamente democratizadora y permite a R responder rápidamente a necesidades emergentes, como lo fue la pandemia de COVID-19. Muchas instituciones importantes confían en R y lo utilizan: por ejemplo, la Administración Federal de Alimentos y Medicamentos de EEUU (FDA).

La base del software R está dirigida por un "grupo central" y se actualiza cada pocos meses. A cada versión se le asigna un número, como "R versión 4.1.2 (2021-11-01)", y un nombre fácil de recordar, como "Bird Hippie". En el futuro, podrás actualizar fácilmente tu versión de R volviendo a descargarla. R y RStudio suelen notificar sobre nuevas versiones disponibles y te pedirán que las descargues cuando sea necesario.

Entender RStudio

RStudio es una interfaz para utilizar R. Aunque es posible abrir y utilizar R directamente, es mucho más habitual utilizar R a través de un Entorno de Desarrollo Integrado (IDE) como RStudio, que proporciona una experiencia más amigable y una organización de archivos más sencilla. La empresa Posit ofrece gratuitamente "RStudio".

Cuando abras RStudio, encontrarás y utilizarás automáticamente la versión de R instalada en tu ordenador. No es necesario abrir ambos programas por separado.

Puedes pensar en R como el motor de un vehículo haciendo el trabajo crucial, y RStudio como el cuerpo del vehículo (el chasis, los asientos, los accesorios, etc.).

Cuestionario

Ahora, comprueba tus conocimientos de R y RStudio respondiendo a las preguntas siguientes:

quiz(caption = "Cuestionario: R and RStudio",

   question("¿Qué es RStudio?",
            allow_retry = TRUE,
    answer("Una aplicación que facilita el uso de R.",
           correct = TRUE,
           message = "RStudio es un Entorno de Desarrollo Integrado (IDE) que facilita la escritura, el uso, la corrección y el almacenamiento de código en R."),
    answer("Una grilla como en Microsoft Excel."),
    answer("Otro nombre para R",
           message = "R y RStudio son dos elementos distintos. Mientras que R es un lenguaje de programación, similar al francés o al español, RStudio puede ser visto como un programa que facilita su uso, de manera similar a cómo un procesador de texto te permite escribir en un idioma específico."),
    answer("Una aplicación que te permite usar R sin escribir ningún código",
           message = "Aún tienes que escribir código, ¡y eso es positivo! Escribir código te permite mantener un registro reproducible de tu trabajo, lo cual es fundamental para seguir las mejores prácticas.")
  ),


  question("¿Se puede descargar y usar RStudio gratuitamente?",
    answer("Sí",
           correct = TRUE,
           message = "El IDE de RStudio es un software ofrecido gratuitamente por la compañía Posit. Aunque existen otros IDE para usar R, como Tinn-R y Emacs, son menos comunes en comparación."),
    answer("No",
           message = "El IDE de RStudio es gratuito y de código abierto.")
  ),

  question("¿Tienes que instalar R y RStudio?",
    answer("Sí",
           correct = TRUE,
           message = "Aunque es posible trabajar con R sin utilizar una interface como RStudio, no es recomendable para principiantes."),
    answer("No",
           message = "Aunque es posible trabajar con R sin utilizar una interface como RStudio, no es recomendable para principiantes.")
  ),

  question("Una vez que ambos programas estén instalados, ¿cuál deberías abrir para comenzar a trabajar?",
    answer("RStudio",
           correct = TRUE,
           message = "Abrir RStudio iniciará automáticamente R."),
    answer("R",
           message = "Para principiantes es mejor trabajar con R a través de RStudio. Comienza por abrir RStudio."))
)

Un recorrido por RStudio

Echa un vistazo a RStudio. Observa los principales paneles de RStudio. Deberías ver 3 ó 4 paneles: 1) El panel Consola (izquierda o inferior-izquierda)
2) El panel Entorno (arriba-derecha)
3) El panel de Archivos, Gráficos, Paquetes, Ayuda y Visor (abajo a la derecha)
4) El panel Fuente (arriba a la izquierda). Si sólo ves estos 3 paneles, haz clic en Archivo -> Nuevo archivo -> Script R para abrir un nuevo Script R y conseguir el aspecto clásico de abajo.

Tómate unos minutos para familiarizarte con la ubicación de los distintos paneles, utilizando el diagrama que aparece a continuación.

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/rstudio_overview.png", error = F)

Panel Fuente (arriba a la izquierda)

Este panel es un espacio destinado a editar y ejecutar tus scripts, donde puedes escribir los comandos de R. También muestra conjuntos de datos. Para los usuarios de Stata, este panel es similar a las ventanas Archivo-Do y Editor de Datos.

El panel de la Consola R (abajo a la izquierda)

El software R en sí mismo actúa como el "motor" que ejecuta los comandos. Aquí se muestran las salidas no gráficas y los mensajes de error/advertencia. Puedes ingresar comandos directamente en la Consola de R, pero estos no se guardan como ocurre cuando se ejecutan desde un script. Si estás familiarizado con Stata, la Consola de R es similar a la Ventana de Comandos y también a la Ventana de Resultados.

El panel Entorno (arriba a la derecha)

Este panel muestra los objetos disponibles para ti, que pueden incluir conjuntos de datos o valores específicos que hayas guardado para su uso posterior, como por ejemplo, un número específico de "semana epidemiológica". En Stata, es muy similar a la ventana del Gestor de Variables.

Archivos, Gráficos, Paquetes, Ayuda y Panel Visualizador (abajo a la derecha)

El panel consta de varias pestañas. La pestaña Archivos sirve como navegador para abrir, renombrar o borrar archivos. En la pestaña Gráficos se muestran gráficos y diagramas, mientras que las salidas interactivas se visualizan en el panel Visor. La pestaña Ayuda ofrece documentación y archivos de ayuda. La pestaña Paquetes te permite instalar, actualizar y cargar/descargar paquetes de R. Esta pestaña corresponde a los equivalentes en Stata de las ventanas Gestor de Gráficos y Gestor de Proyectos.

Para más detalles sobre las capacidades de RStudio, descarga este PDF: Hoja de trucos del IDE.

Configuración del espacio de trabajo de RStudio

Cuando instales RStudio por primera vez, es importante ajustar una configuración por defecto.

Sigue estos pasos en tu sesión de RStudio ahora:

  1. Ir a RStudio Herramientas (busca este menú desplegable en la parte superior de RStudio).
  2. Selecciona la última opción "Opciones globales" y verás aparecer una ventana emergente.
# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/RStudio_tools_options_1.png", error = F)
  1. Consulta la sección de la pestaña General llamada "Espacio de trabajo" y desmarca la casilla "Restaurar .RData en el espacio de trabajo al inicio".
  2. Establece el menú desplegable que hay justo debajo en "Nunca" guardar el espacio de trabajo en .RData al salir.
# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/options_rdata.png", error = F)

¿Por qué recomendamos esto? A largo plazo, te convertirás en un mejor programador si RStudio comienza vacío o con una "pizarra limpia" cada vez que lo abras. Esto te obliga a escribir código completo, sin depender de lo que hiciste en una sesión anterior. Así, tu análisis será más "reproducible" y evitarás dolores de cabeza al compartir el código con otras personas.

Proyectos en RStudio

A continuación, configurarás un proyecto de RStudio.

Un entorno de R autónomo y portátil

Un proyecto en RStudio es un entorno de trabajo de R autónomo y portátil: una carpeta para todos los archivos asociados a un proyecto determinado (archivos de datos, scripts de R, resultados, etc.).

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/project_briefcase.png", error = F)

Si no trabajas dentro de un proyecto de RStudio, te resultará más difícil organizar archivos, importar datos y hacer que tus scripts sean utilizables por personas en otros ordenadores.

Proyectos en este curso

Durante este curso, crearás al menos 3 proyectos de RStudio dentro de la carpeta "intro_curso":

1) Un proyecto para el Módulo 1 (práctica) 2) Un proyecto para el análisis de un brote de Ébola 3) Un proyecto para el análisis de un brote de COVID-19

Crea un proyecto RStudio para el Módulo 1

Sigue estos pasos para crear un proyecto de RStudio para el Módulo 1:

1) Abre RStudio (asegúrate de abrir RStudio y no sólo R).

2) En RStudio, en la parte superior izquierda pulsa Archivo -> Nuevo Proyecto. En la ventana emergente, selecciona "Directorio existente".

knitr::include_graphics("images/create_project.png")

3) Crea el proyecto en la subcarpeta "intro_curso/modulo1

¡Voilà! Este será el proyecto para tu trabajo en este primer módulo.

Confirma que estás en un proyecto

Si estás trabajando en un proyecto de RStudio, verás el nombre del proyecto en la esquina superior derecha de RStudio. Si no estás en un proyecto de RStudio, aparecerá "Proyecto: (Ninguno)". ¿Qué ves en tu RStudio?

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/Rproject_dropdown.png", error = F)

Explora tu proyecto de RStudio

r fontawesome::fa("window-restore", fill = "darkgrey") Minimiza RStudio y abre el navegador de carpetas de tu ordenador (por ejemplo, el Explorador de Windows). Navega hasta la carpeta "módulo1". El contenido de la carpeta debería parecerse a esto:

knitr::include_graphics("images/new_r_project_explorer.png", error = F)

En la carpeta, deberías ver un pequeño archivo con un icono parecido a una "caja de R": es el archivo de proyecto de RStudio (.Rproj).

Para abrir el proyecto la próxima vez, haz doble clic en este archivo. Se abrirá RStudio y todos los archivos de este proyecto estarán listos.

Observa que en RStudio, en el panel "Archivos" (abajo a la derecha), también es visible el contenido del proyecto.

knitr::include_graphics("images/new_r_project.png", error = F)

Puedes leer más sobre los proyectos de RStudio en este capítulo del Manual de Epi R.

Ejecutar comandos de R

Iniciar un script de R

Si aún no lo has hecho, abre un nuevo script R haciendo clic en Archivo -> Nuevo archivo -> Nuevo script.

knitr::include_graphics("images/new_script.jpg", error = F)

Deberías ver que aparece un espacio vacío en la parte superior izquierda de RStudio. Este espacio es el script de R.

knitr::include_graphics("images/RStudio_new_script.png", error = F)

Actualmente, el script no se guarda. Haz clic en el icono de guardar situado encima del script, o haz clic en Archivo -> Guardar como.

Nombra el script como "module1_script.R" y asegúrate de que se guarda en la carpeta "module1".

Ten en cuenta que la extensión de archivo de un script de R es ".R". Al trabajar con R, te encontrarás con otras extensiones, pero recuerda que ésta es para los scripts de R.

r fontawesome::fa("eye", fill = "darkblue") Observa que ahora tu script también debería aparecer en el panel "Archivos" (parte inferior derecha de RStudio) en la carpeta "module1".

quiz(
  question("¿Cuál de los siguiente nombres de archivos es un script de R?",
           allow_retry = TRUE,
    answer("survey_analysis.Rproj", message = "No, esta extensión indica que es un proyecto de R. Podrías hacer click en éste para abrir RStudio y trabajar en el proyecto."),
    answer(".Rhistory", message = "No, .Rhistory es un archivo especial que guarda un registro de comandos y resultados. Raramente es utilizado."),
    answer("cholera_plots.Rmd", message = ".Rmd indica que es un script de 'R markdown', el cual no es un script de R estándar. Aprenderás sobre R markdown más adelante en el curso."),
    answer("measles.R", correct = TRUE, message = "Sí, .R indica que es un script de R."),
    answer("pirate_ship.arrrrr", message = "No, ¡esto no tiene sentido!")
  )
)

Un script es una lista de instrucciones para R

Un script es un lugar donde escribir comandos (instrucciones) para R. Un script típico de R para salud pública podría incluir secciones como:

En el ejemplo siguiente, el texto verde y los símbolos almohadilla (#) son "comentarios" o "notas" para el lector, o se utilizan para delimitar secciones del script. El texto negro son comandos del código de R.

NO ESCRIBAS EL CÓDIGO DE EJEMPLO DE ABAJO EN TU SCRIPT
Simplemente revisa el formato, centrándote en cómo el # se utiliza para comentar o crear encabezados de sección. Tendrás la oportunidad de escribir guiones como éste más adelante en el curso.

knitr::include_graphics("images/example_script.png", error = F)

Escribe comandos sencillos en R

r fontawesome::fa("terminal", fill = "black") ¡Vamos a codificar!

R como calculadora

Para sentirte cómodo ejecutando comandos, empecemos por el uso más sencillo de R: como una calculadora.

A continuación se muestran operadores matemáticos comunes en R. Se suelen utilizar para realizar sumas, divisiones, crear nuevas columnas en conjuntos de datos, etc. Los espacios alrededor de los operadores no afectan al comando, pero hacen que el código sea más legible.

| Operación | Ejemplo en R | | -------------------------- | ----------------------------------------------- | | suma | 2 + 3 | | resta | 2 - 3 | | multiplicación | 2 * 3 | | división | 30 / 5 | | exponente | 2\^3 | | orden de las operaciones | ( ) |

Siéntete cómodo escribiendo y ejecutando comandos

Como se muestra en la demostración, puedes ejecutar comandos de R a través de la consola de las siguientes formas:

knitr::include_graphics("images/RStudio_run_console.png", error = F)

El [1] antes del 62 te indica que ésta es la primera (y en este caso la única) salida.

knitr::include_graphics("images/RStudio_run_script.png", error = F)

Ten en cuenta que los resultados siempre aparecerán en la Consola, aunque el comando se ejecute desde el script.

Escribe algunos comandos matemáticos sencillos en el script de R. Intenta ejecutar los comandos de TODAS las formas indicadas anteriormente. ¿Cuál es tu método preferido para ejecutar un comando?

Ahora, ejecuta comandos en tu script de R para encontrar las soluciones al siguiente problema matemático sencillo:

quiz(caption = "R como una calculadora",
  question_numeric(
    "¿Cuál es la suma de 12, -99, 2, 147 y 29?",
    answer(91, message = "¡Excelente!", correct = T),
    allow_retry = TRUE,
    correct = "Correcto, buen trabajo.",
    min = 1,
    max = 3000,
    step = 1
  )
)

Si te cuesta escribir el código, ¡revisa la sección de ayuda que aparece a continuación! Si es necesario, también se proporciona la solución.

r fontawesome::fa("lightbulb", fill = "gold") Haz clic para leer una pista

Utiliza el operador de suma + entre los números, coloca el cursor en esa línea del script y pulsa el botón "Ejecutar", ubicado en la parte superior derecha del script. No olvides que el segundo valor es NEGATIVO 99.


r fontawesome::fa("check", fill = "red")Haz clic para ver una solución (¡pruébalo tú primero!) 

12 + -99 + 2 + 147 + 29



Ejercicio: cadena de suministros de muestras de COVID-19

Intentemos desarrollar un código para una pregunta más relevante para la salud pública:

Estás gestionando una campaña de pruebas de COVID-19 en 3 centros, y necesitas hacer un pedido de suministro de pruebas rápidas para el mes que viene. Basándote en la siguiente información, ¿cuántas pruebas necesitas pedir para el mes que viene?

Escribe y ejecuta un comando en tu script para calcular cuántas pruebas necesitas pedir para el mes Si te cuesta empezar, ¡revisa primero la sección de ayuda que aparece a continuación!

r fontawesome::fa("lightbulb", fill = "gold") Haz clic para leer un tip

Utiliza los paréntesis ( ), el operador de multiplicación, *, y los operadores de suma, +, y resta, -. Primero, suma las demandas conocidas (200, 550 y dos veces 925). Envuelve todo eso entre paréntesis, porque necesitas multiplicar esa suma por el amortiguador deseado (110%, pero en forma decimal). Ese total también debe ir entre paréntesis, porque luego tienes que restar el sobrante del mes anterior (que no es necesario comprar).


r fontawesome::fa("check", fill = "red")Haz clic para ver una solución (¡pruébalo tú primero!) 

((200 + 550 + (925 * 2)) * 1.1) - 420



quiz(caption = "Ejercicio de cadena de suministros",
  question_numeric(
    "¿Cuántas pruebas deberías solicitar para el mes siguiente?",
    answer(2440, correct = T),
    allow_retry = TRUE,
    correct = "Correcto, buen trabajo.",
    incorrect = "Intenta nuevamente o mira la sugerencia de arriba. Piensa en el orden de las operaciones...",
    min = 1,
    max = 3000,
    step = 1
  ),
  question(
    "¿Dónde se ha impreso la resupuesta en RSTudio?",
    allow_retry = TRUE,
    answer("La consola de R, abajo a la izquierda", correct = TRUE),
    answer("El panel de gráficos, abajo a la derecha", message = "No, la respuesta no se ha impreso en el panel de gráficos. Revisa la consola, abajo a la izquierda."),
    answer("En el script de R", message = "No, no se ha impreso en el script de R. Mira abajo, en el panel de la consola.")
  )
)

Documentación

r fontawesome::fa("pen", fill = "brown") ¡Es importante que escribas notas en tu guión para que otras personas (y tú en el futuro) puedan entenderlo!

El símbolo "almohadilla" (#) desactiva cualquier texto escrito a la derecha del mismo y se utiliza para insertar comentarios a lo largo del script.

Por ejemplo:

# Este es un comentario en el script
# Este es otro comentario

2 + 2  # este es un comentario luego de un código de R activo

Por favor, actualiza tu script para incluir lo siguiente:

¡Los futuros lectores de tu código te lo agradecerán!

A continuación puedes ver una posible solución.

r fontawesome::fa("check", fill = "red")Haz clic para ver la solución (¡pruébalo tú primero!)

Ten en cuenta que el autor, la fecha y el correo electrónico de contacto deben reflejar tus propios datos (por ejemplo, tu nombre, la fecha de hoy y tus datos de contacto).

# Propósito: calcular suministros mensuales de pruebas
# Autor: Neale Batra
# Última actualización: 2 de febrero de 2024
# Email de contacto: contact@appliedepi.org

# lugar 1 utiliza 200 pruebas por mes
# lugar 2 utliza 550 pruebas por mes
# lugar 3 tiene 2 sub-lugares, cada uno necesitando 925 pruebas por mes
# Solicitar un adicional del 10% como amortiguador en caso de mayor demanda
# Al final, restar el número de pruebas sobrantes del mes anterior

((200 + 550 + (925 * 2)) * 1.1) - 420


Crear objetos

Tipos de objetos

R te permite almacenar objetos para su uso posterior. Se almacenan en tu Entorno de R, el panel de la parte superior derecha de RStudio.

Todo lo que almacenes en R (conjuntos de datos, variables, una lista de nombres de pueblos, un número total de población, incluso gráficos) son objetos a los que se les asigna un nombre de tu elección que puedes referenciar en comandos posteriores. ¡En cualquier script puedes crear ("definir") y redefinir cientos de objetos!

Algunos ejemplos:

Más adelante exploraremos los distintos tipos de objetos, pero de momento practiquemos la definición de objetos sencillos.

El operador de asignación

Crea objetos asignándoles un valor con el "operador de asignación": <-

Puedes pensar en el operador de asignación <- como las palabras "se define como".

Este operador se parece a una flecha. Toma el valor del lado derecho y lo asigna al nombre del lado izquierdo. Los comandos de asignación suelen seguir un orden estándar:

nombre_objeto \<- valor (o cálculo/proceso que produce un valor)

Al ejecutar el comando con el operador de asignación, puedes crear un objeto, o volviendo a ejecutar el comando puedes redefinir el objeto con un nuevo valor.

Consejo: El atajo de teclado para crear el <- es Alt y - (Windows) u Opción y - (Mac).

Entorno de R

r fontawesome::fa("eye", fill = "darkblue") Mira tu panel "Entorno" en RStudio. En este momento, no debería haber ninguna entrada allí, porque aún no hemos definido ningún objeto.

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/empty_environment.png", error = F)

Ahora, escribe el código siguiente en tu script de R, y ejecuta el comando.

Recuerda que para ejecutar un comando en tu script, resalta todo el comando o coloca el cursor en el comando y pulsa "Ejecutar".

Trata de escribir tu mismo el comando (¡no te limites a copiar y pegar!) para familiarizarte con los comandos de R.

casos_confirmados <- 34

Observa que el objeto casos_confirmados está ahora en el Entorno, con el valor de 34. Ahora podemos ejecutar otros comandos utilizando el objeto casos_confirmados y R sabrá que debe utilizar el valor 34.

quiz(
   question_checkbox("Cuando ejecutas el comando de arriba para definir un objeto, ¿que sucede en RStudio? (Selecciona TODAS las que consideres correctas)",
    answer("Un nuevo objeto llamado 'casos_confirmados' con el valor 34 ha aparecido en el panel de Entorno",
           correct = TRUE,
           message = ""),
    answer("El comando ejecutado ha aparecido en el panel de la consola (abajo-izquierda)",
           correct = TRUE,
           message = "Nota que solo el comando ha aparecido en la consola de R, no el resultado"),
    answer("34 ha aparecido en la consola como resultado",
           message = "Este comando solo asigna un valor a un objeto con un determinado nombre, no solicita a R que imprima el resultado del cálculo"),
    allow_retry = TRUE
  )
)

r fontawesome::fa("pen", fill = "brown") Notas sobre la denominación de los objetos:

r emo::ji("cross mark") mi objeto
r emo::ji("cross mark") Teniendo ambos datos y Datos
r emo::ji("cross mark") 2da_ola_de_casos_del_condado_de_Santa_Clara

r emo::ji("check") casos_zambia
r emo::ji("check") base_cruda
r emo::ji("check") lab_20140216

Nota: en la bibliografía sobre R, a menudo verás que la gente utiliza df como nombre de objeto. Es una forma muy abreviada de referirse al hecho de que el objeto que están guardando es una "base de datos" (conjunto de datos con columnas y filas).

Comandos Imprimir vs. Guardar

Ahora, ejecuta un comando sólo con el nombre del objeto casos_confirmados (mira la salida en el panel de la consola de R)*:

casos_confirmados

Este comando pide a R que imprima (también llamado "devolver") el valor asignado al objeto casos_confirmados. El valor 34 se ha impreso en la consola.

Esto plantea un punto crítico que debes comprender como usuario principiante de R: hay dos tipos fundamentales de comandos de R:

1) Guardar comandos que utilizan la <- para guardar un objeto.
Se creará o modificará algún objeto de tu Entorno. El registro del comando se imprimirá en la Consola, pero no se imprimirá ningún valor de salida.

2) Comandos de impresión que imprimen una salida en una consola (y no utilizan la tecla <-).
R imprimirá el comando y un valor a la Consola, pero no harán ningún cambio duradero en ningún objeto del Entorno.

Pregúntate siempre: "¿Qué le pide a R mi comando? ¿Imprimir? o ¿Guardar?". Reforzaremos esto con ejemplos a lo largo del curso.


Crea otro objeto

Crea un objeto llamado casos_sospechosos y asígnale el valor 12. Ejecuta este comando a través de tu consola para asegurarte de que el objeto casos_sospechosos se crea en tu entorno con el valor asignado de 12.

r fontawesome::fa("check", fill = "red")Haz clic para ver la solución (¡pruébalo tú primero!) 

casos_sospechosos <- 12


Ahora, escribe y ejecuta el siguiente comando. Observa cómo ahora puedes hacer referencia a los valores llamando sólo a los nombres asignados.

casos_totales <- casos_confirmados + casos_sospechosos

quiz(
  question("Este comando, ¿fue de impresión o de guardado?",
    answer("Impresión",
           message = "No, se ha utilizado una flecha y ningún resultado fue impreso en la consola."),
    answer("Guardado",
           message = "Si, se ha utlizado una flecha y un nuevo object fue guardado en el entorno.",
           correct = TRUE),
    allow_retry = TRUE
  ),

   question("Cuando se ha ejecutado el comando de arriba, ¿se ha impreso el valor de casos_totales en la consola?",
    answer("Sí", message = "Este comando ha utilizado el operador de asignación y así solo solicitó a R que guarde el valor, no que lo imprima en la consola."),
    answer("No", correct = TRUE, message = "Correcto, este comando ha utilizado el operador de asignación y así ha solicitado a R que guarde el valor, no que lo imprima en la consola."),
    allow_retry = TRUE
  ),

  question("¿Cómo puedes saber el número total de casos? (selecciona todos los que consideres apropiados)",
    answer("Mirar el valor de casos_totales en el Entorno",
           correct = TRUE),
    answer("Gritarle a R hasta que me lo diga",
           correct = FALSE),
    answer("Ejecutar un comando de solo casos_totales, de manera que imprima su valor actual",
           correct = TRUE),
    allow_retry = TRUE
  ),

  question("¿Cuál es el número total de casos?",
    answer("34",
           message = "Has seleccionado el número de casos CONFIRMADOS únicamente"),
    answer("12",
           message = "Has seleccionado el número de casos SOSPECHOSOS únicamente"),
    answer("46",
           correct = TRUE,
           message = "Has seleccionado correctamente el número total de casos"),
    allow_retry = TRUE
  )
)

Redefinir objetos

¿Qué ocurre si recibes la noticia de que hay 10 casos adicionales confirmados?

Si modificas el primer comando para que diga casos_confirmados <- 44, ¿cambia el valor de casos_confirmados en el panel Entorno de RStudio inmediatamente? (No.) ¿Cambia el valor de casos_totales inmediatamente a 56? (Tampoco.)

quiz(
   question_checkbox("Selecciona todos los pasos que deben ocurrir para que el valor de casos_totales se actualice a 56",
    answer("Ejecutar el comando: casos_confirmados <- 44",
           message = "Sí, primero casos_confirmados ha de ser redefinido",
    correct = T),
    answer("Re-ejecutar el comando: casos_totales <- casos_confirmados + casos_sospechosos",
           message = "Sí, segundo, el total debe ser actualizado con el nuevo número de casos confirmados.",
    correct = T),
    answer("Dar un regalo a tu instructor/a",
           message = "No, sobornar a tu instructor/a no hará que R haga magia."),
    allow_retry = TRUE
  )
)

Cambiar un valor escrito en tu script no actualiza automáticamente el resto del mismo, ¡ni cambia ningún valor almacenado en R!

Debes volver a ejecutar los comandos para que R registre los cambios.

En este caso, debes volver a ejecutar dos comandos para actualizar el valor de casos_totales (¡y deben ejecutarse en el orden correcto!)

Ejecutar varias líneas

Puede que te preguntes: "¿por qué tengo que ejecutar cada línea de mi script una a una?". Pues bien, ¡no tienes por qué hacerlo! Utiliza el ratón para resaltar varios comandos del script y luego ejecútalos.

Antes de ejecutar varias líneas, comprueba si hay código incompleto que pueda causar un error. Recuerda que R se detendrá si encuentra un error.

El símbolo # también se puede utilizar para desactivar código temporalmente. Si se coloca al principio de la línea, R la ignorará.

# Ejemplo de una línea desactivada con el símbolo '#'
casos_confirmados <- 44
casos_sospechosos <- 12
#casos_pendientes <- 3

casos_totales <- casos_confirmados + casos_sospechosos

Ejercicio: cálculo de la cadena de suministros médicos

Aplica lo que has aprendido en el ejemplo de la cadena de suministro de la sección anterior. Como recordatorio: estás gestionando los suministros de la prueba de COVID-19 en 3 lugares. Dispones de la siguiente información:

Anteriormente, escribiste este comando para calcular el número necesario de pruebas:

((200 + 550 + (925 * 2)) * 1.1) - 420

Vuelve a escribir este cálculo utilizando objetos para que pueda actualizarse fácilmente cada mes.

r fontawesome::fa("lightbulb", fill = "gold") Haz clic para leer una sugerencia

Empieza escribiendo 3 comandos, que definan las necesidades de cada uno de los 3 lugares.

Después, escribe un comando que defina las pruebas sobrantes del mes anterior.

Por último, escribe un comando que imprima el número total de pruebas necesarias sustituyendo los números por los nombres de los objetos definidos en los comandos anteriores.


r fontawesome::fa("check", fill = "red")Haz clic para ver una solución (¡pruébalo tú primero!) 

# Define los valores (objetos) para usar en el cálculo
lugar1 <- 200
lugar2 <- 550
lugar3 <- 925 * 2
extra <- 420

# run this command to print the amount needed to order
((lugar1 + lugar2 + lugar3) * 1.1) - extra



Ahora que has configurado tu cálculo para que sea fácil de procesar, utiliza el código que has creado para responder a la siguiente pregunta:

quiz(
   question("¿Cuántas pruebas deberías solicitar si el lugar 1 necesita 250, el lugar 2 necesita 730 y los dos sub-lugares del lugar 3 necesitan 1050 cada uno, y teniendo 37 pruebas extras del mes anterior?",
    answer("3253", message = "Revisa tus paréntesis, ¿estás multiplicando 1.1 en TODOS los lugares, como debería ser?"),
    answer("3351", correct = TRUE, message = "¡Buen trabajo!"),
    answer("2980", message = "El cálculo es incorrecto, compara tu código con la solución."),
    allow_retry = TRUE
  )
)

Piensa, ¿cómo abordarías las siguientes preguntas?

Si no estás seguro, pregunta a un/a instructor/a.

r fontawesome::fa("exclamation", fill = "red") ¡Recuerda guardar a menudo tu script de R! Sólo tienes que hacer clic en el pequeño "ícono de guardar" de la fila de íconos situada encima del script, o hacer clic en Archivo -> Guardar

Comentando

¡Ya has escrito un script útil! Pero, ¿podrá un colega entender tu lógica y tus órdenes?

Utilizando el símbolo # (almohadilla) para los comentarios

Como se ha demostrado anteriormente, cualquier texto escrito a la derecha del símbolo almohadilla es ignorado por R. Puedes colocar el símbolo almohadilla para:

# Objectivo: calcular solicitud mensual de suministros de testeo
# Autor: (tu nombre)
# Última actualización: (fecha)  
# Email de contacto: (tu email)

# Define los valores (objetos) para usar en el cálculo
lugar1 <- 200         
lugar2 <- 550         
lugar3 <- 925 * 2     
extra <- 420         

# Ejecuta este comando para imprimir la cantidad a solicitar
((lugar1 + lugar2 + lugar3) * 1.1) - extra

# Objectivo: calcular solicitud mensual de suministros de testeo
# Autor: (tu nombre)
# Última actualización: (fecha)  
# Email de contacto: (tu email)

# Define los valores (objetos) para usar en el cálculo
lugar1 <- 200         # suministros para el lugar 1
lugar2 <- 550         # suministros para el lugar 2 
lugar3 <- 925 * 2     # suministros para los sub-lugares del lugar 3
extra <- 420         # número de pruebas remanentes del mes anterior

# Ejecuta este comando para imprimir la cantidad a solicitar
((lugar1 + lugar2 + lugar3) * 1.1) - extra


A continuación se muestra un ejemplo de script bien documentado que importa datos y realiza análisis epidemiológicos básicos. NO es necesario que escribas este código en tu script, simplemente míralo. Fíjate en lo claro que es de leer: cada sección está claramente anotada, con muchos espacios y líneas nuevas entre las partes del código.

knitr::include_graphics("images/example_script.png", error = F)

Títulos de las secciones

Los encabezados de sección son una forma útil de organizar tu código. Puedes utilizar un atajo de teclado para insertar un encabezado de sección en tu script.

Coloca el cursor donde deba comenzar la nueva sección y pulsa Ctrl, Mayús y R al mismo tiempo (o Cmd, Mayús y R en un Mac). En la ventana emergente, dale un nombre a la sección, por ejemplo "Necesidades mensuales de suministros".

El encabezado de la nueva sección debería tener este aspecto:

# Necesidades mensuales de suministros ----------------------------------------

RStudio reconocerá esta sección, y aparecerá en el "Esquema" del script, situado en la parte superior derecha del panel de script de R. Esta herramienta "Esquema" en la que puedes hacer clic puede ser muy útil para navegar por scripts con cientos o incluso miles de líneas.

knitr::include_graphics("images/section_headings.png", error = F)

Adapta tu script para utilizar encabezados de sección y comentarios

r fontawesome::fa("check", fill = "red")Haz clic para ver una solución (¡pruébalo tú primero!) 

# Sobre este script ----------------------------------------------
# Objectivo: calcular solicitud mensual de suministros de testeo
# Autor: (tu nombre)
# Última actualización: (fecha)  
# Email de contacto: (tu email)

# Necesidades mensuales de suministros ----------------------------
# Puedes cambiar los números para reflejar los requerimientos esperados de cada lugar

lugar1 <- 200         # suministros para el lugar 1
lugar2 <- 550         # suministros para el lugar 2 
lugar3 <- 925 * 2     # suministros para los sub-lugares del lugar 3
extra <- 420         # número de pruebas remanentes del mes anterior

# Cálculo -----------------------------------------------------
# Nota: esta ecuación incluye un amortiguador de 10% a través del factor 1.1

((lugar1 + lugar2 + lugar3) * 1.1) - extra


Objetos nominales (de texto)

Los objetos también pueden contener valores "nominales" (texto, palabras). Éstos se colocan entre comillas, como "Ciudad de Nueva York" o "dm76wk34" (un identificador único de caso generado aleatoriamente).

Ten en cuenta que los objetos nominales pueden crearse con "comillas dobles" o 'comillas simples' con el mismo efecto (a veces puede ser útil colocar comillas simples dentro de comillas dobles).

Cuando tu script de R reconozca que algo que has escrito es un valor nominal (una vez escritas la primera y la última comillas) cambiará de color.

nombre <- "Oliver"
distrito <- "Bolo"
ocupacion <- "enfermero"

Intenta definir algunos objetos nominales en tu script, como los anteriores. Experimenta imprimiéndolos en la Consola y cambiando su valor.

Observa que treinta y cuatro podría escribirse en R como:

¿Qué ocurre si intentas sumar 30 + "12"?

Utilizaremos más objetos nominales en la siguiente sección...

Funciones

Los ejemplos anteriores de ejecución de comandos, creación de objetos y cálculos matemáticos no muestran las mejores capacidades de R.

¡El verdadero poder de R proviene de las funciones! Las funciones son el núcleo del uso de R, y son la forma de realizar tareas más complejas.

Una función es como una máquina

Una función recibe entradas, ejecuta una acción con esas entradas y produce un resultado. El resultado depende de la función.

Las funciones operan sobre un objeto ubicado dentro del paréntesis de la función. Por ejemplo, la función sqrt() devuelve la raíz cuadrada de un número:

sqrt(64)

Del mismo modo, la función sum() acepta un número ilimitado de valores numéricos y devuelve la suma.

sum(2, 5, 10, -8, 100)

En tu script de R, utiliza las funciones min() y max() para hallar el mínimo y el máximo de los números 3, 55, 9, -4 y 33.

No haremos un test, porque las respuestas deberían ser bastante fáciles... pero ¿funcionó tu código?

# Calcular el valor mínimo
min(3, 55, 9, -4, 33)

# Calcular el valor máximo
max(3, 55, 9, -4, 33)

Crear vectores con la función c()

Probemos la función c(). La "c" representa el término "concatenar" (puedes recordarlo como "combinar"), porque esta función combina los valores dentro de sus paréntesis en una unidad.

A la unidad producida por c() la llamaremos vector. Un vector es una unidad de varios valores, que deben ser de la misma clase (todos numéricos, todos nominales, todos lógicos, etc.) y deben estar separados por comas.

Mira este ejemplo, en el que creamos un vector con nombre de valores numéricos (las edades de 5 pacientes).

# Crear un vector con las edades de pacientes
edades_pacientes <- c(5, 10, 60, 25, 12)

Prueba el comando anterior en tu script de R. Ahora, ¿qué ocurre cuando ejecutas el comando edades_pacientes? Todos los números se imprimen en la consola de R.

Es útil que se pueda hacer referencia a estos números con un solo nombre, porque ahora podemos aplicar cambios a todos ellos en un solo paso:

edades_pacientes * 2

No estoy seguro de por qué tendríamos que multiplicar todas las edades de los pacientes por 2, pero seguro que ha sido fácil, ¿verdad?

Funciones que cambian su contenido

Intenta crear tu propio vector: haz un vector con algunos nombres de distritos/ciudades/condados de tu región. Ponle nombre jurisdicciones. ¿Se parece tu comando a esto?

# A character vector of jurisdiccion names in Mozambique  
jurisdicciones <- c("Maputo", "Inhambane", "Gaza", "Zambezia", "Manica", "Sofala")

¿Qué podemos hacer con un vector nominal? No podemos multiplicarlo por 2... Por diversión, vamos a poner este vector en otra función: toupper() que cambia todos los caracteres a mayúsculas:

toupper(jurisdicciones)

Nota: Aunque el vector contenga valores de caracteres, al teclear la tecla nombre del objeto o nombre del vector, no se utilizan comillas. Es un objeto de R igual que casos_confirmados y, por tanto, debe escribirse claramente en el código.

¿Qué aspecto tiene el resultado? ¿Y si pruebas la función tolower()? ¡Esto podría ser útil para normalizar nombres u otras palabras al unir dos bases de datos!

quiz(
  question("El comando toupper(), ¿ha sido un comando de GUARDADO o de IMPRESIÓN?",
    answer("Impresión",
           message = "Sí, no hay un operador de asignación. Los valores en el objeto jurisdicciones fueron cambiados temporalmente para imprimirlos en MAYÚSCULAS en la consola. Estos valores no fueron cambiados en el Entorno.",
           correct = TRUE),
    answer("Guardado",
           message = "No, no se ha utilizado el operador de asignación y los valores dentro del objeto jurisdicciones no fueron cambiados realmente."),
    allow_retry = TRUE
  ) 
)

Funciones con argumentos con nombre

La mayoría de las funciones que encontrarás en R tienen argumentos con nombres. Éstos te permiten especificar los parámetros con los que operará la función.

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/arguments-buttons.png", error = F)

Volvamos al vector de caracteres jurisdicciones que has definido antes. Tu vector puede incluir otras jurisdicciones cercanas a tu domicilio.

jurisdicciones

Imagina que quieres imprimir estos nombres de jurisdicciones en un informe (¡sí, puedes automatizar informes con R!), pero esta salida tiene un aspecto feo y no es muy legible en una frase. Cuestionarioá quieras comas entre los nombres.

La función paste() acepta valores y los combina.

Los argumentos se escriben dentro de los paréntesis de la función con un solo signo igual por lo que nos referimos a la argumento collapse como collapse =. Ten en cuenta que los argumentos se separan por comas dentro de la función.

Escribe el siguiente código en tu script y ejecuta el comando a través de tu consola para ver el resultado:

paste(jurisdicciones, collapse = ",")

Entendamos lo que está pasando:

1) El primer argumento espera el nombre de un vector, en este caso jurisdicciones. A menudo, el primer argumento de una función son datos sobre los que se va a operar, y no requiere un nombre ni un signo igual.

2) El segundo argumento es collapse = al que proporcionamos un valor nominal (entre comillas) para que aparezca entre cada una de las palabras. En el ejemplo anterior, hemos elegido una coma: .",".

pegar(jurisdicciones, colapso = ",")

El resultado es el siguiente

paste(jurisdicciones, collapse = ",")

Reproduce el código anterior con tu vector jurisdicciones en RStudio. Observa cómo esta función sabe que no debe poner una coma después del último valor de jurisdicciones.

¿Cómo ajustarías el código para añadir un espacio después de cada coma?

r fontawesome::fa("check", fill = "red")Haz clic para ver la solución (¡pruébalo tú primero!) 

# Nota el espacio después de la coma, dentro las comillas
paste(jurisdicciones, collapse = ", ")


Argumentos opcionales y valores por defecto

Las funciones suelen tener muchos argumentos, y no todos son necesarios para que se ejecuten. En la función paste() ejercicio anterior, collapse = es opcional. Puedes utilizar la función sin especificar un valor para ella.

En otro ejemplo, las funciones que realizan gráficos tienen argumentos como title =, subtitle =, color = etc. No es necesario que proporciones valores para que la función se ejecute correctamente.

Los programadores de R no tienen cerebros enciclopédicos: buscamos esta información todo el tiempo en la documentación de ayuda o en recursos como nuestro Manual de R para epidemiólogos.

Obtener ayuda

En la documentación de la función se pueden leer los argumentos y cualquier valor establecido por defecto. Para leer la documentación, busca el nombre de la función en el campo Panel de ayuda en la parte inferior derecha de RStudio. También puedes escribir ? antes del nombre de la función en la Consola (por ejemplo ?paste).

Los detalles de la documentación tendrán un aspecto parecido a éste (podemos ayudarte a interpretarlos, ya que pueden ser difíciles de entender al principio):

knitr::include_graphics("images/r_documentation.png", error = F)

quiz(
  question("¿Cuáles son los argumentos en el siguiente comando: \n\nage_pyramid(data = linelist, split_by = 'gender', age_group = 'agecat5', proportional = TRUE)",
    answer("linelist, split_by, age_group, proportional", message = "¡Cuidado! linelist aparece luego del signo 'igual'. Es el valor asignado al argumento 'data = '."),
    answer("data, split_by, age_group, proportional", correct = T),
    answer("age_pyramid, linelist, 'gender', proportional", message = "age_pyramid es la función y linelist es el valor asignado al argumento 'data = '."),
    allow_retry = T
  )
  )

quiz(
  question("Todas las funciones de R tiene múltiples argumentos que requiren entradas",
    allow_retry = T,
    answer("Verdadero"),
    answer("Falso", correct = TRUE, message = "No todas las functiones tiene múltiples argumentos. Generalmente, las funciones que tienen múltiples argumentos no necesitan entradas para todos ellos.")
  )
)

Funciones matemáticas básicas de R

Repasa brevemente estos otros operadores y base R base.

| Operación | Función | | -------------------------- | ------------------------------------- | | redondeo | round(x, digits = n) | | redondeo | janitor::round_half_up(x, digits = n) | | valor absoluto | abs(x) | | raíz cuadrada | sqrt(x) | | exponente | exponent(x) | | logaritmo natural | log(x) | | logaritmo en base 10 | log10(x) |

Nota: Véase esta página del Manual de Epi R antes de utilizar las funciones de redondeo. Hay matices matemáticos que son importantes en algunas circunstancias.

Funciones estadísticas

Repasa brevemente estas funciones estadísticas habituales en R. Las utilizaremos con frecuencia.

| Objetivo | Función | | -------------------------- | ------------------ | | media (promedio) | mean(x, na.rm=T) | | mediana | median(x, na.rm=T) | | desviación estándar | sd(x, na.rm=T) | | percentiles* | quantile(x) | | suma | sum(x, na.rm=T) | | valor mínimo | min(x, na.rm=T) | | valor máximo | max(x, na.rm=T) | | rango | range(x, na.rm=T) | | resumen | summary(x) |

ATENCIÓN: Por defecto, cualquier valor que falte en el cálculo (escrito en R como NA) dará como resultado NA a menos que el argumento na.rm = se establezca como TRUE que remueve (rm) los NAs del cálculo. Esto se puede abreviar como na.rm = T. Esto tendrá más sentido cuando empecemos a utilizar bases de datos.

[PELIGRO: Si proporcionas un vector independiente de números a una de las funciones estadísticas anteriores, asegúrate de envolver los números dentro de c() .]{style="color: red;"}

# Si provees números a una función estadística directamente, asegúrate de envolverlos con c()
mean(1, 6, 12, 10, 5, 0)    # ¡¡¡ INCORRECTO !!!  

mean(c(1, 6, 12, 10, 5, 0)) # CORRECTO

Paquetes

Hasta ahora, has utilizado funciones básicas, {base}, de R que vienen automáticamente instaladas, como sum(), c() y min(). Éstas son una parte muy pequeña de todas las funciones R.

Un paquete de R es un paquete compartible de funciones relacionadas que puedes descargar y utilizar.

Los paquetes suelen tener un tema, por ejemplo:

Los nombres de los paquetes suelen escribirse en entre llaves { }. Esto no se hace al escribir los nombres de los paquetes en tu código R.

Los nombres también suelen ser juegos de palabras ingeniosos: ¡el espíritu divertido de la comunidad R es evidente!

CRAN

Para instalar la mayoría de los paquetes de R, utiliza los comandos de R para descargar el paquete de "CRAN" a la "biblioteca de R" de tu ordenador.

Muchos usuarios de R crean funciones especializadas, que comparten en paquetes con la comunidad de R. Para que los paquetes se distribuyan ampliamente, suelen compartirse en la red Red Completa de Archivos de R (CRAN), el cual es el repositorio central de softwares de R: un archivo de paquetes de R que han superado un escrutinio básico.

Para diciembre de 2023, había 20.190 paquetes disponibles en CRAN. Algunos de ellos son inmensamente populares, con cientos de miles de descargas al mes.

Seguridad y VPN

¿Te preocupan los virus y la seguridad cuando descargas un paquete de CRAN? Lee este artículo sobre el tema.

Si utilizas una Red Privada Virtual (VPN), puede que tengas que desactivarla para poder instalar los paquetes de R.

Instalar y cargar paquetes

Una vez que un paquete se ha instalado se almacena en tu "biblioteca" de R. Puedes acceder a las funciones que contiene "cargando" el paquete para utilizarlo durante tu sesión actual de R.

En resumen: para utilizar las funciones disponibles en un paquete R, hay que realizar 2 pasos:

  1. El paquete debe estar instalado (una vez), y
  2. El paquete debe estar cargado (cada nueva sesión de R, cada vez que volvamos a abrir RStudio)

Piensa en R como en tu biblioteca personal: cuando instalas un paquete, tu biblioteca adquiere un nuevo "libro" de funciones. Pero cada vez que quieras utilizar una función de ese libro, deberás tomarla prestada ("cargarla") de tu biblioteca.

knitr::include_graphics("images/bookshelf1.png", error = F)

Comandos para instalar paquetes de R

Nuestro primer consejo es éste: comienza tu script escribiendo el código que instala y carga los paquetes (como primer comando).

Esto te deja claro a ti y a otros lectores qué paquetes son necesarios para ejecutar el script.

Comandos {base} de R

Existen comandos {base} de R para instalar y cargar paquetes. No son el método más eficaz, pero siempre puedes volver a este método.

Paso 1: Instala un paquete con comandos {base} R

install.packages() es la función {base} de R para instalar paquetes (ten en cuenta que "paquetes" se escribe en plural). Escribe el nombre del paquete dentro del paréntesis usando comillas. Los nombres de los paquetes distinguen entre mayúsculas y minúsculas.

# Instalar el paquete janitor usando comandos {base}
install.packages("janitor")

r fontawesome::fa("exclamation", fill = "red") Ten en cuenta que este comando instalará el paquete cada vez que se ejecute, aunque el paquete ya esté instalado.. Además, no carga el paquete para utilizarlo en la sesión actual (paso 2 de arriba).

Si quieres instalar varios paquetes en un solo comando, deben aparecer dentro de un vector de palabras c().

# Instalar múltiples paquetes usando comandos {base}
install.packages(c("janitor", "rio", "here"))

Ahora pruébalo: escribe un comando cerca de la parte superior de tu script para instalar el paquete "pacman". Si una ventana emergente te pregunta si quieres reiniciar R, di "No".

r fontawesome::fa("check", fill = "red")Haz clic para ver la solución (¡pruébalo tú primero!) 

install.packages("pacman")


Paso 2: Carga un paquete con comandos {base} de R

¿Recuerdas con qué frecuencia tienes que cargar un paquete? Cada vez que inicies R.

Puedes hacerlo utilizando la función {base} de R library().

Escribe y ejecuta el siguiente comando debajo del install.packages("pacman") que acabas de añadir a tu script.

# Carga el paquete pacman para usar en la sesión actual
library(pacman)

Las funciones del paquete {pacman} están ahora disponibles para su uso.

El método {pacman}

El paquete "pacman" te ayuda eficazmente a instalar y cargar otros paquetes y facilita enormemente compartir scripts de R entre colegas. Su nombre hace referencia a "package (paquete en inglés) y manager" (administrador en inglés). ¡No el personaje del videojuego!

Su función p_load() realiza los pasos 1 y 2 con eficacia. Instala cada paquete sólo si no está ya instalado. Además carga cada paquete para su uso.

La sintaxis es bastante sencilla. Coloca los nombres de los paquetes entre paréntesis, separados por comas. No son necesarias las comillas. Los nombres de los paquetes distinguen entre mayúsculas y minúsculas.

Escribe este comando cerca de la parte superior de tu script, como primer comando, y ejecútalo. Pon un # delante de cualquier install.packages() y library para desactivarlos.

pacman::p_load(rio, here, janitor, tidyverse)

Cuando tu colega ejecute este comando en su ordenador, sólo se instalarán los paquetes que no tenga ya en su ordenador, y se cargarán todos. Esto utiliza menos líneas de código y no da lugar a instalaciones innecesarias. Depende, eso sí, de que tu compañero tenga el paquete {pacman} ya instalado.

La sintaxis especial pacman::p_load() repite los dos puntos, dos veces, ::, para conectar explícitamente el nombre del paquete pacman y el nombre de la función p_load(). Esta sintaxis es útil porque carga el paquete {pacman} (suponiendo que ya esté instalado), evitando la necesidad de libary(pacman). Ésta es una de las pocas veces en que esta sintaxis :: es útil.

IMPORTANTE: Escribe tu comando pacman::p_load() sólo una vez cerca de la parte superior de tu script. Si más adelante te das cuenta de que necesitas paquetes adicionales, sólo tienes que añadirlos a esta función y volver a ejecutarla.

Documentación

En cualquier comando de R, las nuevas líneas y las sangrías no afectarán la ejecución del código, ¡pero pueden mejorar drásticamente la legibilidad!

Por lo tanto, el comando pacman::p_load() puede escribirse verticalmente, con comentarios para explicar por qué estamos cargando cada paquete.

Edita tu comando para que tenga este aspecto.

# Cargar todos los paquetes necesarios, instalándolos si no lo están aún
pacman::p_load(
     rio,          # para importar bases de datos
     here,         # para identificar la ruta de los arhivos
     janitor,      # para limpieza de datos
     tidyverse     # para manejo de datos
)

Por lo general, se aconseja ubicar {tidyverse} en último lugar, debido a un fenómeno llamado "enmascaramiento de funciones". Pregunta a un instructor/a si quieres saber más.

quiz(caption = "Cuestionario: Paquetes de R",
  question("¿Con qué frecuencia tienes que instalar paquetes en tu ordenador?",
    allow_retry = T,
    answer("Cada vez que inicies R", message = "Los paquetes se instalan solo una vez. No tiene relación alguna con el reinicio de R."),
    answer("Solo una vez", correct = TRUE, message = "Los paquetes se instalan solo una vez. Al transcurrir un determinado tiempo, puede ser necesario actualizarlos re-instalándolos."),
    answer("Nunca (asumiendo que tienes conexión a internet)", message = "Los paquetes se instalan solo una vez. No puedes acceder a ellos interactivamente desde internet."),
    answer("Cada vez que reinicies tu ordenador", message = "Los paquetes se instalan solo una vez. No tiene relación alguna con el reinicio del ordenador.")
  ),

  question("¿Con qué frecuencia has de cargar un paquete?",
    allow_retry = T,
    answer("Cada vez que comiences R", correct = TRUE, message = "Los paquetes deben ser cargados cada vez que inicies tu sesión de R."),
    answer("Solo una vez", message = "Los paquetes se instalan solo una vez pero deben cargarse al inicio de cada sesión de R."),
    answer("Nunca (asumiendo que tienes conexión a internet)", message = "Lod paquetes se instalan solo una vez y se cargan al inicio de cada sesión de R. No se puede acceder a ellos interactivamente a través de internet."),
    answer("Cada vez que reinicies el ordenador", message = "Los paquetes se instalan solo una vez y cargados al inicio de cada sesión de R. No tiene relación alguna con el reinicio de tu ordenador.")
  ),

  question("Las nuevas líneas y sangrías pueden ser usadas para mejorar la lectura sin que impacten en la ejecución del código.",
    allow_retry = T,
    answer("Verdadero", correct = TRUE),
    answer("Falso")
  ),

  question("¿Cuál de las siguientes acciones realiza la función p_load() del paquete {pacman}? (selecciona todas las que consideres apropiadas).",
    allow_retry = T,
    answer("Instala los paquetes si aún no están instalados", correct = TRUE),
    answer("Carga los paquetes para su uso", correct = TRUE),
    answer("Genera un pequeño emoji amarillo que come tu código línea a línea")
  )
)

Importar una base de datos

¡Empecemos a trabajar con datos! Para trabajar con una base de datos guardada en tu ordenador como archivo Excel, CSV o similar, debes importarla al entorno de R como un objeto.

La base de datos se guardará como un objeto de datos (dataframe) formado por columnas y filas.

A diferencia de otros programas, R puede almacenar varias bases de datos a la vez.

Ubicación de los datos

Para importar una base de datos en R, debes indicarle a R dónde acceder al archivo en tu ordenador (por ejemplo, una carpeta específica). A veces, esto puede resultar sorprendentemente difícil.

Sin embargo utilizando un proyecto de RStudio y guardando los datos dentro del proyecto todo el proceso resulta mucho más sencillo.

En el directorio del proyecto "módulo1", comprueba que la carpeta de "nivel superior" o "raíz" del proyecto (donde se encuentra la carpeta "módulo1.Rproj") contiene el archivo "datos_prueba.csv". Importaremos esta base de datos a nuestra sesión actual de R.

knitr::include_graphics("images/data_in_root.png", error = F)

{rio}, el paquete para importar datos fácilmente

Hay funciones {base} de R para importar datos, pero pueden ser confusas y difíciles de recordar. Por ejemplo, hay funciones distintas para importar distintos tipos de archivos a R (por ejemplo, .xlsx, .csv, .tsv, .txt, etc.).

Afortunadamente, hay una función que sirve para casi todos los formatos de archivo que es la función import() del paquete {rio}.

La función import() espera recibir un valor de nominal con la ruta del archivo a los datos que deseas importar. En este caso, nuestro archivo de datos se guarda en la carpeta raíz del proyecto de RStudio, por lo que sólo tienes que proporcionar el nombre del archivo y su extensión, entre comillas, como se indica a continuación:

import("datos_prueba.csv")

Crea una nueva sección de script, utilizando el atajo de teclado Ctrl + Mayús + R, y nómbrala "Práctica de importación de datos".

Escribe y ejecuta el script import() anterior en la sección "Practicar la importación de datos" de tu script.

r fontawesome::fa("exclamation", fill = "red") ¿Has visto este error?

Error en import("datos_prueba.csv") : no se pudo encontrar la función "import"

Si es así, significa que no has instalado y cargado la función {rio} paquete. Si necesitas ayuda, revisa la sección anterior y busca el icono pacman::p_load() que carga varios paquetes, entre ellos {rio}.

Una vez que hayas conseguido que el comando se ejecute correctamente, probablemente hayas visto aparecer un montón de texto en la Consola. ¡Era la base de datos!

Piensa: ¿qué le pidió tu mando a R que hiciera? ¿Era un comando de IMPRESIÓN o un comando para GUARDAR?

...Le pediste a R que importara la base de datos... y como no había ningún <- (operador de asignación) en el comando, la acción por defecto fue imprimir la salida en la consola.

Ahora, ajusta tu comando para guardar la base de datos como un objeto en tu Entorno con el nombre pruebas?

r fontawesome::fa("lightbulb", fill = "gold") Haz clic para leer una sugerencia

Utiliza el operador de asignación <- antes de la función. No olvides escribir el nombre del archivo entre comillas.


r fontawesome::fa("check", fill = "red")Haz clic para ver una solución (¡pruébalo tú primero!) 

pruebas <- import("datos_prueba.csv")



Cuando ejecutes este código, deberías ver el nuevo objeto pruebas en el panel de Entorno, con una breve descripción del número de observaciones y variables. Enhorabuena, ¡ya has importado una base de datos a R! ¡Bien hecho!

Mira la base de datos

Ahora que has importado los datos, ¡echemos un vistazo!

En el panel Entorno, haz clic una vez en el círculo azul situado junto al nombre de la base de datos.

El área expandida bajo el nombre es una vista general de las columnas de la base de datos. También hay una abreviatura que indica la "clase" de la columna (nominales, enteros, etc.) y los primeros valores de la columna.

Para ver la base de datos, haz clic en el nombre del objeto pruebas en el panel Entorno. Esto abre una nueva pestaña que muestra la base de datos, en el panel situado junto al script de R.

Practica desplazándote por la base de datos y aplicando filtros (mira el icono del filtro en la parte superior izquierda de la visualización de datos).

quiz(caption = "Cuestionario: Revisión de datos",
  question("¿Cuántas columnas hay en la base de datos?",
    allow_retry = T,
    answer("665", message = "No, éste es el número de filas/ observaciones"),
    answer(ncol(pruebas), correct = TRUE, message = "¡Sí, es correcto!"),
    answer("4", message = "Esto no es correcto, inténtalo nuevamente."),
    answer("25", message = "No, éste es el número de filas mostrados en el muestra inicial.")
  ),

  question("¿Cuál es el valor de la cuarta columna en la décima fila?",
    allow_retry = T,
    answer(pruebas[10, 4], correct = TRUE),
    answer("899"),
    answer("38.3"),
    answer("Lugar 3")
  ),

  question("¿Cuántas filas incluyen entre 100 y 300 pruebas solicitadas (inclusivas)?",
    allow_retry = T,
        answer("14"),
        answer(pruebas %>% filter(pruebas_solicitadas >= 100 & pruebas_solicitadas <= 300) %>% nrow(), correct = TRUE),
        answer("20"),
        answer("4")
  )
)

Si te cuesta responder a la última pregunta, haz clic en el recuadro blanco situado debajo de "pruebas_solicitadas" para filtrar numéricamente la columna y, a continuación, lee el resumen de filas filtradas en la parte inferior del panel. Ten en cuenta que esta acción no filtra la base de datos real, sino sólo visualización de la misma.

Explora tu base de datos

Aprovechemos esta oportunidad para explorar la base de datos.

Añadir paquetes

Ve a tu pacman::p_load() cerca de la parte superior de tu script y añade estos paquetes a la lista. Añádelos antes de el paquete "tidyverse", ¡y no olvides poner comas!

Ahora tu comando debería tener el siguiente aspecto:

# Cargar todos los paquetes necesarios, instalándolos si no lo están aún
pacman::p_load(
  rio,          # para importar bases de datos
  here,         # para identificar la ruta de los arhivos
  janitor,      # para limpieza de datos
  skimr,        # para exploración de datos
  flextable,    # para formateo de tablas
  scales,       # para formateo de valores
  gtsummary,    # para crear tablas estéticas
  tidyverse     # para manejo de datos
)

Haz clic para colocar el cursor en cualquier lugar del pacman::p_load() de tu script R y vuelve a ejecutar el comando haciendo clic en Ejecutar o pulsando Intro en el teclado.

Resumir tus datos

El paquete {skimr}

Puedes obtener un resumen útil de la base de datos utilizando el paquete {skimr} y su función skim().

Ya deberías haber instalado y cargado {skimr} añadiéndolo a tu pacman::p_load() y volviendo a ejecutar este comando. Si encuentras algún error, notifícaselo a tu facilitador/a.

Vuelve a la sección "Practicando la importación de datos" de tu guión. Coloca el nombre de tu objeto de base de datos importado (pruebas) en la función skim() y ejecuta el comando. ¿Qué contenido aparece en la consola de R?

Si la salida no es fácilmente legible, amplía el panel de la consola para que sea más ancho moviendo los límites entre los paneles de RStudio (haz doble clic y arrastra), y vuelve a ejecutar el comando.

r fontawesome::fa("check", fill = "red")Haz clic para ver una solución (¡pruébalo tú primero!) 

skim(pruebas)


¿Qué muestra la salida?

quiz(caption = "Cuestionario: Revisando los datos",
  question("¿Cuántas columnas ha clasificado R como numéricas?",
    allow_retry = T,
    answer("12", message = "No, ¡esto es más que el número de columnas en la base de datos!"),
    answer(pruebas %>% select(where(is.numeric)) %>% ncol(), correct = TRUE, message = "Sí, ¡esto es correcto!"),
    answer("1", message = "No, este es el número de columnas que son PSIXct, un formato de fechas")
  ),

  question("Revisa la información de la columnas con valores nominales. ¿Cuántas valores únicos hay en la columna 'lugares'?",
    allow_retry = T,
    answer(length(unique(pruebas$lugar)), correct = TRUE),
    answer("6"),
    answer("12"),
    answer("0")
  ),

  question("Revosa la información de las columnas con valores numéricos. ¿Cuál es la media (percentilo 50) de las pruebas mensuales solicitadas?",
    allow_retry = T,
        answer("32.2"),
        answer(median(pruebas$pruebas_solicitadas, na.rm=TRUE), correct = TRUE),
        answer("1250"),
        answer("99.0")
  )
)

Otras funciones de resumen

Existen otras funciones {base} de R para resumir objetos, como por ejemplo:

summary()
glimpse()

Prueba estas otras funciones en tu base de datos. Compara los resultados de cada función. ¿Qué resultado prefieres?

Indexación para extraer columnas o celdas concretas

En una pregunta anterior, te pedimos que encontraras el valor de la 4ª columna y la 10ª fila. En lugar de buscar manualmente, también puedes escribir el código para aislar y visualizar partes de la base de datos.

Extraer una columna con el operador de índice,$

"Indexar" significa referenciar sólo una parte de un objeto. El símbolo $ es un operador {base} de R para extraer sólo una columna de una base de datos. Escribe el nombre de la base de datos y a continuación $ seguido por el nombre de la columna, como se muestra a continuación.

Añade el siguiente código a tu script R para imprimir sólo una columna de pruebas:

pruebas$pruebas_solicitadas

Columnas como vectores

Aquí hay algo que debes saber: las columnas son "vectores". Una larga línea de valores de la misma clase, igual que jurisdicciones y edades_pacientes, vistas anteriormente en este módulo. De hecho, una base de datos es simplemente una colección de vectores (¡columnas!).

Igual que pones los vectores jurisdicciones en la función toupper() también puedes poner una columna dentro de una función. Por ejemplo:

Podemos utilizar la función mean() para obtener la media de una columna. Pruébalo en tu script de R:

mean(pruebas$pruebas_solicitadas)

Podemos utilizar la función summary() para resumir la información de una columna. Pruébalo en tu script de R:

summary(pruebas$pruebas_solicitadas)

Mientras escribías, lentamente, ¿viste aparecer un pequeño menú que mostraba todas las columnas de la base de datos? Puedes hacer clic para seleccionar una columna del menú desplegable cuando aparezca, si no quieres escribir el resto y cometer potencialmente un error ortográfico.

Paréntesis para indexación adicional

Otro operador de indexación a tener en cuenta son los "corchetes", que tienen el aspecto de [ ]. Éstos extraen una parte de un objeto mayor utilizando la siguiente plantilla:

objeto[FILA, COLUMNA]

Por ejemplo, pruebas[10, 4] devolvería el valor de pruebas en la 10ª fila y la 4ª columna.

Puedes devolver una columna entera utilizando corchetes, dejando vacía la parte de FILAS (¡pero no olvides la coma!): pruebas[ , 4] o puedes devolver una fila entera haciendo lo contrario: pruebas[10, ]

También se pueden indexar otros objetos. Por ejemplo, la función summary() cuando se utiliza en una columna devuelve un objeto que contiene el mínimo, la mediana, la media, el IQR, etc.

Prueba los 3 comandos siguientes para ver cómo cambia la salida a medida que se aplica más indexación:

# Retornar el resumen de la columna 'edad'
summary(pruebas$pruebas_solicitadas)

# Retornar el tercer element de la función 'summary()'
summary(pruebas$pruebas_solicitadas)[3]

# Retornar solo el número del tercer elemento de la function 'summary()'
# Los doble corchetes permiten una mirada más profunda en objetos anidados
summary(pruebas$pruebas_solicitadas)[[3]]

# Ejecuta una operación con el número seleccionado
summary(pruebas$pruebas_solicitadas)[[3]] + 4

Utilizarás el comando $ con mucha frecuencia. Es menos frecuente necesitar o utilizar los corchetes, pero aun así es bueno saberlo.

Hacer un gráfico

A continuación, te proporcionamos un código R para hacer un gráfico con los datos de pruebas de COVID-19.

NO es necesario que escribas este código, ¡simplemente cópialo y pégalo! Pega este código en tu script, debajo de los comandos de importación, y ejecútalo

Más adelante en este curso, aprenderás a entender y escribir este código, ¡así como a crear tus propios gráficos!

# Crear un gráfico de las pruebas utilizadas por lugar y mes
ggplot(data = pruebas, # usar la base de datos pruebas
       mapping = aes( # mapear ejes a columnas en la base de datos
         x = mes, # establecer la columna mes como el eje-x
         y = pruebas_utilizadas, # establecer la columna de pruebas utilizadas como eje-y
         color = lugar))+ # establecer colores diferentes para cada lugar
  geom_line()+ # mostrar los datos como líneas
  theme_light()+ # fondo simple
  labs(title = "Pruebas COVID-19 utilizadas, por mes") # agregar un título

¿Ves cómo aparece el resultado en el panel de Gráficos de RStudio, en la parte inferior derecha? Puedes ajustar el tamaño del panel, según necesites.

¡Qué divertido! ¡Con unas pocas líneas de código hemos hecho un gráfico precioso! R es una herramienta extremadamente versátil. Podrías guardarlo como un PNG, incrustarlo en una diapositiva de Powerpoint (PPT), o incrustarlo en un informe rutinario que se actualice automáticamente cuando se comuniquen nuevos datos.

Haz una tabla resumen

Hay muchas formas de hacer tablas resumen en R, que exploraremos en un módulo posterior. A continuación te ofrecemos algunos ejemplos.

Copia y pega el siguiente código en tu script y ejecútalo. No te preocupes si no lo entiendes. ¡Al final lo entenderás!

Este código utiliza el paquete {gtsummary} y su función tbl_summary para producir una tabla HTML que se puede incrustar con R en un informe Word, PDF o HTML, o en un sitio web/panel.

# Hacer una tabla resumen HTML por lugar
pruebas %>%                                                   # empezar con la base pruebas
  select(lugar, pruebas_solicitadas, pruebas_usadas, staffing) %>%   # seleccionar las columnas
  tbl_summary(by = lugar) %>%                                # resumir la tabla por lugar
  modify_caption("Análisis de las necesidades por lugar")        # agregar un título

Haz una tabla con estadísticas descriptivas detalladas

En este ejemplo utilizamos el paquete {tidyverse} para realizar cálculos descriptivos más complejos en una tabla resumen.

Copia y pega el código R que aparece a continuación en la parte inferior de tu script, luego haz clic con el cursor en la línea superior del comando y pulsa "Ejecutar" para ejecutar todo el comando.

Más adelante en el curso, podrás comprender lo que hace este código. Comienza agregando las filas por lugar de pruebas, creando nuevas columnas de resumen con medias, máximos y porcentajes por centro. Las líneas posteriores adaptan la tabla a un bonito formato con un encabezado, un título e incluso un resaltado que responde automáticamente a los valores.

# Hacer una tabla resumen para la performance de cada lugar de prueba
pruebas %>% 
  # agregar datos por lugar   
  group_by(lugar) %>% 

  # calcular estadísticas de resumen
  summarise(
    media_pruebas = round(mean(pruebas_usadas, na.rm = T), digits = 1),
    max_pruebas = max(pruebas_usadas, na.rm=T),
    pico_mes = month(which.max(pruebas_usadas), label=T),
    pct_personal_insuf = percent(sum(personal == "insuficiente", na.rm=T)/12))%>%

  # hacer que la tabla sea bonita (formatear)
  qflextable() %>% 
  set_header_labels(
    lugar = "lugar",
    media_pruebas = "Media\npruebas",
    max_pruebas = "Max\npruebas",
    pico_mes = "Pico\nmes",
    pct_personal_insuf = "% de meses\n personal insuficiente"
  ) %>% 
  bg(i = ~pct_personal_insuf >= 50, j = 5, part = "body", bg = "#FF7F7F") %>% 
  add_footer_lines("lugares con personal insuficiente en >= 50% de los meses están destacados.") %>% 
  italic(part = "footer") %>% 
  add_header_lines(values = "Rendimiento por lugar de las pruebas de COVID-19 (resumen anual)") %>% 
  align(part = "header", i = 1, align = "center") %>% 
  bold(i = 1, bold = TRUE, part = "header")

Podrías imprimir esta tabla como un PNG, enviarla a un documento Word o PDF, o incrustarla en una presentación de diapositivas o en un informe en línea.

Es importante tener en cuenta que para actualizar la tabla, sólo tienes que volver a ejecutar tu script utilizando una base de datos actualizada. Esto significa que si el archivo testing_data.csv se actualizara con nuevos datos, y volvieras a ejecutar tu script tal y como está escrito, la tabla se actualizaría en función de los nuevos datos, sin tener que hacer ningún cambio real en el script. ¡Asombroso!

Cierra y vuelve a abrir RStudio

No tengas miedo de cerrar RStudio al final de tu sesión de R. ¡Vamos a probarlo ahora! Realiza los siguientes pasos:

1) Guarda tu script. Puedes hacerlo yendo al menú Archivo y haciendo clic en "Guardar" o haciendo clic en el icono Guardar que parece un "disquete".

2) Cierra RStudio (por ejemplo, haz clic en la x de la esquina superior derecha para salir).

Ahora, practica la reapertura de *este proyecto "módulo1". ¿Recuerdas cómo?

quiz(caption = "Cuestionario: Reabrir RStudio",

     question("¿Cuáles de las formas mencionadas abajo funcionarán para abrir RStudio y continuar tu trabajo en un proyecto de RSTudio específico?",
              allow_retry = T,
              answer("Abrir RStudio desde el ícono del escritorio: automáticamente abrirá mi proyecto",
                     correct = FALSE,
                     message = "¡No necesariamente! Abrir RStudio genéricamente abrirá el proyecto utilizado más recientemente."),
              answer("Navegar a la carpeta del proyecto deseado y luego abrir el archivo de proyecto de RStudio",
                     correct = TRUE,
                     message = "Sí, puedes hacer click en el archivo del proyecto de RSTudio para abrir el proyecto deseado."),
              answer("Abrir RStudio y luego navegar usando el menú de arriba a la derecha hacia el proyecto en el que quiero trabajar.",
                     correct = TRUE,
                     message = "Sí, puedes navegar al proyecto desde dentro de RStudio.")
  )

)

Ahora que RStudio está abierto de nuevo en tu proyecto, ¿qué notas? Si has seguido las instrucciones del principio de este módulo sobre la configuración del espacio de trabajo y el manejo de ".RData", deberías ver que

Abre tu script de R y ejecuta los comandos de uno en uno, empezando por la parte superior del script. Observa cómo se recrean los objetos, se imprimen las salidas y se re-importan los datos. Si encuentras errores, considera la posibilidad de reordenar los comandos en el script. Si tienes confusión, consulta con un/a instructor/a.

Ten en cuenta que siempre debes ejecutar tu pacman::p_load() primero, para asegurarte de que tienes todos los paquetes necesarios y las funciones asociadas cargadas y listas para usar en tu sesión actual.

Nota: hemos guardado un script "solución" en la carpeta "intro_course/module1/backup". Es un ejemplo del aspecto que podría tener tu script al final del módulo.

Fin

¡Enhorabuena por terminar el primer módulo!

Pasa a la siguiente sección si quieres material extra...

Extras

Si terminas antes, aquí tienes algunas tareas para aprender más:

Guía de estilo de R

Ver esta Guía de estilo de Tidyverse para obtener consejos sobre cómo ajustarse a las mejores prácticas de codificación en R.

Instalar paquetes divertidos

Aunque la mayoría de los paquetes de R realizan análisis específicos o hacen que los flujos de trabajo sean más eficientes, los programadores de R también son gente divertida que creó paquetes para divertirse.

{praise}

Prueba a instalar el paquete de R {praise} y luego comprueba qué hace la función praise().

pacman::p_load(praise)

praise()

¡Este es un paquete divertido para usar si estás construyendo un tutorial!

{cowsay}

Ahora intenta instalar el paquete de R {cowsay}, un paquete para imprimir imágenes de animales hechas con símbolos de puntuación.

pacman::p_load(cowsay)

La función say() tiene un argumento obligatorio what = al que puedes proporcionar un valor nominal que será pronunciado por un gato:

say(what = "¡Hola, soy un gato que está aprendiendo R!")

El segundo argumento es by = y puede aceptar el nombre de otro animal, como "pollo", "yoda", "araña", "hormiga" o "rana".

say(what = "¡Incluso a las ranas les gusta aprender R!", by = "frog")

Puedes cambiar los colores con los argumentos by_color = y what_color =. Puedes ver más en la documentación del paquete introduciendo ?say en tu consola de R.

¡Diviértete con esto!

{aRtsy}

La funcionalidad de visualización de datos de R es de tan alta calidad que los usuarios han escrito un paquete para generar arte.

Instala el paquete {aRtsy} y cárgalo para utilizarlo.

pacman::p_load(aRtsy)

Algunas de las ilustraciones pueden tardar mucho tiempo en generarse (consulta la [documentación del paquete(https://koenderks.github.io/aRtsy/)]), pero prueba con éste:

canvas_collatz(colors = colorPalette("tuscany3"))

Como se describe en la documentación del paquete:

La conjetura de Collatz también se conoce como ecuación 3x+1. El algoritmo traza líneas según un conjunto de reglas sencillas: 1. Toma un número positivo al azar. 2. Si el número es par, divídelo por 2. 3. Si el número es impar, multiplícalo por 3 y súmale 1. 4. Repite la operación para obtener una secuencia de números. Al visualizar la secuencia de cada número, al superponer las secuencias que sean idénticas y al doblar los bordes de manera diferente para los números pares e impares de la secuencia, es posible generar estructuras con un aspecto orgánico.

Personalizar RStudio

Lee la información en este enlace y ajusta la configuración de tu RStudio a través del menú "Herramientas" y haciendo clic en "Opciones globales". ¿Qué ajustes de Apariencia prefieres?

Comunidades de usuarios de R

Busca en esta lista comunidades de usuarios de R y encuentra una cerca de ti. También puedes consultar la lista de R-Ladies, ¡uno de los mayores grupos de usuarios de R del mundo! Ahora que tienes una cuenta en Applied Epi, no olvides visitar el foro de la comunidad de applied epi. Este foro es un espacio para hacer preguntas sobre códigos de R, aprender sobre los paquetes o funciones de R que te interesen y discutir todo lo relacionado con R con antiguos alumnos, estudiantes actuales y miembros del equipo de Applied Epi.

Tidy Tuesday (Martes de orden)

Un fenómeno social de R muy popular es el "Tidy Tuesday", el día de la semana en que muchos usuarios de R realizan una tarea divertida de visualización de datos en R y la comparten con la comunidad. Es una forma divertida de practicar y aprender nuevos trucos de R.

Echa un vistazo al hash "TidyTuesday" en Twitter (o Sigue a @TidyTuesday_Bot) ¡y revisa los geniales gráficos que la gente hace con R!

Orígenes de R

Si te interesa, mira este vídeo de 7 minutos, entrevista en vídeo, con uno de los cofundadores de R, Ross Ihaka, producida por Maori TV en su Nueva Zelanda natal. Habla de su filosofía al crear R, de las influencias maoríes en su vida y mucho más.

Repasa lo básico

Lee el capítulo "Conceptos básicos de R" del Manual de Epi. Está lleno de cosas que has aprendido hoy, pero también de temas que te resultarán nuevos.

Si alguna sección te resulta confusa, pide aclaraciones a tu instructor/a.

Creación de funciones

La magia de R realmente ocurre cuando creas tus propias funciones. Ésta es una habilidad avanzada que no cubriremos en este curso, y normalmente no necesitas crear funciones hasta que seas un usuario de R más experimentado. No es necesario que pruebes este código, a menos que quieras hacerlo. Esto es puramente información adicional.

Sin embargo, este aspecto de R es donde realmente empieza a brillar su versatilidad. ¿Imaginas que pudieras convertir todo tu flujo de trabajo en un solo comando?

A modo de demostración, el script de la cadena de suministro de pruebas de la sección anterior se convierte en una función:

# Crear una función que acepta 4 entradas (1 es opcional) y retornal los requerimientos,
# basados en la ecuación

# Crear la función calc_test()
calc_tests <- function(lugar1, lugar2, lugar3, extra){   # Hacer una lista de argumentos y abrir la función

     needs <- ((lugar1 + lugar2 + lugar3)*1.1) - extra   # Agregar la ecuación dentro de la función
     return(needs)                                    # La función retorna el resultado
}                                                     # Cerrar la función

Una vez ejecutado el código anterior, la función queda definida (aparecerá en el panel de entorno de R igual que los demás objetos).

Ahora que la función calc_tests ha sido definida y creada, podemos utilizarla para ejecutar la ecuación dados los valores de los argumentos, así

calc_tests(lugar1 = 200, lugar2 = 550, lugar3 = (925*2), extra = 420)

O con distintos valores para los argumentos de la función:

calc_tests(lugar1 = 400, lugar2 = 150, lugar3 = (700*2), extra = 85)

¡Mira cómo hemos envuelto todo el código en una función! Muy chulo. Piensa en las posibilidades... ¡puedes crear funciones que satisfagan tus necesidades locales!

Si escribes una función que sea útil para otros, puedes publicarla en un paquete de R, una unidad de múltiples funciones relacionadas. Todos los demás pueden probar y ensayar tus funciones, ¡y tu trabajo puede ayudar a personas de todo el mundo! Ésta es la belleza del software de código abierto.

Revisa el capítulo Importar y Exportar

Este capítulo del Manual de Epi R cubre más detalles sobre la importación y exportación de datos, incluyendo:

Discutiremos el uso de here() en el próximo módulo.

Importar big data

Lee sobre el paquete de R {vroom} creado para importar rápidamente conjuntos de datos muy grandes. ¡Pruébalo!



appliedepi/introexercises documentation built on April 22, 2024, 1:01 a.m.

R Package Documentation

rdrr.io home R language documentation Run R code online

Browse R Packages

CRAN packages Bioconductor packages R-Forge packages GitHub packages

We want your feedback!

Note that we can't provide technical support on individual packages. You should contact the package authors for that.
GitHub issue tracker
ian@mutexlabs.com
Personal blog

 
Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.

Close