diff --git a/01-rstudio-intro.md b/01-rstudio-intro.md index 08cb2090..56de54b7 100644 --- a/01-rstudio-intro.md +++ b/01-rstudio-intro.md @@ -114,11 +114,11 @@ de "leer, evaluar, mostrar" (tú escribes comandos, R intenta ejecutarlos y lueg Lo más simple que podrías hacer con R es aritmética: -```r +``` r 1 + 100 ``` -```output +``` output [1] 101 ``` @@ -163,22 +163,22 @@ De mayor a menor precedencia: - Resta: `-` -```r +``` r 3 + 5 * 2 ``` -```output +``` output [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. -```r +``` r (3 + 5) * 2 ``` -```output +``` output [1] 16 ``` @@ -186,7 +186,7 @@ Esto puede ser difícil de manejar cuando no es necesario, pero aclara tus inten Recuerda que otros pueden leer tu código. -```r +``` r (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 @@ -197,11 +197,11 @@ El texto después de cada línea de código se llama "comentario". Todo lo que s Los números pequeños o grandes tienen una notación científica: -```r +``` r 2/10000 ``` -```output +``` output [1] 2e-04 ``` @@ -210,11 +210,11 @@ Es la abreviatura de "multiplicado por `10 ^ XX` ". Entonces `2e-4` es la abrevi Tú también puedes escribir números en notación científica: -```r +``` r 5e3 # nota la falta del signo menos aquí ``` -```output +``` output [1] 5000 ``` @@ -224,38 +224,38 @@ R tiene muchas funciones matemáticas integradas. Para llamar a una función, si Todo lo que escribas dentro de los paréntesis se llaman argumentos de la función: -```r +``` r sin(1) # función trigonométrica ``` -```output +``` output [1] 0.841471 ``` -```r +``` r log(1) # logaritmo natural ``` -```output +``` output [1] 0 ``` -```r +``` r log10(10) # logaritmo en base-10 ``` -```output +``` output [1] 1 ``` -```r +``` r exp(0.5) # e^(1/2) ``` -```output +``` output [1] 1.648721 ``` @@ -275,56 +275,56 @@ disponibles en el sitio de RStudio. Podemos realizar comparaciones en R: -```r +``` r 1 == 1 # igualdad (observa dos signos iguales, se lee como "es igual a") ``` -```output +``` output [1] TRUE ``` -```r +``` r 1 != 2 # desigualdad (leída como "no es igual a") ``` -```output +``` output [1] TRUE ``` -```r +``` r 1 < 2 # menor que ``` -```output +``` output [1] TRUE ``` -```r +``` r 1 <= 1 # menor o igual que ``` -```output +``` output [1] TRUE ``` -```r +``` r 1 > 0 # mayor que ``` -```output +``` output [1] TRUE ``` -```r +``` r 1 >= -9 # mayor o igual que ``` -```output +``` output [1] TRUE ``` @@ -354,18 +354,18 @@ Lectura adicional: [http://floating-point-gui.de/](https://floating-point-gui.de Podemos almacenar valores en variables usando el operador de asignación `<-`. Veamos un ejemplo: -```r +``` r 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`: -```r +``` r x ``` -```output +``` output [1] 0.025 ``` @@ -374,18 +374,18 @@ Más precisamente, el valor almacenado es una *aproximación decimal* de esta fr 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: -```r +``` r log(x) ``` -```output +``` output [1] -3.688879 ``` Ten en cuenta que las variables pueden reasignarse, es decir, puedes cambiar el valor almacenado en la variable: -```r +``` r x <- 100 ``` @@ -394,7 +394,7 @@ x <- 100 También, los valores de asignación pueden contener la variable asignada: -```r +``` r x <- x + 1 # observa cómo RStudio actualiza la descripción de x en la pestaña superior derecha y <- x * 2 ``` @@ -413,7 +413,7 @@ Lo que uses depende de ti, pero **sé consistente**. También es posible utilizar el operador `=` para la asignación: -```r +``` r x = 1/40 ``` @@ -429,7 +429,7 @@ Entonces la recomendación es usar `<-`. De los siguientes ejemplos, ¿Cuáles son nombres de variables válidas en R? -```r +``` r min_height max.height _age @@ -447,7 +447,7 @@ celsius2kelvin Los siguientes nombres de variables son válidos en R: -```r +``` r min_height max.height MaxLength @@ -457,14 +457,14 @@ celsius2kelvin El punto al inicio crea una variable oculta: -```r +``` r .mass ``` Los siguientes no son nombres de variables válidos en R: -```r +``` r _age min-length 2widths @@ -481,28 +481,28 @@ En contraste con los conceptos de vectores de física y matemáticas, un vector mismo tipo de datos en un cierto orden. Por ejemplo: -```r +``` r 1:5 ``` -```output +``` output [1] 1 2 3 4 5 ``` -```r +``` r 2^(1:5) ``` -```output +``` output [1] 2 4 8 16 32 ``` -```r +``` r x <- 1:5 2^x ``` -```output +``` output [1] 2 4 8 16 32 ``` @@ -516,11 +516,11 @@ Hay algunos comandos útiles que puedes usar para interactuar con la sesión de (tu sesión de trabajo en R): -```r +``` r ls() ``` -```output +``` output [1] "x" "y" ``` @@ -539,11 +539,11 @@ 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! -```r +``` r ls ``` -```output +``` output function (name, pos = -1L, envir = as.environment(pos), all.names = FALSE, pattern, sorted = TRUE) { @@ -575,14 +575,14 @@ function (name, pos = -1L, envir = as.environment(pos), all.names = FALSE, } else all.names } - + ``` Puedes usar `rm` para eliminar objetos que ya no necesitas: -```r +``` r rm(x) ``` @@ -590,7 +590,7 @@ Si tienes muchas cosas en tu entorno y deseas borrarlas todas, puedes pasar los resultados de `ls` y mandarlos a la función `rm`: -```r +``` r rm(list = ls()) ``` @@ -601,11 +601,11 @@ En este caso, hemos especificado que los resultados de `ls` se deben usar para e Si, en cambio, usamos `<-`, habrá efectos secundarios no deseados, o puedes recibir un mensaje de error: -```r +``` r rm(list <- ls()) ``` -```error +``` error Error in rm(list <- ls()): ... must contain names or character strings ``` @@ -642,7 +642,7 @@ R y RStudio tienen funcionalidad para administrar paquetes: ¿Cuál será el valor de cada variable después de cada comando en el siguiente programa? -```r +``` r mass <- 47.5 age <- 122 mass <- mass * 2.3 @@ -654,21 +654,21 @@ age <- age - 20 ## Solución al desafío 2 -```r +``` r mass <- 47.5 ``` Esto dará un valor de 47.5 para la variable mass -```r +``` r age <- 122 ``` Esto dará un valor de 122 para la variable age -```r +``` r mass <- mass * 2.3 ``` @@ -676,7 +676,7 @@ Multiplica el valor existente en mass 47.5 por 2.3 para dar un nuevo valor 109\.25 a la variable mass. -```r +``` r age <- age - 20 ``` @@ -703,11 +703,11 @@ Ejecuta el código del desafío anterior y escribe un comando para comparar la v Una forma de responder esta pregunta en R es usar `>` para hacer lo siguiente: -```r +``` r mass > age ``` -```output +``` output [1] TRUE ``` @@ -732,7 +732,7 @@ Limpia tu entorno de trabajo borrando las variables de `mass` y `age`. Podemos usar el comando `rm` para realizar esta tarea: -```r +``` r rm(age, mass) ``` @@ -753,7 +753,7 @@ Instala los siguientes paquetes: `ggplot2`, `plyr`, `gapminder`. Puedes utilizar el comando `install.packages()` para instalar los paquetes requeridos. -```r +``` r install.packages("ggplot2") install.packages("plyr") install.packages("gapminder") diff --git a/02-project-intro.md b/02-project-intro.md index 25e9be31..991c881a 100644 --- a/02-project-intro.md +++ b/02-project-intro.md @@ -129,7 +129,7 @@ trabajo y compartirlo con colaboradores. 3. Inicializa el proyecto: -```r +``` r install.packages("ProjectTemplate") library("ProjectTemplate") create.project("../my_project", merge.strategy = "allow.non.conflict") @@ -205,33 +205,33 @@ línea de comandos para contestar las siguientes preguntas: Al ejecutar estos comandos en la terminal: -```sh +``` sh ls -lh data/gapminder-FiveYearData.csv ``` -```output --rw-r--r-- 1 runner docker 80K May 21 00:27 data/gapminder-FiveYearData.csv +``` output +-rw-r--r-- 1 runner docker 80K Jun 4 00:33 data/gapminder-FiveYearData.csv ``` El tamaño del archivo es 80K. -```sh +``` sh wc -l data/gapminder-FiveYearData.csv ``` -```output +``` output 1705 data/gapminder-FiveYearData.csv ``` Hay 1705 líneas. Los datos se ven así: -```sh +``` sh head data/gapminder-FiveYearData.csv ``` -```output +``` output country,year,pop,continent,lifeExp,gdpPercap Afghanistan,1952,8425333,Asia,28.801,779.4453145 Afghanistan,1957,9240934,Asia,30.332,820.8530296 diff --git a/03-seeking-help.md b/03-seeking-help.md index c4a29256..8f157eae 100644 --- a/03-seeking-help.md +++ b/03-seeking-help.md @@ -40,7 +40,7 @@ para buscar ayuda en cualquier función, "function\_name", de una función espec cargado dentro de tu **namespace** (tu sesión interactiva en R): -```r +``` r ?function_name help(function_name) ``` @@ -76,7 +76,7 @@ uso correcto para cada función que usas. Afortunadamente, están los archivos d Para buscar ayuda en operadores especiales, usa comillas: -```r +``` r ?"<-" ``` @@ -95,7 +95,7 @@ Si un paquete no tiene viñetas, generalmente puedes encontrar ayuda escribiendo 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: -```r +``` r ??function_name ``` @@ -117,7 +117,7 @@ Si no puedes encontrar la respuesta, hay algunas funciones útiles para ayudarte a hacer una pregunta a tus compañeros: -```r +``` r ?dput ``` @@ -125,11 +125,11 @@ Descargará los datos con los que estás trabajando en un formato para que pueda ser copiados y pegados por cualquier otra persona en su sesión de R. -```r +``` r sessionInfo() ``` -```output +``` output R version 4.4.0 (2024-04-24) Platform: x86_64-pc-linux-gnu Running under: Ubuntu 22.04.4 LTS @@ -151,7 +151,7 @@ attached base packages: [1] stats graphics grDevices utils datasets methods base loaded via a namespace (and not attached): -[1] compiler_4.4.0 tools_4.4.0 yaml_2.3.8 knitr_1.46 xfun_0.43 +[1] compiler_4.4.0 tools_4.4.0 yaml_2.3.8 knitr_1.47 xfun_0.44 [6] renv_1.0.7 evaluate_0.23 ``` @@ -167,7 +167,7 @@ Buscar la ayuda para la función `c`. ¿Qué tipo de vector crees que crearás si evalúas lo siguiente?: -```r +``` r c(1, 2, 3) c('d', 'e', 'f') c(1, 2, 'f') @@ -202,7 +202,7 @@ Buscar la ayuda para la función `paste`. Tendrás que usar esto más tarde. Busca la ayuda de la función `paste()`, usa: -```r +``` r help("paste") ?paste ``` @@ -217,35 +217,35 @@ juntos utilizando el separador dado, y el resultado es una sola cadena. e.g. -```r +``` r paste(c("a","b"), "c") ``` -```output +``` output [1] "a c" "b c" ``` -```r +``` r paste(c("a","b"), "c", sep = ",") ``` -```output +``` output [1] "a,c" "b,c" ``` -```r +``` r paste(c("a","b"), "c", collapse = "|") ``` -```output +``` output [1] "a c|b c" ``` -```r +``` r paste(c("a","b"), "c", sep = ",", collapse = "|") ``` -```output +``` output [1] "a,c|b,c" ``` diff --git a/04-data-structures-part1.md b/04-data-structures-part1.md index 00bfd23e..43521093 100644 --- a/04-data-structures-part1.md +++ b/04-data-structures-part1.md @@ -48,7 +48,7 @@ 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: -```r +``` r color,peso,le_gusta_cuerda mixto,2.1,1 negro,5.0,0 @@ -58,14 +58,14 @@ atigrado,3.2,1 Podemos usar la función `data.frame` para crearlo. -```r +``` r gatos <- data.frame(color = c("mixto", "negro", "atigrado"), peso = c(2.1, 5.0, 3.2), le_gusta_cuerda = c(1, 0, 1)) gatos ``` -```output +``` output color peso le_gusta_cuerda 1 mixto 2.1 1 2 negro 5.0 0 @@ -88,12 +88,12 @@ Ahora sí usa `write.csv(gatos, "data/gatos-data.csv", row.names=FALSE)` para cr Podemos leer el archivo en R con el siguiente comando: -```r +``` r gatos <- read.csv(file = "data/gatos-data.csv", stringsAsFactors = TRUE) gatos ``` -```output +``` output color peso le_gusta_cuerda 1 mixto 2.1 1 2 negro 5.0 0 @@ -113,19 +113,19 @@ para `read.csv` y ` read.delim`. Podemos empezar a explorar el **dataset** inmediatamente proyectando las columnas usando el operador `$`: -```r +``` r gatos$peso ``` -```output +``` output [1] 2.1 5.0 3.2 ``` -```r +``` r gatos$color ``` -```output +``` output [1] mixto negro atigrado Levels: atigrado mixto negro ``` @@ -133,22 +133,22 @@ Levels: atigrado mixto negro Podemos hacer otras operaciones sobre las columnas. Por ejemplo, podemos aumentar el peso de todos los gatos con: -```r +``` r gatos$peso + 2 ``` -```output +``` output [1] 4.1 7.0 5.2 ``` Podemos imprimir los resultados en una oración -```r +``` r paste("El color del gato es", gatos$color) ``` -```output +``` output [1] "El color del gato es mixto" "El color del gato es negro" [3] "El color del gato es atigrado" ``` @@ -156,15 +156,15 @@ paste("El color del gato es", gatos$color) Pero qué pasa con: -```r +``` r gatos$peso + gatos$color ``` -```warning +``` warning Warning in Ops.factor(gatos$peso, gatos$color): '+' not meaningful for factors ``` -```output +``` output [1] NA NA NA ``` @@ -180,30 +180,30 @@ Hay 5 tipos de datos principales: `double`, `integer`, `complex`, `logical` and Podemos preguntar cuál es la estructura de datos si usamos la función `class`: -```r +``` r class(gatos$color) ``` -```output +``` output [1] "factor" ``` -```r +``` r class(gatos$peso) ``` -```output +``` output [1] "numeric" ``` También podemos ver que `gatos` es un **data.frame** si usamos la función `class`: -```r +``` r class(gatos) ``` -```output +``` output [1] "data.frame" ``` @@ -223,11 +223,11 @@ de los elementos del vector - en este caso **strings** vacíos. Podemos ver que `gatos$peso` es un vector usando la funcion `str`. -```r +``` r str(gatos$peso) ``` -```output +``` output num [1:3] 2.1 5 3.2 ``` @@ -262,27 +262,27 @@ a la larga, la consistencia estricta hace nuestras vidas más fáciles cuando us También puedes crear vectores con contenido explícito con la función **combine** o `c()`: -```r +``` r mi_vector <- c(2,6,3) mi_vector ``` -```output +``` output [1] 2 6 3 ``` -```r +``` r str(mi_vector) ``` -```output +``` output num [1:3] 2 6 3 ``` Dado lo que aprendimos hasta ahora, ¿qué crees que hace el siguiente código? -```r +``` r otro_vector <- c(2,6,'3') ``` @@ -292,21 +292,21 @@ los tipos de datos básicos y cómo R los interpreta. Cuando R encuentra una mez Considera: -```r +``` r vector_coercion <- c('a', TRUE) str(vector_coercion) ``` -```output +``` output chr [1:2] "a" "TRUE" ``` -```r +``` r otro_vector_coercion <- c(0, TRUE) str(otro_vector_coercion) ``` -```output +``` output num [1:2] 0 1 ``` @@ -315,38 +315,38 @@ Las reglas de coerción son: `logical` -> `integer` -> `numeric` -> `complex` -> Puedes intentar forzar la coerción de acuerdo a esta cadena usando las funciones `as.`: -```r +``` r vector_caracteres <- c('0','2','4') vector_caracteres ``` -```output +``` output [1] "0" "2" "4" ``` -```r +``` r str(vector_caracteres) ``` -```output +``` output chr [1:3] "0" "2" "4" ``` -```r +``` r caracteres_coercionados_numerico <- as.numeric(vector_caracteres) caracteres_coercionados_numerico ``` -```output +``` output [1] 0 2 4 ``` -```r +``` r numerico_coercionado_logico <- as.logical(caracteres_coercionados_numerico) numerico_coercionado_logico ``` -```output +``` output [1] FALSE TRUE TRUE ``` @@ -360,115 +360,115 @@ lo que nuestros datos representan. Podemos convertir esta columna al tipo de dat usando la función `as.logical`: -```r +``` r gatos$le_gusta_cuerda ``` -```output +``` output [1] 1 0 1 ``` -```r +``` r class(gatos$le_gusta_cuerda) ``` -```output +``` output [1] "integer" ``` -```r +``` r gatos$le_gusta_cuerda <- as.logical(gatos$le_gusta_cuerda) gatos$le_gusta_cuerda ``` -```output +``` output [1] TRUE FALSE TRUE ``` -```r +``` r class(gatos$le_gusta_cuerda) ``` -```output +``` output [1] "logical" ``` La función **combine**, `c()`, también agregará elementos al final de un vector existente: -```r +``` r ab <- c('a', 'b') ab ``` -```output +``` output [1] "a" "b" ``` -```r +``` r abc <- c(ab, 'c') abc ``` -```output +``` output [1] "a" "b" "c" ``` También puedes hacer una serie de números así: -```r +``` r mySerie <- 1:5 mySerie ``` -```output +``` output [1] 1 2 3 4 5 ``` -```r +``` r str(mySerie) ``` -```output +``` output int [1:5] 1 2 3 4 5 ``` -```r +``` r class(mySerie) ``` -```output +``` output [1] "integer" ``` Finalmente, puedes darle nombres a los elementos de tu vector: -```r +``` r names(mySerie) <- c("a", "b", "c", "d", "e") mySerie ``` -```output +``` output a b c d e 1 2 3 4 5 ``` -```r +``` r str(mySerie) ``` -```output +``` output Named int [1:5] 1 2 3 4 5 - attr(*, "names")= chr [1:5] "a" "b" "c" "d" ... ``` -```r +``` r class(mySerie) ``` -```output +``` output [1] "integer" ``` @@ -485,7 +485,7 @@ Multiplica el vector por 2 y asigna al vector resultante, los nombres de A hasta ## Solución del desafío 1 -```r +``` r x <- 1:26 x <- x * 2 names(x) <- LETTERS @@ -500,11 +500,11 @@ names(x) <- LETTERS Otra estructura de datos importante se llama **factor**. -```r +``` r str(gatos$color) ``` -```output +``` output Factor w/ 3 levels "atigrado","mixto",..: 2 3 1 ``` @@ -513,40 +513,40 @@ Por ejemplo, construyamos un vector de **strings** con etiquetas para las colora gatos en nuestro estudio: -```r +``` r capas <- c('atigrado', 'carey', 'carey', 'negro', 'atigrado') capas ``` -```output +``` output [1] "atigrado" "carey" "carey" "negro" "atigrado" ``` -```r +``` r str(capas) ``` -```output +``` output chr [1:5] "atigrado" "carey" "carey" "negro" "atigrado" ``` Podemos convertir un vector en un **factor** de la siguiente manera: -```r +``` r categorias <- factor(capas) class(categorias) ``` -```output +``` output [1] "factor" ``` -```r +``` r str(categorias) ``` -```output +``` output Factor w/ 3 levels "atigrado","carey",..: 1 2 2 3 1 ``` @@ -556,19 +556,19 @@ serie de números. R ha reemplazado las categorías con índices numéricos, lo muchos cálculos estadísticos usan esa representación para datos categóricos: -```r +``` r class(capas) ``` -```output +``` output [1] "character" ``` -```r +``` r class(categorias) ``` -```output +``` output [1] "factor" ``` @@ -588,7 +588,7 @@ en lugar de factores; luego escribe uno o más comandos para mostrar que el **fa Una solución es usar el argumento `stringAsFactors`: -```r +``` r gatos <- read.csv(file="data/gatos-data.csv", stringsAsFactors=FALSE) str(gatos$color) ``` @@ -597,7 +597,7 @@ Otra solución es usar el argumento `colClasses` que permiten un control más fino. -```r +``` r gatos <- read.csv(file="data/gatos-data.csv", colClasses=c(NA, NA, "character")) str(gatos$color) ``` @@ -617,13 +617,13 @@ que es el primer factor, pero por defecto los factores están etiquetados en orden alfabetico. Puedes cambiar esto especificando los niveles: -```r +``` r misdatos <- c("caso", "control", "control", "caso") factor_orden <- factor(misdatos, levels = c("control", "caso")) str(factor_orden) ``` -```output +``` output Factor w/ 2 levels "control","caso": 2 1 1 2 ``` @@ -638,12 +638,12 @@ es más simple en algunos aspectos que los otros tipos, porque puedes poner cual que tú quieras en ella: -```r +``` r lista <- list(1, "a", TRUE, 1+4i) lista ``` -```output +``` output [[1]] [1] 1 @@ -657,12 +657,12 @@ lista [1] 1+4i ``` -```r +``` r otra_lista <- list(title = "Numbers", numbers = 1:10, data = TRUE ) otra_lista ``` -```output +``` output $title [1] "Numbers" @@ -676,11 +676,11 @@ $data Ahora veamos algo interesante acerca de nuestro **data.frame**; ¿Qué pasa si corremos la siguiente línea? -```r +``` r typeof(gatos) ``` -```output +``` output [1] "list" ``` @@ -695,37 +695,37 @@ En nuestro ejemplo de `gatos`, tenemos una variable **integer**, una **double** ya hemos visto, cada columna del **data.frame** es un vector. -```r +``` r gatos$color ``` -```output +``` output [1] mixto negro atigrado Levels: atigrado mixto negro ``` -```r +``` r gatos[,1] ``` -```output +``` output [1] mixto negro atigrado Levels: atigrado mixto negro ``` -```r +``` r typeof(gatos[,1]) ``` -```output +``` output [1] "integer" ``` -```r +``` r str(gatos[,1]) ``` -```output +``` output Factor w/ 3 levels "atigrado","mixto",..: 2 3 1 ``` @@ -733,28 +733,28 @@ Cada fila es una *observación* de diferentes variables del mismo **data.frame** por lo tanto puede estar compuesto de elementos de diferentes tipos. -```r +``` r gatos[1,] ``` -```output +``` output color peso le_gusta_cuerda 1 mixto 2.1 TRUE ``` -```r +``` r typeof(gatos[1,]) ``` -```output +``` output [1] "list" ``` -```r +``` r str(gatos[1,]) ``` -```output +``` output 'data.frame': 1 obs. of 3 variables: $ color : Factor w/ 3 levels "atigrado","mixto",..: 2 $ peso : num 2.1 @@ -784,11 +784,11 @@ Investiga cada uno de los ejemplos anteriores y explica el resultado de cada uno ## Solución al desafío 3 -```r +``` r gatos[1] ``` -```output +``` output color 1 mixto 2 negro @@ -800,11 +800,11 @@ resulta en la primera proyección de la lista, como otra lista. En este caso es **data frame**. -```r +``` r gatos[[1]] ``` -```output +``` output [1] mixto negro atigrado Levels: atigrado mixto negro ``` @@ -813,11 +813,11 @@ El doble corchete `[[1]]` devuelve el contenido del elemento de la lista. En est es el contenido de la primera columna, un *vector* de tipo *factor*. -```r +``` r gatos$color ``` -```output +``` output [1] mixto negro atigrado Levels: atigrado mixto negro ``` @@ -826,11 +826,11 @@ Este ejemplo usa el caracter `$` para direccionar elementos por nombre. *color* primera columna del *data frame*, de nuevo un *vector* de tipo *factor*. -```r +``` r gatos["color"] ``` -```output +``` output color 1 mixto 2 negro @@ -841,11 +841,11 @@ Aquí estamos usando un solo corchete `["color"]` reemplazando el número del í el nombre de la columna. Como el ejemplo 1, el objeto devuelto es un *list*. -```r +``` r gatos[1, 1] ``` -```output +``` output [1] mixto Levels: atigrado mixto negro ``` @@ -855,11 +855,11 @@ El objeto devuelto es el valor en la fila 1, columna 1. El objeto es un *integer es parte de un *vector* de tipo *factor*, R muestra la etiqueta "mixto" asociada con el valor entero. -```r +``` r gatos[, 1] ``` -```output +``` output [1] mixto negro atigrado Levels: atigrado mixto negro ``` @@ -869,11 +869,11 @@ 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*. -```r +``` r gatos[1, ] ``` -```output +``` output color peso le_gusta_cuerda 1 mixto 2.1 TRUE ``` @@ -892,12 +892,12 @@ Por último, pero no menos importante, están las matrices. Podemos declarar una la siguiente forma: -```r +``` r matrix_example <- matrix(0, ncol=6, nrow=3) matrix_example ``` -```output +``` output [,1] [,2] [,3] [,4] [,5] [,6] [1,] 0 0 0 0 0 0 [2,] 0 0 0 0 0 0 @@ -907,51 +907,51 @@ matrix_example Y de manera similar a otras estructuras de datos, podemos preguntar cosas sobre la matriz: -```r +``` r class(matrix_example) ``` -```output +``` output [1] "matrix" "array" ``` -```r +``` r typeof(matrix_example) ``` -```output +``` output [1] "double" ``` -```r +``` r str(matrix_example) ``` -```output +``` output num [1:3, 1:6] 0 0 0 0 0 0 0 0 0 0 ... ``` -```r +``` r dim(matrix_example) ``` -```output +``` output [1] 3 6 ``` -```r +``` r nrow(matrix_example) ``` -```output +``` output [1] 3 ``` -```r +``` r ncol(matrix_example) ``` -```output +``` output [1] 6 ``` @@ -972,12 +972,12 @@ Inténtalo. `length(matrix_example)`? -```r +``` r matrix_example <- matrix(0, ncol=6, nrow=3) length(matrix_example) ``` -```output +``` output [1] 18 ``` @@ -1011,7 +1011,7 @@ Investiga como cambiar este comportamento. (Sugerencia: lee la documentación de la función **`matrix`**.) -```r +``` r x <- matrix(1:50, ncol=5, nrow=10) x <- matrix(1:50, ncol=5, nrow=10, byrow = TRUE) # to fill by row ``` @@ -1037,7 +1037,7 @@ que hemos visto hasta ahora. ## Solución al desafío 6 -```r +``` r dataTypes <- c('double', 'complex', 'integer', 'character', 'logical') dataStructures <- c('data.frame', 'vector', 'factor', 'list', 'matrix') answer <- list(dataTypes, dataStructures) @@ -1058,7 +1058,7 @@ para recordar la importancia de estos elementos básicos. Considera la salida de R para la siguiente matriz: -```output +``` output [,1] [,2] [1,] 4 1 [2,] 9 5 @@ -1081,7 +1081,7 @@ Piensa en qué matrices producirán los otros comandos. Considera la salida de R para la siguiente matriz: -```output +``` output [,1] [,2] [1,] 4 1 [2,] 9 5 @@ -1093,7 +1093,7 @@ cada comando e intenta determinar el correcto antes de escribirlos. Piensa en qué matrices producirán los otros comandos. -```r +``` r matrix(c(4, 1, 9, 5, 10, 7), ncol = 2, byrow = TRUE) ``` diff --git a/05-data-structures-part2.md b/05-data-structures-part2.md index 8f7861c7..3b4a6aef 100644 --- a/05-data-structures-part2.md +++ b/05-data-structures-part2.md @@ -46,29 +46,29 @@ Comando : Traducción 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: -```r +``` r gatos ``` -```output +``` output color peso legusta_la_cuerda 1 mixto 2.1 1 2 negro 5.0 0 3 atigrado 3.2 1 ``` -```r +``` r edad <- c(2,3,5) ``` Podemos entonces agregarlo como una columna via: -```r +``` r cbind(gatos, edad) ``` -```output +``` output color peso legusta_la_cuerda edad 1 mixto 2.1 1 2 2 negro 5.0 0 3 @@ -78,21 +78,21 @@ cbind(gatos, edad) 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. -```r +``` r edad <- c(2, 3, 5, 12) cbind(gatos, edad) ``` -```error +``` error Error in data.frame(..., check.names = FALSE): arguments imply differing number of rows: 3, 4 ``` -```r +``` r edad <- c(2, 3) cbind(gatos, edad) ``` -```error +``` error Error in data.frame(..., check.names = FALSE): arguments imply differing number of rows: 3, 2 ``` @@ -101,13 +101,13 @@ Error in data.frame(..., check.names = FALSE): arguments imply differing number Para que funcione, debemos tener `nrow(gatos)` = `length(edad)`. Vamos a sobrescribir el contenido de los gatos con nuestro nuevo marco de datos. -```r +``` r edad <- c(2, 3, 5) gatos <- cbind(gatos, edad) gatos ``` -```output +``` output color peso legusta_la_cuerda edad 1 mixto 2.1 1 2 2 negro 5.0 0 3 @@ -117,12 +117,12 @@ gatos 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: -```r +``` r nueva_fila <- list("carey", 3.3, TRUE, 9) gatos <- rbind(gatos, nueva_fila) ``` -```warning +``` warning Warning in `[<-.factor`(`*tmp*`, ri, value = "carey"): invalid factor level, NA generated ``` @@ -130,41 +130,41 @@ 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: -```r +``` r colores <- factor(c("negro","canela","canela","negro")) levels(colores) ``` -```output +``` output [1] "canela" "negro" ``` -```r +``` r nlevels(colores) ``` -```output +``` output [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. -```r +``` r colores ## el orden actual ``` -```output +``` output [1] negro canela canela negro Levels: canela negro ``` -```r +``` r colores <- factor(colores, levels = c("negro", "canela")) colores # despues de re-organizar ``` -```output +``` output [1] negro canela canela negro Levels: negro canela ``` @@ -179,15 +179,15 @@ La advertencia (*Warning*) nos está diciendo que agregamos 'carey' a nuestro fa *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: -```r +``` r levels(gatos$color) ``` -```output +``` output [1] "atigrado" "mixto" "negro" ``` -```r +``` r levels(gatos$color) <- c(levels(gatos$color), 'carey') gatos <- rbind(gatos, list("carey", 3.3, TRUE, 9)) ``` @@ -195,11 +195,11 @@ 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. -```r +``` r str(gatos) ``` -```output +``` output '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 @@ -207,12 +207,12 @@ str(gatos) $ edad : num 2 3 5 9 9 ``` -```r +``` r gatos$color <- as.character(gatos$color) str(gatos) ``` -```output +``` output 'data.frame': 5 obs. of 4 variables: $ color : chr "mixto" "negro" "atigrado" NA ... $ peso : num 2.1 5 3.2 3.3 3.3 @@ -249,11 +249,11 @@ Imaginemos que, como los perros, 1 año humano es equivalente a 7 años en los g 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. -```r +``` r gatos ``` -```output +``` output color peso legusta_la_cuerda edad 1 mixto 2.1 1 2 2 negro 5.0 0 3 @@ -265,11 +265,11 @@ gatos Podemos pedir el *data frame* sin la fila errónea: -```r +``` r gatos[-4,] ``` -```output +``` output color peso legusta_la_cuerda edad 1 mixto 2.1 1 2 2 negro 5.0 0 3 @@ -282,11 +282,11 @@ Notar que -4 significa que queremos remover la cuarta fila, la coma sin nada det Alternativamente, podemos eliminar filas que contengan valores `NA`: -```r +``` r na.omit(gatos) ``` -```output +``` output color peso legusta_la_cuerda edad 1 mixto 2.1 1 2 2 negro 5.0 0 3 @@ -297,7 +297,7 @@ na.omit(gatos) Volvamos a asignar el nuevo resultado *output* al *data frame* `gatos`, así nuestros cambios son permanentes: -```r +``` r gatos <- na.omit(gatos) ``` @@ -306,11 +306,11 @@ gatos <- na.omit(gatos) También podemos eliminar columnas en un *data frame*. Hay dos formas de eliminar una columna: por número o nombre de índice. -```r +``` r gatos[,-4] ``` -```output +``` output color peso legusta_la_cuerda 1 mixto 2.1 1 2 negro 5.0 0 @@ -323,12 +323,12 @@ Observa la coma sin nada antes, lo que indica que queremos mantener todas las fi Alternativamente, podemos quitar la columna usando el nombre del índice. -```r +``` r drop <- names(gatos) %in% c("edad") gatos[,!drop] ``` -```output +``` output color peso legusta_la_cuerda 1 mixto 2.1 1 2 negro 5.0 0 @@ -341,12 +341,12 @@ gatos[,!drop] 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): -```r +``` r gatos <- rbind(gatos, gatos) gatos ``` -```output +``` output color peso legusta_la_cuerda edad 1 mixto 2.1 1 2 2 negro 5.0 0 3 @@ -361,12 +361,12 @@ gatos Pero ahora los nombres de las filas *rownames* son complicados. Podemos removerlos y R los nombrará nuevamente, de manera secuencial: -```r +``` r rownames(gatos) <- NULL gatos ``` -```output +``` output color peso legusta_la_cuerda edad 1 mixto 2.1 1 2 2 negro 5.0 0 3 @@ -385,7 +385,7 @@ gatos Puedes crear un nuevo *data frame* desde R con la siguiente sintaxis: -```r +``` r df <- data.frame(id = c('a', 'b', 'c'), x = 1:3, y = c(TRUE, TRUE, FALSE), @@ -406,7 +406,7 @@ Finalmente, usa `cbind` para agregar una columna con espacio para que cada perso ## Solución al Desafío 2 -```r +``` r df <- data.frame(first = c('Grace'), apellido = c('Hopper'), numero_favorito = c(0), @@ -434,7 +434,7 @@ por tabuladores. De las tres variantes, `read.csv` es la más comúnmente usada. el signo de puntuación usado por defecto para ambas funciones: `read.csv` y `read.delim`. -```r +``` r gapminder <- read.csv("data/gapminder-FiveYearData.csv") ``` @@ -448,7 +448,7 @@ gapminder <- read.csv("data/gapminder-FiveYearData.csv") La función `read.csv` puede ser ejecutada para leer el archivo descargado, por ejemplo: -```r +``` 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("data/gapminder-FiveYearData.csv") ``` @@ -456,7 +456,7 @@ 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, -```r +``` r gapminder <- read.csv("https://raw.githubusercontent.com/swcarpentry/r-novice-gapminder/gh-pages/_episodes_rmd/data/gapminder-FiveYearData.csv") ``` @@ -468,11 +468,11 @@ gapminder <- read.csv("https://raw.githubusercontent.com/swcarpentry/r-novice-ga Vamos a investigar gapminder un poco; lo primero que hay que hacer siempre es ver cómo se ve el dataset usando `str`: -```r +``` r str(gapminder) ``` -```output +``` output '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 ... @@ -485,27 +485,27 @@ str(gapminder) También podemos examinar columnas individuales del *data frame* con la función `typeof`: -```r +``` r typeof(gapminder$year) ``` -```output +``` output [1] "integer" ``` -```r +``` r typeof(gapminder$country) ``` -```output +``` output [1] "character" ``` -```r +``` r str(gapminder$country) ``` -```output +``` output chr [1:1704] "Afghanistan" "Afghanistan" "Afghanistan" "Afghanistan" ... ``` @@ -513,63 +513,63 @@ También podemos interrogar al *data frame* por la información sobre sus dimens 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é? -```r +``` r length(gapminder) ``` -```output +``` output [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*. -```r +``` r typeof(gapminder) ``` -```output +``` output [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: -```r +``` r nrow(gapminder) ``` -```output +``` output [1] 1704 ``` -```r +``` r ncol(gapminder) ``` -```output +``` output [1] 6 ``` O, para obtener ambos de una vez: -```r +``` r dim(gapminder) ``` -```output +``` output [1] 1704 6 ``` Probablemente queremos saber los nombres de las columnas. Para hacerlo, podemos pedir: -```r +``` r colnames(gapminder) ``` -```output +``` output [1] "country" "year" "pop" "continent" "lifeExp" "gdpPercap" ``` @@ -578,11 +578,11 @@ A esta altura, es importante preguntarnos si la estructura de R está en sinton 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: -```r +``` r head(gapminder) ``` -```output +``` output country year pop continent lifeExp gdpPercap 1 Afghanistan 1952 8425333 Asia 28.801 779.4453 2 Afghanistan 1957 9240934 Asia 30.332 820.8530 @@ -607,11 +607,11 @@ Buscar líneas exactamente en el medio no es tan difícil, pero simplemente revi Para revisar las últimas líneas del *data frame* R tiene una función para esto: -```r +``` r tail(gapminder) ``` -```output +``` output country year pop continent lifeExp gdpPercap 1699 Zimbabwe 1982 7636524 Africa 60.363 788.8550 1700 Zimbabwe 1987 9216418 Africa 62.351 706.1573 @@ -621,11 +621,11 @@ tail(gapminder) 1704 Zimbabwe 2007 12311143 Africa 43.487 469.7093 ``` -```r +``` r tail(gapminder, n = 15) ``` -```output +``` output country year pop continent lifeExp gdpPercap 1690 Zambia 1997 9417789 Africa 40.238 1071.3538 1691 Zambia 2002 10595811 Africa 39.193 1071.6139 @@ -652,17 +652,17 @@ La solución que presentamos aquí utiliza funciones anidadas, por ejemplo una f 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*. -```r +``` r gapminder[sample(nrow(gapminder), 5), ] ``` -```output - country year pop continent lifeExp gdpPercap -916 Madagascar 1967 6334556 Africa 42.881 1634.0473 -618 Guinea 1977 4227026 Africa 40.762 874.6859 -798 Japan 1977 113872473 Asia 75.380 16610.3770 -783 Jamaica 1962 1665128 Americas 65.610 5246.1075 -868 Lebanon 1967 2186894 Asia 63.870 6006.9830 +``` output + country year pop continent lifeExp gdpPercap +388 Cuba 1967 8139332 Americas 68.290 5690.2680 +971 Mauritania 2002 2828858 Africa 62.247 1579.0195 +1338 Serbia 1977 8686367 Europe 70.300 12980.6696 +1633 Venezuela 1952 5439568 Americas 55.088 7689.7998 +289 China 1952 556263528 Asia 44.000 400.4486 ``` ::::::::::::::::::::::::: @@ -690,7 +690,7 @@ o apretando el botón de "source" en RStudio. Los contenidos de `scripts/load-gapminder.R`: -```r +``` 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") ``` @@ -700,7 +700,7 @@ Para ejecutar el script y cargar los archivos en la variable `gapminder`: Para ejecutar el script y cargar los archivos en la variable `gapminder`: -```r +``` r source(file = "scripts/load-gapminder.R") ``` diff --git a/06-data-subsetting.md b/06-data-subsetting.md index 9adc865d..b011f24a 100644 --- a/06-data-subsetting.md +++ b/06-data-subsetting.md @@ -31,13 +31,13 @@ para las diferentes estructuras de datos. Empecemos con el caballito de batalla de R: un vector numérico. -```r +``` r x <- c(5.4, 6.2, 7.1, 4.8, 7.5) names(x) <- c('a', 'b', 'c', 'd', 'e') x ``` -```output +``` output a b c d e 5.4 6.2 7.1 4.8 7.5 ``` @@ -60,21 +60,21 @@ Para extraer elementos o datos de un vector podemos usar su índice correspondie por uno: -```r +``` r x[1] ``` -```output +``` output a 5.4 ``` -```r +``` r x[4] ``` -```output +``` output d 4.8 ``` @@ -85,11 +85,11 @@ No lo parece, pero el operador corchetes es una función. Para los vectores También podemos pedir varios elementos al mismo tiempo: -```r +``` r x[c(1, 3)] ``` -```output +``` output a c 5.4 7.1 ``` @@ -97,11 +97,11 @@ x[c(1, 3)] O podemos tomar un rango del vector: -```r +``` r x[1:4] ``` -```output +``` output a b c d 5.4 6.2 7.1 4.8 ``` @@ -110,30 +110,30 @@ el operador `:` crea una sucesión de números del valor a la izquierda hasta el la derecha. -```r +``` r 1:4 ``` -```output +``` output [1] 1 2 3 4 ``` -```r +``` r c(1, 2, 3, 4) ``` -```output +``` output [1] 1 2 3 4 ``` También podemos pedir el mismo elemento varias veces: -```r +``` r x[c(1,1,3)] ``` -```output +``` output a a c 5.4 5.4 7.1 ``` @@ -142,11 +142,11 @@ Si pedimos por índices mayores a la longitud del vector, R regresará un valor faltante. -```r +``` r x[6] ``` -```output +``` output NA ``` @@ -157,11 +157,11 @@ Este es un vector de longitud uno que contiene un `NA`, cuyo nombre también es Si pedimos el elemento en el índice 0, obtendremos un vector vacío. -```r +``` r x[0] ``` -```output +``` output named numeric(0) ``` @@ -180,11 +180,11 @@ elemento de un vector tiene índice 0. En R, el primer elemento tiene el índice Si usamos un valor negativo como índice para un vector, R regresará cada elemento *excepto* lo que se ha especificado: -```r +``` r x[-2] ``` -```output +``` output a c d e 5.4 7.1 4.8 7.5 ``` @@ -192,11 +192,11 @@ x[-2] También podemos saltar o no mostrar varios elementos: -```r +``` r x[c(-1, -5)] # o bien x[-c(1,5)] ``` -```output +``` output b c d 6.2 7.1 4.8 ``` @@ -210,14 +210,14 @@ de elementos de un vector. Es natural tratar de filtrar una sucesión de la siguiente manera: -```r +``` r x[-1:3] ``` Esto nos devuelve un error algo críptico: -```error +``` error Error in x[-1:3]: only 0's may be mixed with negative subscripts ``` @@ -229,11 +229,11 @@ 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: -```r +``` r x[-(1:3)] ``` -```output +``` output d e 4.8 7.5 ``` @@ -244,12 +244,12 @@ Para quitar los elementos de un vector, será necesario que asignes el resultado de vuelta a la variable: -```r +``` r x <- x[-4] x ``` -```output +``` output a b c e 5.4 6.2 7.1 7.5 ``` @@ -261,13 +261,13 @@ x Dado el siguiente código: -```r +``` r x <- c(5.4, 6.2, 7.1, 4.8, 7.5) names(x) <- c('a', 'b', 'c', 'd', 'e') print(x) ``` -```output +``` output a b c d e 5.4 6.2 7.1 4.8 7.5 ``` @@ -275,7 +275,7 @@ print(x) Encuentra al menos 3 comandos distintos que produzcan la siguiente salida: -```output +``` output b c d 6.2 7.1 4.8 ``` @@ -287,41 +287,41 @@ Después de encontrar los tres comandos distintos, compáralos con los de tu vec ## Solución al desafío 1 -```r +``` r x[2:4] ``` -```output +``` output b c d 6.2 7.1 4.8 ``` -```r +``` r x[-c(1,5)] ``` -```output +``` output b c d 6.2 7.1 4.8 ``` -```r +``` r x[c("b", "c", "d")] ``` -```output +``` output b c d 6.2 7.1 4.8 ``` -```r +``` r x[c(2,3,4)] ``` -```output +``` output b c d 6.2 7.1 4.8 ``` @@ -335,12 +335,12 @@ x[c(2,3,4)] Podemos extraer elementos usando sus nombres, en lugar de extraerlos por índice: -```r +``` r 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")] ``` -```output +``` output a c 5.4 7.1 ``` @@ -354,11 +354,11 @@ de subconjuntos, ¡pero los nombres siempre permanecen iguales! También podemos usar un vector con elementos lógicos para hacer subconjuntos: -```r +``` r x[c(FALSE, FALSE, TRUE, FALSE, TRUE)] ``` -```output +``` output c e 7.1 7.5 ``` @@ -368,11 +368,11 @@ podemos usarlos para crear subconjuntos de manera mas sintética: la siguiente i tiene el mismo resultado que el anterior. -```r +``` r x[x > 7] ``` -```output +``` output c e 7.1 7.5 ``` @@ -385,11 +385,11 @@ Podemos usar `==` para imitar el método anterior de indexar con nombre (recordemos que se usa `==` en vez de `=` para comparar): -```r +``` r x[names(x) == "a"] ``` -```output +``` output a 5.4 ``` @@ -433,13 +433,13 @@ son `TRUE`). Dado el siguiente código: -```r +``` r x <- c(5.4, 6.2, 7.1, 4.8, 7.5) names(x) <- c('a', 'b', 'c', 'd', 'e') print(x) ``` -```output +``` output a b c d e 5.4 6.2 7.1 4.8 7.5 ``` @@ -452,12 +452,12 @@ a 4 pero menores que 7. ## Solución al desafío 3 -```r +``` r x_subset <- x[x<7 & x>4] print(x_subset) ``` -```output +``` output a b d 5.4 6.2 4.8 ``` @@ -476,39 +476,39 @@ de las filas deben ser únicos). Considera estos ejemplos: -```r +``` r x <- 1:3 x ``` -```output +``` output [1] 1 2 3 ``` -```r +``` r names(x) <- c('a', 'a', 'a') x ``` -```output +``` output a a a 1 2 3 ``` -```r +``` r x['a'] # solo devuelve el primer valor ``` -```output +``` output a 1 ``` -```r +``` r x[names(x) == 'a'] # devuelve todos los tres valores ``` -```output +``` output a a a 1 2 3 ``` @@ -530,12 +530,12 @@ comillas: 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 +``` 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"] ``` -```error +``` error Error in -"a": invalid argument to unary operator ``` @@ -543,11 +543,11 @@ Sin embargo, podemos usar el operador `!=` (no igual) para construir un vector con elementos lógicos, que es lo que nosotros queremos: -```r +``` r x[names(x) != "a"] ``` -```output +``` output b c d e 6.2 7.1 4.8 7.5 ``` @@ -556,16 +556,16 @@ 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 +``` r x[names(x)!=c("a","c")] ``` -```warning +``` warning Warning in names(x) != c("a", "c"): longer object length is not a multiple of shorter object length ``` -```output +``` output b c d e 6.2 7.1 4.8 7.5 ``` @@ -582,16 +582,16 @@ pregunta. Tomemos un momento para observar al operador de comparación en este código: -```r +``` r names(x) != c("a", "c") ``` -```warning +``` warning Warning in names(x) != c("a", "c"): longer object length is not a multiple of shorter object length ``` -```output +``` output [1] FALSE TRUE TRUE TRUE TRUE ``` @@ -626,11 +626,11 @@ Aquí, como queremos *excluir* los valores, nosotros también necesitamos el operador `!` para cambiar la inclusión por una *no* inclusión: -```r +``` r x[! names(x) %in% c("a","c") ] ``` -```output +``` output b d e 6.2 4.8 7.5 ``` @@ -651,7 +651,7 @@ Asia y `FALSE` en otros casos? Supongamos que se tienen los siguientes datos: -```r +``` 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) @@ -680,7 +680,7 @@ funcionan (o no). este problema es -```r +``` r (countries=="Myanmar" | countries=="Thailand" | countries=="Cambodia" | countries == "Vietnam" | countries=="Laos") ``` @@ -721,30 +721,30 @@ podemos hacer subconjuntos de otras estructuras de datos? Podemos hacer subconjuntos de factores de la misma manera que con los vectores. -```r +``` r f <- factor(c("a", "a", "b", "c", "c", "d")) f[f == "a"] ``` -```output +``` output [1] a a Levels: a b c d ``` -```r +``` r f[f %in% c("b", "c")] ``` -```output +``` output [1] b c c Levels: a b c d ``` -```r +``` r f[1:3] ``` -```output +``` output [1] a a b Levels: a b c d ``` @@ -753,11 +753,11 @@ Saltar elementos no quita el nivel, incluso cuando no existan datos en esa categoría del factor: -```r +``` r f[-3] ``` -```output +``` output [1] a a c c d Levels: a b c d ``` @@ -769,13 +769,13 @@ caso toma dos argumentos: el primero se aplica a las filas y el segundo a las columnas: -```r +``` r set.seed(1) m <- matrix(rnorm(6*4), ncol=4, nrow=6) m[3:4, c(3,1)] ``` -```output +``` output [,1] [,2] [1,] 1.12493092 -0.8356286 [2,] -0.04493361 1.5952808 @@ -785,11 +785,11 @@ Siempre puedes dejar el primer o segundo argumento vacío para obtener todas las o columnas respectivamente: -```r +``` r m[, c(3,4)] ``` -```output +``` output [,1] [,2] [1,] -0.62124058 0.82122120 [2,] -2.21469989 0.59390132 @@ -803,11 +803,11 @@ Si quisieramos acceder a solo una fila o una columna, R automáticamente convertirá el resultado a un vector: -```r +``` r m[3,] ``` -```output +``` output [1] -0.8356286 0.5757814 1.1249309 0.9189774 ``` @@ -815,11 +815,11 @@ Si quieres mantener la salida como una matriz, necesitas especificar un *tercer* argumento; `drop = FALSE`: -```r +``` r m[3, , drop=FALSE] ``` -```output +``` output [,1] [,2] [,3] [,4] [1,] -0.8356286 0.5757814 1.124931 0.9189774 ``` @@ -828,11 +828,11 @@ A diferencia de los vectores, si tratamos de acceder a una fila o columna fuera de la matriz, R arrojará un error: -```r +``` r m[, c(3,6)] ``` -```error +``` error Error in m[, c(3, 6)]: subscript out of bounds ``` @@ -851,11 +851,11 @@ Como las matrices son vectores, podemos también hacer subconjuntos usando solo un argumento: -```r +``` r m[5] ``` -```output +``` output [1] 0.3295078 ``` @@ -863,11 +863,11 @@ 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: -```r +``` r matrix(1:6, nrow=2, ncol=3) ``` -```output +``` output [,1] [,2] [,3] [1,] 1 3 5 [2,] 2 4 6 @@ -876,11 +876,11 @@ matrix(1:6, nrow=2, ncol=3) Si quisieramos llenar una matriz por filas, usamos `byrow=TRUE`: -```r +``` r matrix(1:6, nrow=2, ncol=3, byrow=TRUE) ``` -```output +``` output [,1] [,2] [,3] [1,] 1 2 3 [2,] 4 5 6 @@ -896,12 +896,12 @@ sus filas y de sus columnas en vez de usar sus índices. Dado el siguiente código: -```r +``` r m <- matrix(1:18, nrow=3, ncol=6) print(m) ``` -```output +``` output [,1] [,2] [,3] [,4] [,5] [,6] [1,] 1 4 7 10 13 16 [2,] 2 5 8 11 14 17 @@ -941,12 +941,12 @@ lista, pero no quieres *extraer* un elemento, entonces probablemente usarás `[`. -```r +``` r xlist <- list(a = "Software Carpentry", b = 1:10, data = head(mtcars)) xlist[1] ``` -```output +``` output $a [1] "Software Carpentry" ``` @@ -960,11 +960,11 @@ condición en la estructura de datos de los elementos de la lista, y no en los elementos individuales de dichas estructuras de datos. -```r +``` r xlist[1:2] ``` -```output +``` output $a [1] "Software Carpentry" @@ -976,11 +976,11 @@ Para extraer elementos individuales de la lista, tendrás que hacer uso de la función doble corchete: `[[`. -```r +``` r xlist[[1]] ``` -```output +``` output [1] "Software Carpentry" ``` @@ -989,44 +989,44 @@ Nota que ahora el resultados es un vector, no una lista. No puedes extraer más de un elemento al mismo tiempo: -```r +``` r xlist[[1:2]] ``` -```error +``` error Error in xlist[[1:2]]: subscript out of bounds ``` Tampoco puedes usarlo para saltar elementos: -```r +``` r xlist[[-1]] ``` -```error +``` error Error in xlist[[-1]]: invalid negative subscript in get1index ``` Pero tú puedes usar los nombres para hacer subconjuntos y extraer elementos: -```r +``` r xlist[["a"]] ``` -```output +``` output [1] "Software Carpentry" ``` La función `$` es una manera abreviada para extraer elementos por nombre: -```r +``` r xlist$data ``` -```output +``` output 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 @@ -1043,7 +1043,7 @@ Valiant 18.1 6 225 105 2.76 3.460 20.22 1 0 3 1 Dada la siguiente lista: -```r +``` r xlist <- list(a = "Software Carpentry", b = 1:10, data = head(mtcars)) ``` @@ -1056,29 +1056,29 @@ Pista: el número 2 está contenido en el elemento "b" de la lista. ## Solución al desafío 5 -```r +``` r xlist$b[2] ``` -```output +``` output [1] 2 ``` -```r +``` r xlist[[2]][2] ``` -```output +``` output [1] 2 ``` -```r +``` r xlist[["b"]][2] ``` -```output +``` output [1] 2 ``` @@ -1093,7 +1093,7 @@ xlist[["b"]][2] Dado un modelo lineal: -```r +``` r mod <- aov(pop ~ lifeExp, data=gapminder) ``` @@ -1105,12 +1105,12 @@ ayudar) ## Solución del desafío 6 -```r +``` r attributes(mod) ## `df.residual` es uno de los nombres de `mod` ``` -```r +``` r mod$df.residual ``` @@ -1128,11 +1128,11 @@ donde cada elemento de la lista corresponde a una columna. El objeto devuelto será una **data frame**: -```r +``` r head(gapminder[3]) ``` -```output +``` output pop 1 8425333 2 9240934 @@ -1145,22 +1145,22 @@ head(gapminder[3]) Similarmente, `[[` extraerá *una sola columna*: -```r +``` r head(gapminder[["lifeExp"]]) ``` -```output +``` output [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: -```r +``` r gapminder[1:3,] ``` -```output +``` output country year pop continent lifeExp gdpPercap 1 Afghanistan 1952 8425333 Asia 28.801 779.4453 2 Afghanistan 1957 9240934 Asia 30.332 820.8530 @@ -1171,11 +1171,11 @@ Si nuestro subconjunto es una sola fila, el resultado será una **data frame** (porque los elementos son de distintos tipos): -```r +``` r gapminder[3,] ``` -```output +``` output country year pop continent lifeExp gdpPercap 3 Afghanistan 1962 10267083 Asia 31.997 853.1007 ``` @@ -1193,21 +1193,21 @@ Corrige cada uno de los siguientes errores para hacer subconjuntos de 1. Extraer observaciones colectadas en el año 1957 - ```r + ``` r gapminder[gapminder$year = 1957,] ``` 2. Extraer todas las columnas excepto de la 1 a la 4 -```r +``` r gapminder[,-1:4] ``` 3. Extraer las filas donde la esperanza de vida es mayor a 80 años - ```r + ``` r gapminder[gapminder$lifeExp > 80] ``` @@ -1215,7 +1215,7 @@ Corrige cada uno de los siguientes errores para hacer subconjuntos de (`lifeExp` y `gdpPercap`). - ```r + ``` r gapminder[1, 4, 5] ``` @@ -1223,7 +1223,7 @@ Corrige cada uno de los siguientes errores para hacer subconjuntos de y 2007 - ```r + ``` r gapminder[gapminder$year == 2002 | 2007,] ``` @@ -1237,7 +1237,7 @@ Corrige cada uno de los siguientes errores para hacer subconjuntos de 1. Extraer observaciones colectadas en el año 1957 - ```r + ``` r # gapminder[gapminder$year = 1957,] gapminder[gapminder$year == 1957,] ``` @@ -1245,7 +1245,7 @@ Corrige cada uno de los siguientes errores para hacer subconjuntos de 2. Extraer todas las columnas excepto de la 1 a la 4 - ```r + ``` r # gapminder[,-1:4] gapminder[,-c(1:4)] ``` @@ -1253,7 +1253,7 @@ Corrige cada uno de los siguientes errores para hacer subconjuntos de 3. Extraer las filas donde la esperanza de vida es mayor a 80 años - ```r + ``` r # gapminder[gapminder$lifeExp > 80] gapminder[gapminder$lifeExp > 80,] ``` @@ -1262,7 +1262,7 @@ Corrige cada uno de los siguientes errores para hacer subconjuntos de (`lifeExp` y `gdpPercap`). - ```r + ``` r # gapminder[1, 4, 5] gapminder[1, c(4, 5)] ``` @@ -1271,7 +1271,7 @@ Corrige cada uno de los siguientes errores para hacer subconjuntos de y 2007 - ```r + ``` r # gapminder[gapminder$year == 2002 | 2007,] gapminder[gapminder$year == 2002 | gapminder$year == 2007,] gapminder[gapminder$year %in% c(2002, 2007),] @@ -1300,7 +1300,7 @@ Corrige cada uno de los siguientes errores para hacer subconjuntos de 2. -```r +``` r gapminder_small <- gapminder[c(1:9, 19:23),] ``` diff --git a/07-control-flow.md b/07-control-flow.md index 69772a8c..94fd1edb 100644 --- a/07-control-flow.md +++ b/07-control-flow.md @@ -27,7 +27,7 @@ Hay varias maneras de controlar el flujo en R. Para declaraciones condicionales, los enfoques más comúnmente utilizados son los **constructs**: -```r +``` r # if if (la condición es verdad) { realizar una acción @@ -44,7 +44,7 @@ if (la condición es verdad) { Digamos, por ejemplo, que queremos que R imprima un mensaje si una variable `x` tiene un valor en particular: -```r +``` r x <- 8 if (x >= 10) { @@ -54,14 +54,14 @@ if (x >= 10) { x ``` -```output +``` output [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** -```r +``` r x <- 8 if (x >= 10) { @@ -71,14 +71,14 @@ if (x >= 10) { } ``` -```output +``` output [1] "x es menor a 10" ``` También podemos testear múltiples condiciones usando **else if** -```r +``` r x <- 8 if (x >= 10) { @@ -90,7 +90,7 @@ if (x >= 10) { } ``` -```output +``` output [1] "x es mayor a 5, pero menor a 10" ``` @@ -99,7 +99,7 @@ elementos lógicos como `TRUE` o `FALSE`. Entender esto puede ser un dolor de ca los principiantes. Por ejemplo: -```r +``` r x <- 4 == 3 if (x) { "4 igual a 3" @@ -108,19 +108,19 @@ if (x) { } ``` -```output +``` output [1] "4 no es igual a 3" ``` Como podemos observar se muestra el mensaje es igual porque el vector x es `FALSE` -```r +``` r x <- 4 == 3 x ``` -```output +``` output [1] FALSE ``` @@ -141,28 +141,28 @@ 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`: -```r +``` r gapminder[(gapminder$year == 2002),] ``` Luego, contamos el número de filas del data.frame `gapminder` que corresponde al año 2002: -```r +``` r 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: -```r +``` r rows2002_number >= 1 ``` Entonces podríamos escribir: -```r +``` r if(nrow(gapminder[(gapminder$year == 2002),]) >= 1){ print("Se encontraron registro(s) para el año 2002.") } @@ -171,7 +171,7 @@ if(nrow(gapminder[(gapminder$year == 2002),]) >= 1){ Todo esto se puede hacer más rápido con `any()`. En dicho caso la condición lógica se puede expresar como: -```r +``` r if(any(gapminder$year == 2002)){ print("Se encontraron registro(s) para el año 2002.") } @@ -184,7 +184,7 @@ if(any(gapminder$year == 2002)){ ¿Alguien recibió un mensaje de advertencia como este? -```error +``` error Error in eval(expr, envir, enclos): object 'gapminder' not found ``` @@ -217,7 +217,7 @@ como cuando el cálculo de cada iteración dependa del resultado de la iteració La estructura básica de un bucle `for()` es: -```r +``` r for(iterador in conjunto de valores){ haz alguna acción } @@ -226,13 +226,13 @@ for(iterador in conjunto de valores){ Por ejemplo: -```r +``` r for(i in 1:10){ print(i) } ``` -```output +``` output [1] 1 [1] 2 [1] 3 @@ -252,7 +252,7 @@ Podemos usar un bucle `for()` anidado con otro bucle `for()` para iterar sobre a la vez. -```r +``` r for(i in 1:5){ for(j in c('a', 'b', 'c', 'd', 'e')){ print(paste(i,j)) @@ -260,7 +260,7 @@ for(i in 1:5){ } ``` -```output +``` output [1] "1 a" [1] "1 b" [1] "1 c" @@ -291,7 +291,7 @@ for(i in 1:5){ En lugar de mostrar los resultados en la pantalla podríamos guardarlos en un nuevo objeto. -```r +``` r output_vector <- c() for(i in 1:5){ for(j in c('a', 'b', 'c', 'd', 'e')){ @@ -302,7 +302,7 @@ for(i in 1:5){ output_vector ``` -```output +``` output [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" @@ -331,7 +331,7 @@ Una mejor manera es definir el objeto de salida (vacío) antes de completar los Aunque para este ejemplo parece más complicado, es aún más eficiente. -```r +``` r output_matrix <- matrix(nrow=5, ncol=5) j_vector <- c('a', 'b', 'c', 'd', 'e') for(i in 1:5){ @@ -345,7 +345,7 @@ output_vector2 <- as.vector(output_matrix) output_vector2 ``` -```output +``` output [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" @@ -359,7 +359,7 @@ 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()`. -```r +``` r while(mientras esta condición es verdad){ haz algo } @@ -370,7 +370,7 @@ partir de una distribución uniforme (la función `runif()` ) entre 0 y 1 hasta que obtiene uno que es menor a 0.1. -```r +``` r z <- 1 while(z > 0.1){ z <- runif(1) @@ -399,21 +399,21 @@ Compara los objetos output\_vector y output\_vector2. ¿Son lo mismo? Si no, ¿p Podemos verificar si dos vectores son idénticos usando la función `all()` : -```r +``` r all(output_vector == output_vector2) ``` Sin embargo todos los elementos de `output_vector` se pueden encontrar en `output_vector2`: -```r +``` r all(output_vector %in% output_vector2) ``` y viceversa: -```r +``` r all(output_vector2 %in% output_vector) ``` @@ -425,28 +425,28 @@ La solución es transponer la `output_matrix`. Podemos hacerlo llamando a la fun La primera solución requiere cambiar el original -```r +``` r output_vector2 <- as.vector(output_matrix) ``` por -```r +``` r output_vector2 <- as.vector(t(output_matrix)) ``` La segunda solución requiere cambiar -```r +``` r output_matrix[i, j] <- temp_output ``` por -```r +``` r output_matrix[j, i] <- temp_output ``` @@ -469,7 +469,7 @@ años. **Paso 1**: Queremos asegurarnos de que podamos extraer todos los valores únicos del vector continente -```r +``` r gapminder <- read.csv("data/gapminder-FiveYearData.csv") unique(gapminder$continent) ``` @@ -482,7 +482,7 @@ Podemos hacer eso de la siguiente manera: 3. Regresar la expectativa de vida calculada al usuario imprimiendo el resultado: -```r +``` r for( iContinent in unique(gapminder$continent) ){ tmp <- mean(subset(gapminder, continent==iContinent)$lifeExp) cat("Average Life Expectancy in", iContinent, "is", tmp, "\n") @@ -496,7 +496,7 @@ 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": -```r +``` r thresholdValue <- 50 for( iContinent in unique(gapminder$continent) ){ @@ -530,7 +530,7 @@ países. En esta oportunidad que imprima si la esperanza de vida es menor que 50 Modificamos nuestra solución al Reto 3 agregando ahora dos umbrales, `lowerThreshold` y` upperThreshold` y extendiendo nuestras declaraciones if-else: -```r +``` r lowerThreshold <- 50 upperThreshold <- 70 @@ -550,7 +550,7 @@ for( iCountry in unique(gapminder$country) ){ } ``` -```error +``` error Error in eval(expr, envir, enclos): object 'gapminder' not found ``` @@ -578,7 +578,7 @@ Si seguimos la lección de Shell de Unix podríamos vernos tentados de probar lo siguiente -```r +``` r grep("^B", unique(gapminder$country)) ``` @@ -588,7 +588,7 @@ Para obtener los valores, debemos agregar la opción `value = TRUE` al comando` grep`: -```r +``` r grep("^B", unique(gapminder$country), value=TRUE) ``` @@ -601,7 +601,7 @@ y de ser menor a 50 usamos un gráfico base para trazar la evolución de la expectativa de vida promedio: -```r +``` r thresholdValue <- 50 candidateCountries <- grep("^B", unique(gapminder$country), value=TRUE) diff --git a/08-plot-ggplot2.md b/08-plot-ggplot2.md index fba6bb9c..ef20847c 100644 --- a/08-plot-ggplot2.md +++ b/08-plot-ggplot2.md @@ -61,7 +61,7 @@ ggplot(data = , mapping = aes()) + () -```r +``` r library("ggplot2") ggplot(data = gapminder) ``` @@ -73,7 +73,7 @@ ggplot(data = gapminder) buscar esa columna en los **datos**!: -```r +``` r ggplot(data = gapminder, mapping = aes(x = gdpPercap, y = lifeExp)) ``` @@ -88,7 +88,7 @@ ggplot(data = gapminder, mapping = aes(x = gdpPercap, y = lifeExp)) Para agregar un geom, usa el operador `+`. ¡Podemos agregar varios geoms unidos a través de múltiples operadores `+`! Observa que en la figura anterior, llamar a la función **`ggplot`** no fue suficiente para obtener un gráfico, debemos agregar un geom. Podemos usar **`geom_point`** para representar visualmente la relación entre **x** y **y** como un gráfico de dispersión de puntos (**scatterplot**). -```r +``` r ggplot(data = gapminder, mapping = aes(x = gdpPercap, y = lifeExp)) + geom_point() ``` @@ -103,7 +103,7 @@ Modifica el ejemplo anterior de manera que en la figura se muestre como la esperanza de vida ha cambiado a través del tiempo: -```r +``` r ggplot(data = gapminder, aes(x = gdpPercap, y = lifeExp)) + geom_point() ``` @@ -120,7 +120,7 @@ como la esperanza de vida ha cambiado a través del tiempo: Esta es una posible solución: -```r +``` r ggplot(data = gapminder, aes(x = year, y = lifeExp)) + geom_point() ``` @@ -149,7 +149,7 @@ es el *color*. Modifica el código del desafío anterior para **colorear** los p "continent". ¿Qué tendencias observas en los datos? ¿Son lo que esperabas? -```r +``` r ggplot(data = gapminder, aes(x = year, y = lifeExp, color=continent)) + geom_point() ``` @@ -166,7 +166,7 @@ Un gráfico de dispersión probablemente no es la mejor manera de visualizar el En vez de eso, vamos a decirle a `ggplot` que queremos visualizar los datos como un diagrama de línea (line plot): -```r +``` r ggplot(data = gapminder, aes(x=year, y=lifeExp, by=country, color=continent)) + geom_line() ``` @@ -181,7 +181,7 @@ Pero, ¿qué pasa si queremos visualizar ambos, puntos y líneas en la misma gr Simplemente tenemos que agregar otra capa al gráfico: -```r +``` r ggplot(data = gapminder, aes(x=year, y=lifeExp, by=country, color=continent)) + geom_line() + geom_point() ``` @@ -192,7 +192,7 @@ Es importante notar que cada capa se dibuja encima de la capa anterior. En este los puntos se han dibujado *sobre* las líneas. A continuación observamos una demostración: -```r +``` r ggplot(data = gapminder, aes(x=year, y=lifeExp, by=country)) + geom_line(aes(color=continent)) + geom_point() ``` @@ -231,7 +231,7 @@ Intercambia el orden de las capas de los puntos y líneas del ejemplo anterior. Intercambia el orden de las capas de los puntos y líneas del ejemplo anterior. ¿Qué sucede? -```r +``` r ggplot(data = gapminder, aes(x=year, y=lifeExp, by=country)) + geom_point() + geom_line(aes(color=continent)) ``` @@ -250,7 +250,7 @@ ggplot(data = gapminder, aes(x=year, y=lifeExp, by=country)) + Para demostrarlo regresaremos a nuestro primer ejemplo: -```r +``` r ggplot(data = gapminder, aes(x = gdpPercap, y = lifeExp, color=continent)) + geom_point() ``` @@ -265,7 +265,7 @@ de los puntos, usando la función *alpha*, la cual es especialmente útil cuando gran cantidad de datos fuertemente conglomerados. -```r +``` r ggplot(data = gapminder, aes(x = gdpPercap, y = lifeExp)) + geom_point(alpha = 0.5) + scale_x_log10() ``` @@ -295,12 +295,12 @@ Podemos ajustar una relación simple a los datos agregando otra capa, `geom_smooth`: -```r +``` r ggplot(data = gapminder, aes(x = gdpPercap, y = lifeExp)) + geom_point() + scale_x_log10() + geom_smooth(method="lm") ``` -```output +``` output `geom_smooth()` using formula = 'y ~ x' ``` @@ -309,12 +309,12 @@ ggplot(data = gapminder, aes(x = gdpPercap, y = lifeExp)) + Podemos hacer la línea más gruesa *configurando* el argumento **aesthetic** **tamaño** en la capa `geom_smooth`: -```r +``` r ggplot(data = gapminder, aes(x = gdpPercap, y = lifeExp)) + geom_point() + scale_x_log10() + geom_smooth(method="lm", size=1.5) ``` -```warning +``` warning Warning: Using `size` aesthetic for lines was deprecated in ggplot2 3.4.0. ℹ Please use `linewidth` instead. This warning is displayed once every 8 hours. @@ -322,7 +322,7 @@ Call `lifecycle::last_lifecycle_warnings()` to see where this warning was generated. ``` -```output +``` output `geom_smooth()` using formula = 'y ~ x' ``` @@ -349,13 +349,13 @@ Modifica el color y el tamaño de los puntos en la capa puntos en el ejemplo ant Pista: No uses la función `aes`. -```r +``` r ggplot(data = gapminder, aes(x = gdpPercap, y = lifeExp)) + geom_point(size=3, color="orange") + scale_x_log10() + geom_smooth(method="lm", size=1.5) ``` -```output +``` output `geom_smooth()` using formula = 'y ~ x' ``` @@ -386,13 +386,13 @@ incluyendo líneas de tendencia. Pista: El argumento color puede ser usado dentro de **aesthetic** -```r +``` r ggplot(data = gapminder, aes(x = gdpPercap, y = lifeExp, color = continent)) + geom_point(size=3, shape=17) + scale_x_log10() + geom_smooth(method="lm", size=1.5) ``` -```output +``` output `geom_smooth()` using formula = 'y ~ x' ``` @@ -422,7 +422,7 @@ es equivalente a `starts.with == "A" | starts.with == "Z"`) :::::::::::::::::::::::::::::::::::::::::::::::::: -```r +``` r starts.with <- substr(gapminder$country, start = 1, stop = 1) az.countries <- gapminder[starts.with %in% c("A", "Z"), ] ggplot(data = az.countries, aes(x = year, y = lifeExp, color=continent)) + @@ -449,7 +449,7 @@ el título de la leyenda de los colores de las líneas se define utilizando `col de la leyenda del color del relleno se definiría utilizando `fill = "MyTitle"`. -```r +``` r ggplot(data = az.countries, aes(x = year, y = lifeExp, color=continent)) + geom_line() + facet_wrap( ~ country) + labs( @@ -472,7 +472,7 @@ Para poder guardar la gráfica de arriba, primero tenemos que asignarla a una va llamada `results/` en tu directorio de trabajo.) -```r +``` r lifeExp_plot <- ggplot(data = az.countries, aes(x = year, y = lifeExp, color=continent)) + geom_line() + facet_wrap( ~ country) + labs( @@ -485,7 +485,7 @@ lifeExp_plot <- ggplot(data = az.countries, aes(x = year, y = lifeExp, color=con ggsave(filename = "results/lifeExp.png", plot = lifeExp_plot, width = 12, height = 10, dpi = 300, units = "cm") ``` -```error +``` error Error in `ggsave()`: ! Cannot find directory 'results'. ℹ Please supply an existing directory or use `create.dir = TRUE`. @@ -526,7 +526,7 @@ Avanzado: - Agrega una capa **facet** para generar gráficos de densidad con un panel para cada año. -```r +``` r ggplot(data = gapminder, aes(x = gdpPercap, fill=continent)) + geom_density(alpha=0.6) + facet_wrap( ~ year) + scale_x_log10() ``` diff --git a/09-vectorization.md b/09-vectorization.md index 78236f80..cef143a9 100644 --- a/09-vectorization.md +++ b/09-vectorization.md @@ -25,12 +25,12 @@ de cada elemento y actuar sobre cada uno de ellos. Esto hace la escritura de có concisa, fácil de leer y menos propenso a errores. -```r +``` r x <- 1:4 x * 2 ``` -```output +``` output [1] 2 4 6 8 ``` @@ -39,19 +39,19 @@ La multiplicación se aplicó a cada elemento del vector. También podemos sumar dos vectores juntos: -```r +``` r y <- 6:9 x + y ``` -```output +``` output [1] 7 9 11 13 ``` Cada elemento de `x` fue sumado a su correspondiente elemento de `y`: -```r +``` r x: 1 2 3 4 + + + + y: 6 7 8 9 @@ -82,12 +82,12 @@ Comprueba el principio o el final del **data frame** para asegurar que funcionó. -```r +``` r gapminder$pop_millions <- gapminder$pop / 1e6 head(gapminder) ``` -```output +``` output country year pop continent lifeExp gdpPercap pop_millions 1 Afghanistan 1952 8425333 Asia 28.801 779.4453 8.425333 2 Afghanistan 1957 9240934 Asia 30.332 820.8530 9.240934 @@ -119,14 +119,14 @@ Indonesia. Nuevamente, no te preocupes acerca de cuál es cuál. Recuerda tus habilidades de graficación al crear una gráfica con la población en millones en comparación con el año. -```r +``` r ggplot(gapminder, aes(x = year, y = pop_millions)) + geom_point() ``` -```r +``` r countryset <- c("China","India","Indonesia") ggplot(gapminder[gapminder$country %in% countryset,], aes(x = year, y = pop_millions)) + @@ -145,23 +145,23 @@ vectorizadas: **Operadores de Comparación** -```r +``` r x > 2 ``` -```output +``` output [1] FALSE FALSE TRUE TRUE ``` **Operadores Lógicos** -```r +``` r a <- x > 3 # o, para más claridad, a <- (x > 3) a ``` -```output +``` output [1] FALSE FALSE FALSE TRUE ``` @@ -180,24 +180,24 @@ La mayoría de las funciones también operan elemento por elemento en los vector **Funciones** -```r +``` r x <- 1:4 log(x) ``` -```output +``` output [1] 0.0000000 0.6931472 1.0986123 1.3862944 ``` Operaciones vectorizadas en matrices: -```r +``` r m <- matrix(1:12, nrow=3, ncol=4) m * -1 ``` -```output +``` output [,1] [,2] [,3] [,4] [1,] -1 -4 -7 -10 [2,] -2 -5 -8 -11 @@ -212,22 +212,22 @@ Muy importante: el operador`*` te da una multiplicación de elemento por element Para hacer multiplicación de matrices, necesitás usar el operador `%*%`: -```r +``` r m %*% matrix(1, nrow=4, ncol=1) ``` -```output +``` output [,1] [1,] 22 [2,] 26 [3,] 30 ``` -```r +``` r matrix(1:4, nrow=1) %*% matrix(1:4, ncol=1) ``` -```output +``` output [,1] [1,] 30 ``` @@ -244,12 +244,12 @@ Para saber más sobre Álgebra de matrices, ver [Quick-R reference guide](https: Dada la siguiente matriz: -```r +``` r m <- matrix(1:12, nrow=3, ncol=4) m ``` -```output +``` output [,1] [,2] [,3] [,4] [1,] 1 4 7 10 [2,] 2 5 8 11 @@ -272,12 +272,12 @@ Escribe lo que crees que sucederá cuando se ejecute: Dada la siguiente matriz: -```r +``` r m <- matrix(1:12, nrow=3, ncol=4) m ``` -```output +``` output [,1] [,2] [,3] [,4] [1,] 1 4 7 10 [2,] 2 5 8 11 @@ -289,7 +289,7 @@ Escribe lo que piensas que sucederá cuando ejecutes: 1. `m ^ -1` -```output +``` output [,1] [,2] [,3] [,4] [1,] 1.0000000 0.2500000 0.1428571 0.10000000 [2,] 0.5000000 0.2000000 0.1250000 0.09090909 @@ -299,7 +299,7 @@ Escribe lo que piensas que sucederá cuando ejecutes: 2. `m * c(1, 0, -1)` -```output +``` output [,1] [,2] [,3] [,4] [1,] 1 4 7 10 [2,] 0 0 0 0 @@ -309,7 +309,7 @@ Escribe lo que piensas que sucederá cuando ejecutes: 3. `m > c(0, 20)` -```output +``` output [,1] [,2] [,3] [,4] [1,] TRUE FALSE TRUE FALSE [2,] FALSE TRUE FALSE TRUE @@ -328,7 +328,7 @@ Estamos interesados en encontrar la suma de la siguiente secuencia de fracciones: -```r +``` r x = 1/(1^2) + 1/(2^2) + 1/(3^2) + ... + 1/(n^2) ``` @@ -344,7 +344,7 @@ Estamos interesados en encontrar la suma de la siguiente secuencia de fracciones: -```r +``` r x = 1/(1^2) + 1/(2^2) + 1/(3^2) + ... + 1/(n^2) ``` @@ -354,59 +354,59 @@ valores altos de n. ¿Qué tal cuando n=10,000? -```r +``` r sum(1/(1:100)^2) ``` -```output +``` output [1] 1.634984 ``` -```r +``` r sum(1/(1:1e04)^2) ``` -```output +``` output [1] 1.644834 ``` -```r +``` r n <- 10000 sum(1/(1:n)^2) ``` -```output +``` output [1] 1.644834 ``` Podemos obtener el mismo resultado usando una función: -```r +``` r inverse_sum_of_squares <- function(n) { sum(1/(1:n)^2) } inverse_sum_of_squares(100) ``` -```output +``` output [1] 1.634984 ``` -```r +``` r inverse_sum_of_squares(10000) ``` -```output +``` output [1] 1.644834 ``` -```r +``` r n <- 10000 inverse_sum_of_squares(n) ``` -```output +``` output [1] 1.644834 ``` diff --git a/10-functions.md b/10-functions.md index 8a9d007b..18d7fd03 100644 --- a/10-functions.md +++ b/10-functions.md @@ -71,7 +71,7 @@ Como el componente básico de la mayoría de los lenguajes de programación, las Empecemos abriendo un nuevo **script** de R en el directorio `functions/` y nombrémosle functions-lesson.R. -```r +``` r my_sum <- function(a, b) { the_sum <- a + b return(the_sum) @@ -82,7 +82,7 @@ Definamos una función `fahr_a_kelvin()` que convierta temperaturas de Fahrenheit a Kelvin: -```r +``` r fahr_to_kelvin <- function(temp) { kelvin <- ((temp - 32) * (5 / 9)) + 273.15 return(kelvin) @@ -118,22 +118,22 @@ Tratemos de correr nuestra función. Llamamos nuestra propia función de la misma manera que llamamos cualquier otra: -```r +``` r # Punto de congelación del agua fahr_to_kelvin(32) ``` -```output +``` output [1] 273.15 ``` -```r +``` r # Punto de ebullición del agua fahr_to_kelvin(212) ``` -```output +``` output [1] 373.15 ``` @@ -154,7 +154,7 @@ Escribe una función llamada `kelvin_a_celsius()` que toma la temperatura en gra Kelvin y devuelve la temperatura en Celsius. -```r +``` r kelvin_to_celsius <- function(temp) { celsius <- temp - 273.15 return(celsius) @@ -174,7 +174,7 @@ Definamos dos funciones que convertirán la temperatura de Fahrenheit a Kelvin, y de Kelvin a Celsius: -```r +``` r fahr_to_kelvin <- function(temp) { kelvin <- ((temp - 32) * (5 / 9)) + 273.15 return(kelvin) @@ -202,7 +202,7 @@ Define la función para convertir directamente de Fahrenheit a Celsius, reutilizando las dos funciones de arriba. -```r +``` r fahr_to_celsius <- function(temp) { temp_k <- fahr_to_kelvin(temp) result <- kelvin_to_celsius(temp_k) @@ -230,7 +230,7 @@ Empecemos por re-examinar `fahr_a_kelvin()`, nuestra función para convertir temperaturas de Fahrenheit a Kelvin. Estaba definida de la siguiente manera: -```r +``` r fahr_to_kelvin <- function(temp) { kelvin <- ((temp - 32) * (5 / 9)) + 273.15 return(kelvin) @@ -244,7 +244,7 @@ probarlo con un condicional `if` y devolver un error si la condición no se cumple. Podríamos agregar esto a nuestra función de la siguiente manera: -```r +``` r fahr_to_kelvin <- function(temp) { if (!is.numeric(temp)) { stop("temp must be a numeric vector.") @@ -266,7 +266,7 @@ probar el **input** a nuestra función `fahr_a_kelvin()`. Queremos asegurar lo siguiente: `temp` es un vector numérico. Lo podemos hacer de la siguiente manera: -```r +``` r fahr_to_kelvin <- function(temp) { stopifnot(is.numeric(temp)) kelvin <- ((temp - 32) * (5 / 9)) + 273.15 @@ -277,24 +277,24 @@ fahr_to_kelvin <- function(temp) { Aún funciona si se le da un **input** adecuado. -```r +``` r # Punto de congelación del agua fahr_to_kelvin(temp = 32) ``` -```output +``` output [1] 273.15 ``` Pero falla instantáneamente si se le da un **input** inapropiado. -```r +``` r # La métrica es un factor en lugar de numeric fahr_to_kelvin(temp = as.factor(32)) ``` -```error +``` error Error in fahr_to_kelvin(temp = as.factor(32)): is.numeric(temp) is not TRUE ``` @@ -316,7 +316,7 @@ funciones, hacer pruebas a la función hace redundante el agregar pruebas a cada dos funciones que la componen. -```r +``` r fahr_to_celsius <- function(temp) { stopifnot(!is.numeric(temp)) temp_k <- fahr_to_kelvin(temp) @@ -335,7 +335,7 @@ Ahora vamos a definir una función que calcula el Producto Interno Bruto ("GDP" Gross Domestic Product) de un país a partir de los datos disponibles en nuestro conjunto de datos: -```r +``` r # Toma un dataset y multiplica la columna de población # por la columna de GDP per capita calcGDP <- function(dat) { @@ -360,11 +360,11 @@ Esta función `return()` es opcional: R automáticamente devolverá el resultado comando que se ejecute en la última línea de la función. -```r +``` r calcGDP(head(gapminder)) ``` -```output +``` output [1] 6567086330 7585448670 8758855797 9648014150 9678553274 11697659231 ``` @@ -372,7 +372,7 @@ Eso no es muy informativo. Agreguemos algunos argumentos más para poder extraer por año y país. -```r +``` r # Toma un dataset y multiplica la columna de población # por la columna de GDP per capita calcGDP <- function(dat, year=NULL, country=NULL) { @@ -394,7 +394,7 @@ Si has estado escribiendo estas funciones en un **script** de R aparte usando la función `source()`: -```r +``` r source("functions/functions-lesson.R") ``` @@ -409,11 +409,11 @@ es mucho más informativo que un vector numérico. Veamos qué sucede cuando especificamos el año: -```r +``` r head(calcGDP(gapminder, year=2007)) ``` -```output +``` output country year pop continent lifeExp gdpPercap gdp 12 Afghanistan 2007 31889923 Asia 43.828 974.5803 31079291949 24 Albania 2007 3600523 Europe 76.423 5937.0295 21376411360 @@ -426,11 +426,11 @@ head(calcGDP(gapminder, year=2007)) O para un país específico: -```r +``` r calcGDP(gapminder, country="Australia") ``` -```output +``` output country year pop continent lifeExp gdpPercap gdp 61 Australia 1952 8691212 Oceania 69.120 10039.60 87256254102 62 Australia 1957 9712569 Oceania 70.330 10949.65 106349227169 @@ -449,11 +449,11 @@ calcGDP(gapminder, country="Australia") O ambos: -```r +``` r calcGDP(gapminder, year=2007, country="Australia") ``` -```output +``` output country year pop continent lifeExp gdpPercap gdp 72 Australia 2007 20434176 Oceania 81.235 34435.37 703658358894 ``` @@ -461,7 +461,7 @@ calcGDP(gapminder, year=2007, country="Australia") Veamos paso a paso el cuerpo de la función: -```r +``` r calcGDP <- function(dat, year=NULL, country=NULL) { ``` @@ -471,7 +471,7 @@ en la definición de la función. Esto significa que esos argumentos tomarán es a menos que el usuario especifique lo contrario. -```r +``` r if(!is.null(year)) { dat <- dat[dat$year %in% year, ] } @@ -526,7 +526,7 @@ son modificadas en ninguna manera cuando se ejecuta la función. :::::::::::::::::::::::::::::::::::::::::::::::::: -```r +``` r gdp <- dat$pop * dat$gdpPercap new <- cbind(dat, gdp=gdp) return(new) @@ -550,7 +550,7 @@ difiere del GDP de Nueva Zelandia en 1952? ## Solución al desafío 3 -```r +``` r calcGDP(gapminder, year = c(1952, 1987), country = "New Zealand") ``` @@ -571,12 +571,12 @@ GDP para Nueva Zelandia en 1952: 21058193787 La función `paste()` puede ser usada para combinar texto, ej.: -```r +``` r best_practice <- c("Write", "programs", "for", "people", "not", "computers") paste(best_practice, collapse=" ") ``` -```output +``` output [1] "Write programs for people not computers" ``` @@ -584,7 +584,7 @@ Escribir una función `fence()` que tome dos vectores como argumentos, llamados `text` y `wrapper`, y muestra el texto flanqueado del `wrapper`: -```r +``` r fence(text=best_practice, wrapper="***") ``` @@ -600,7 +600,7 @@ Escribir una función `fence()` que toma dos vectores como argumentos, llamados `text` y `wrapper`, e imprime el texto flanqueado del `wrapper`: -```r +``` r fence <- function(text, wrapper){ text <- c(wrapper, text, wrapper) result <- paste(text, collapse = " ") @@ -610,7 +610,7 @@ best_practice <- c("Write", "programs", "for", "people", "not", "computers") fence(text=best_practice, wrapper="***") ``` -```output +``` output [1] "*** Write programs for people not computers ***" ``` diff --git a/11-writing-data.md b/11-writing-data.md index 25f3ab6a..ba2d6d82 100644 --- a/11-writing-data.md +++ b/11-writing-data.md @@ -36,7 +36,7 @@ Ya hemos visto como guardar el gráfico más reciente que creaste con el paquete usando el comando `ggsave`. A manera de recordatorio, aquí está el código: -```r +``` r ggsave("My_most_recent_plot.pdf") ``` @@ -57,7 +57,7 @@ nuevo pdf del cual puedes controlar el tamaño y la resolución usando los argumentos específicos de esta función. -```r +``` r pdf("Life_Exp_vs_time.pdf", width=12, height=4) ggplot(data=gapminder, aes(x=year, y=lifeExp, colour=country)) + geom_line() + @@ -82,7 +82,7 @@ mismos datos. Esto te permitirá visualizar en un gráfico los datos por contine ## Solución al desafío 1 -```r +``` r pdf("Life_Exp_vs_time.pdf", width = 12, height = 4) p <- ggplot(data = gapminder, aes(x = year, y = lifeExp, colour = country)) + geom_line() + @@ -110,7 +110,7 @@ Vamos a crear un **script** para limpiar datos. En este análisis, vamos a enfocarnos solamente en los datos de **gapminder** para Australia: -```r +``` r aust_subset <- gapminder[gapminder$country == "Australia",] write.table(aust_subset, @@ -123,11 +123,11 @@ Ahora regresemos a la terminal para dar un vistazo a los datos y asegurarnos que se vean bien: -```bash +``` bash head cleaned-data/gapminder-aus.csv ``` -```output +``` output "country","year","pop","continent","lifeExp","gdpPercap" "61","Australia",1952,8691212,"Oceania",69.12,10039.59564 "62","Australia",1957,9712569,"Oceania",70.33,10949.64959 @@ -147,7 +147,7 @@ Veamos el archivo de ayuda para investigar como podemos cambiar este comportamiento. -```r +``` r ?write.table ``` @@ -158,7 +158,7 @@ columnas. Cambiemos esto: -```r +``` r write.table( gapminder[gapminder$country == "Australia",], file="cleaned-data/gapminder-aus.csv", @@ -170,11 +170,11 @@ Ahora echemos de nuevo un vistazo a los datos usando nuestras habilidades en la terminal: -```bash +``` bash head cleaned-data/gapminder-aus.csv ``` -```output +``` output country,year,pop,continent,lifeExp,gdpPercap Australia,1952,8691212,Oceania,69.12,10039.59564 Australia,1957,9712569,Oceania,70.33,10949.64959 @@ -204,7 +204,7 @@ directorio `cleaned-data`. ## Solución al desafío 2 -```r +``` r write.table( gapminder[gapminder$year > 1990, ], file = "cleaned-data/gapminder-after1990.csv", diff --git a/12-plyr.md b/12-plyr.md index 7a366095..4ed6a677 100644 --- a/12-plyr.md +++ b/12-plyr.md @@ -23,7 +23,7 @@ Previamente vimos como puedes usar funciones para simplificar tu código. Definimos la función `calcGDP`, la cual toma el **dataset** gapminder, y multiplica la columna de población por la columna GDP per cápita. También definimos argumentos adicionales de modo que pudiéramos filtrar por `"year"` o por `"country"`: -```r +``` r # Toma un dataset y multiplica la columna population con # la columna GDP per cápita. calcGDP <- function(dat, year=NULL, country=NULL) { @@ -45,28 +45,28 @@ Una tarea común que encontrarás mientras trabajes con datos, es que querrás h Podríamos ejecutar `calcGDP` y entonces tomar la media de cada continente: -```r +``` r withGDP <- calcGDP(gapminder) mean(withGDP[withGDP$continent == "Africa", "gdp"]) ``` -```output +``` output [1] 20904782844 ``` -```r +``` r mean(withGDP[withGDP$continent == "Americas", "gdp"]) ``` -```output +``` output [1] 379262350210 ``` -```r +``` r mean(withGDP[withGDP$continent == "Asia", "gdp"]) ``` -```output +``` output [1] 227233738153 ``` @@ -88,7 +88,7 @@ Para aquellos que han usado antes R, es posible que estén familiarizados con la Instalamos este paquete en un desafío anterior. Vamos a cargarlo ahora: -```r +``` r library("plyr") ``` @@ -109,7 +109,7 @@ Note que el uso de "array" de plyr es diferente a R, un array en ply puede incl Cada una de las funciones de xxply (`daply`,` ddply`, `llply`,` laply`, ...) tiene la misma estructura y 4 características clave: -```r +``` r xxply(.data, .variables, .fun) ``` @@ -121,7 +121,7 @@ xxply(.data, .variables, .fun) Ahora podemos calcular rápidamente la media GDP por `"continent"`: -```r +``` r ddply( .data = calcGDP(gapminder), .variables = "continent", @@ -129,7 +129,7 @@ ddply( ) ``` -```output +``` output continent V1 1 Africa 20904782844 2 Americas 379262350210 @@ -148,7 +148,7 @@ Veamos el código anterior: ¿Qué pasa si queremos un tipo diferente de estructura de datos de salida?: -```r +``` r dlply( .data = calcGDP(gapminder), .variables = "continent", @@ -156,7 +156,7 @@ dlply( ) ``` -```output +``` output $Africa [1] 20904782844 @@ -188,7 +188,7 @@ Llamamos a la misma función otra vez, pero cambiamos la segunda letra por una ` Podemos especificar múltiples columnas para agrupar: -```r +``` r ddply( .data = calcGDP(gapminder), .variables = c("continent", "year"), @@ -196,7 +196,7 @@ ddply( ) ``` -```output +``` output continent year V1 1 Africa 1952 5992294608 2 Africa 1957 7359188796 @@ -261,7 +261,7 @@ ddply( ``` -```r +``` r daply( .data = calcGDP(gapminder), .variables = c("continent", "year"), @@ -269,7 +269,7 @@ daply( ) ``` -```output +``` output year continent 1952 1957 1962 1967 1972 Africa 5992294608 7359188796 8784876958 11443994101 15072241974 @@ -297,7 +297,7 @@ Puedes usar estas funciones en lugar de ciclos `for` (y generalmente es mas ráp Para remplazar un ciclo ‘for', pon el código que estaba en el cuerpo del ciclo `for` dentro de la función anónima. -```r +``` r d_ply( .data=gapminder, .variables = "continent", @@ -311,7 +311,7 @@ d_ply( ) ``` -```output +``` output [1] "La media GDP per cápita para Africa es 2,193.755" [1] "La media GDP per cápita para Americas es 7,136.11" [1] "La media GDP per cápita para Asia es 7,902.15" @@ -370,7 +370,7 @@ de la esperanza de vida por continente: 1. -```r +``` r ddply( .data = gapminder, .variables = gapminder$continent, @@ -382,7 +382,7 @@ ddply( 2. -```r +``` r ddply( .data = gapminder, .variables = "continent", @@ -392,7 +392,7 @@ ddply( 3. -```r +``` r ddply( .data = gapminder, .variables = "continent", @@ -404,7 +404,7 @@ ddply( 4. -```r +``` r adply( .data = gapminder, .variables = "continent", diff --git a/13-dplyr.md b/13-dplyr.md index b8a83851..e86d1037 100644 --- a/13-dplyr.md +++ b/13-dplyr.md @@ -48,27 +48,27 @@ ciertas observaciones (filas) o variables (columnas), otras veces deseamos agrup o queremos calcular valores estadísticos de un conjunto. Podemos hacer todo ello usando las habituales operaciones básicas de R: -```r +``` r mean(gapminder[gapminder$continent == "Africa", "gdpPercap"]) ``` -```output +``` output [1] 2193.755 ``` -```r +``` r mean(gapminder[gapminder$continent == "Americas", "gdpPercap"]) ``` -```output +``` output [1] 7136.11 ``` -```r +``` r mean(gapminder[gapminder$continent == "Asia", "gdpPercap"]) ``` -```output +``` output [1] 7902.15 ``` @@ -93,14 +93,14 @@ Aquí vamos a revisar 6 de sus funciones más usadas, así como a usar los **pip Si no has instalado antes este paquete, hazlo del siguiente modo: -```r +``` r install.packages('dplyr') ``` Ahora vamos a cargar el paquete: -```r +``` r library("dplyr") ``` @@ -109,7 +109,7 @@ library("dplyr") Si por ejemplo queremos continuar el trabajo con sólo unas pocas de las variables de nuestro **data frame** podemos usar la función `select()`. Esto guardará sólo las variables que seleccionemos. -```r +``` r year_country_gdp <- select(gapminder,year,country,gdpPercap) ``` @@ -118,7 +118,7 @@ year_country_gdp <- select(gapminder,year,country,gdpPercap) Si ahora investigamos `year_country_gdp` veremos que sólo contiene el año, el país y la renta per cápita. Arriba hemos usado la gramática 'normal', pero la fortaleza de `dplyr` consiste en combinar funciones usando **pipes**. Como la gramática de las **pipes** es distinta a todo lo que hemos visto antes en R, repitamos lo que hemos hecho arriba, pero esta vez usando **pipes**. -```r +``` r year_country_gdp <- gapminder %>% select(year,country,gdpPercap) ``` @@ -129,7 +129,7 @@ Para ayudarte a entender por qué lo hemos escrito así, vamos a revisarlo por p Si ahora queremos continuar con lo de arriba, pero sólo con los países europeos, podemos combinar `select` y `filter`. -```r +``` r year_country_gdp_euro <- gapminder %>% filter(continent=="Europe") %>% select(year,country,gdpPercap) @@ -149,7 +149,7 @@ a `lifeExp`, `country` y `year`, pero no de los otros continentes. ## Solución al Reto 1 -```r +``` r year_country_lifeExp_Africa <- gapminder %>% filter(continent=="Africa") %>% select(year,country,lifeExp) @@ -166,11 +166,11 @@ Al igual que la vez anterior, primero le pasamos el **data frame** "gapminder" a Se suponía que teníamos que reducir las repeticiones causantes de errores de lo que se puede hacer con el R básico, pero hasta ahora no lo hemos conseguido porque tendríamos que repetir lo escrito arriba para cada continente. En lugar de `filter()`, que solamente deja pasar las observaciones que se ajustan a tu criterio (`continent = Europe` en lo escrito arriba), podemos usar `group_by()`, que esencialmente usará cada uno de los criterios únicos que podrías haber usado con `filter()`. -```r +``` r str(gapminder) ``` -```output +``` output '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 ... @@ -180,11 +180,11 @@ str(gapminder) $ gdpPercap: num 779 821 853 836 740 ... ``` -```r +``` r str(gapminder %>% group_by(continent)) ``` -```output +``` output gropd_df [1,704 × 6] (S3: grouped_df/tbl_df/tbl/data.frame) $ country : chr [1:1704] "Afghanistan" "Afghanistan" "Afghanistan" "Afghanistan" ... $ year : int [1:1704] 1952 1957 1962 1967 1972 1977 1982 1987 1992 1997 ... @@ -213,7 +213,7 @@ Se puede observar que la estructura del **data frame** obtenido por `group_by()` Lo visto arriba no es muy sofisticado, pero `group_by()` es más interesante y útil si se usa en conjunto con `summarize()`. Esto nos permitirá crear nuevas variables usando funciones que se aplican a cada uno de los **data frames** específicos para cada continente. Es decir, usando la función `group_by()` dividimos nuestro **data frame** original en varias partes, a las que luego podemos aplicarles funciones (por ejemplo, `mean()` o `sd()`) independientemente con `summarize()`. -```r +``` r gdp_bycontinents <- gapminder %>% group_by(continent) %>% summarize(mean_gdpPercap=mean(gdpPercap)) @@ -222,7 +222,7 @@ gdp_bycontinents <- gapminder %>% ![](fig/13-dplyr-fig3.png) -```r +``` r continent mean_gdpPercap 1 Africa 2193.755 @@ -246,7 +246,7 @@ y cuál la menor? ## Solución al Reto 2 -```r +``` r lifeExp_bycountry <- gapminder %>% group_by(country) %>% summarize(mean_lifeExp=mean(lifeExp)) @@ -254,7 +254,7 @@ lifeExp_bycountry %>% filter(mean_lifeExp == min(mean_lifeExp) | mean_lifeExp == max(mean_lifeExp)) ``` -```output +``` output # A tibble: 2 × 2 country mean_lifeExp @@ -269,26 +269,26 @@ del paquete `dplyr`. Se puede usar `desc()` dentro de `arrange()` para ordenar de modo descendente. -```r +``` r lifeExp_bycountry %>% arrange(mean_lifeExp) %>% head(1) ``` -```output +``` output # A tibble: 1 × 2 country mean_lifeExp 1 Sierra Leone 36.8 ``` -```r +``` r lifeExp_bycountry %>% arrange(desc(mean_lifeExp)) %>% head(1) ``` -```output +``` output # A tibble: 1 × 2 country mean_lifeExp @@ -302,13 +302,13 @@ lifeExp_bycountry %>% La función `group_by()` nos permite agrupar en función de varias variables. Vamos a agrupar por `year` y `continent`. -```r +``` r gdp_bycontinents_byyear <- gapminder %>% group_by(continent,year) %>% summarize(mean_gdpPercap=mean(gdpPercap)) ``` -```output +``` output `summarise()` has grouped output by 'continent'. You can override using the `.groups` argument. ``` @@ -316,7 +316,7 @@ gdp_bycontinents_byyear <- gapminder %>% Esto ya es bastante potente, pero puede ser incluso mejor. Puedes definir más de una variable en `summarize()`. -```r +``` r gdp_pop_bycontinents_byyear <- gapminder %>% group_by(continent,year) %>% summarize(mean_gdpPercap=mean(gdpPercap), @@ -325,7 +325,7 @@ gdp_pop_bycontinents_byyear <- gapminder %>% sd_pop=sd(pop)) ``` -```output +``` output `summarise()` has grouped output by 'continent'. You can override using the `.groups` argument. ``` @@ -337,13 +337,13 @@ Una operación muy habitual es contar el número de observaciones que hay en cad Por ejemplo, si queremos comprobar el número de países que hay en el conjunto de datos para el año 2002 podemos usar la función `count()`. Dicha función toma el nombre de una o más columnas que contienen los grupos en los que estamos interesados y puede opcionalmente ordenar los resultados en modo descendente si añadimos `sort = TRUE`. -```r +``` r gapminder %>% filter(year == 2002) %>% count(continent, sort = TRUE) ``` -```output +``` output continent n 1 Africa 52 2 Asia 33 @@ -355,13 +355,13 @@ gapminder %>% Si necesitamos usar en nuestros cálculos el número de observaciones obtenidas, la función `n()` es muy útil. Por ejemplo, si queremos obtener el error estándar de la esperanza de vida por continente: -```r +``` r gapminder %>% group_by(continent) %>% summarize(se_pop = sd(lifeExp)/sqrt(n())) ``` -```output +``` output # A tibble: 5 × 2 continent se_pop @@ -375,7 +375,7 @@ gapminder %>% También se pueden encadenar juntas varias operaciones de resumen, como en el caso siguiente, en el que calculamos el `minimum`, `maximum`, `mean` y `se` de la esperanza de vida por país para cada continente: -```r +``` r gapminder %>% group_by(continent) %>% summarize( @@ -385,7 +385,7 @@ gapminder %>% se_le = sd(lifeExp)/sqrt(n())) ``` -```output +``` output # A tibble: 5 × 5 continent mean_le min_le max_le se_le @@ -401,7 +401,7 @@ gapminder %>% También se pueden crear nuevas variables antes (o incluso después) de resumir la información usando `mutate()`. -```r +``` r gdp_pop_bycontinents_byyear <- gapminder %>% mutate(gdp_billion=gdpPercap*pop/10^9) %>% group_by(continent,year) %>% @@ -413,7 +413,7 @@ gdp_pop_bycontinents_byyear <- gapminder %>% sd_gdp_billion=sd(gdp_billion)) ``` -```output +``` output `summarise()` has grouped output by 'continent'. You can override using the `.groups` argument. ``` @@ -423,7 +423,7 @@ gdp_pop_bycontinents_byyear <- gapminder %>% La creación de nuevas variables se puede conectar con una condición lógica. Una simple combinación de `mutate` y `ifelse` facilita el filtrado solo allí donde se necesita: en el momento de crear algo nuevo. Esta combinación es fácil de leer y es un modo rápido y potente de descartar ciertos datos (incluso sin cambiar la dimensión conjunta del **data frame**) o para actualizar valores dependiendo de la condición utilizada. -```r +``` r ## manteniendo todos los datos pero "filtrando" según una determinada condición # calcular renta per cápita sólo para gente con una esperanza de vida por encima de 25 gdp_pop_bycontinents_byyear_above25 <- gapminder %>% @@ -437,12 +437,12 @@ gdp_pop_bycontinents_byyear_above25 <- gapminder %>% sd_gdp_billion = sd(gdp_billion)) ``` -```output +``` output `summarise()` has grouped output by 'continent'. You can override using the `.groups` argument. ``` -```r +``` r ## actualizando sólo si se cumple una determinada condición # para esperanzas de vida por encima de 40 años, el GDP que se espera en el futuro es escalado gdp_future_bycontinents_byyear_high_lifeExp <- gapminder %>% @@ -452,7 +452,7 @@ gdp_future_bycontinents_byyear_high_lifeExp <- gapminder %>% mean_gdpPercap_expected = mean(gdp_futureExpectation)) ``` -```output +``` output `summarise()` has grouped output by 'continent'. You can override using the `.groups` argument. ``` @@ -462,7 +462,7 @@ gdp_future_bycontinents_byyear_high_lifeExp <- gapminder %>% En la función de creación de gráficas vimos cómo hacer una figura con múltiples paneles añadiendo una capa de paneles separados (**facet panels**). Aquí está el código que usamos (con algunos comentarios extra): -```r +``` r # Obtener la primera letra de cada país starts.with <- substr(gapminder$country, start = 1, stop = 1) # Filtrar países que empiezan con "A" o "Z" @@ -472,14 +472,14 @@ ggplot(data = az.countries, aes(x = year, y = lifeExp, color = continent)) + geom_line() + facet_wrap( ~ country) ``` -```error +``` error Error in ggplot(data = az.countries, aes(x = year, y = lifeExp, color = continent)): could not find function "ggplot" ``` Este código construye la gráfica correcta, pero también crea algunas variables `starts.with` y `az.countries`) que podemos no querer usar para nada más. Del mismo modo que usamos `%>%` para pasar datos con **pipes** a lo largo de una cadena de funciones `dplyr`, podemos usarlo para pasarle datos a `ggplot()`. Como `%>%` sustituye al primer argumento de una función, no necesitamos especificar el argumento `data=` de la función `ggplot()`. Combinando funciones de los paquetes `dplyr` y `ggplot` podemos hacer la misma figura sin crear ninguna nueva variable y sin modificar los datos. -```r +``` r gapminder %>% # Get the start letter of each country mutate(startsWith = substr(country, start = 1, stop = 1)) %>% @@ -491,14 +491,14 @@ gapminder %>% facet_wrap( ~ country) ``` -```error +``` error Error in ggplot(., aes(x = year, y = lifeExp, color = continent)): could not find function "ggplot" ``` Las funciones del paquete `dplyr` también nos ayudan a simplificar las cosas, por ejemplo, combinando los primeros dos pasos: -```r +``` r gapminder %>% # Filter countries that start with "A" or "Z" filter(substr(country, start = 1, stop = 1) %in% c("A", "Z")) %>% @@ -508,7 +508,7 @@ gapminder %>% facet_wrap( ~ country) ``` -```error +``` error Error in ggplot(., aes(x = year, y = lifeExp, color = continent)): could not find function "ggplot" ``` @@ -526,7 +526,7 @@ una sintaxis similar a las demás funciones del paquete `dplyr`. ## Solución al Reto Avanzado -```r +``` r lifeExp_2countries_bycontinents <- gapminder %>% filter(year==2002) %>% group_by(continent) %>% diff --git a/14-tidyr.md b/14-tidyr.md index 186aca00..93110b00 100644 --- a/14-tidyr.md +++ b/14-tidyr.md @@ -43,7 +43,7 @@ los campos en una base de datos y las variables observadas son como los valores Primero instala los paquetes necesarios, `tidyr` y `dplyr`. Si aún no lo has hecho, puedes también instalar el grupo de paquetes `tidyverse` que contiene varios paquetes incluyendo `tidyr` y `dplyr`. -```r +``` r #install.packages("tidyr") #install.packages("dplyr") ``` @@ -51,7 +51,7 @@ Primero instala los paquetes necesarios, `tidyr` y `dplyr`. Si aún no lo has he Ahora carga los paquetes usando **library**. -```r +``` r library("tidyr") library("dplyr") ``` @@ -59,11 +59,11 @@ library("dplyr") Primero, veamos la estructura **structure** del **data frame** gapminder: -```r +``` r str(gapminder) ``` -```output +``` output '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 ... @@ -118,12 +118,12 @@ y guarda el archivo csv en tu carpeta de datos. Cargaremos el archivo de datos para verlo. Nota: no queremos que las columnas de caracteres sean convertidas a factores, por lo que usamos el argumento `stringsAsFactors = FALSE` para para deshabilitar eso, más información en la ayuda `?read.csv ()`. -```r +``` r gap_wide <- read.csv("data/gapminder_wide.csv", stringsAsFactors = FALSE) str(gap_wide) ``` -```output +``` output 'data.frame': 142 obs. of 38 variables: $ continent : chr "Africa" "Africa" "Africa" "Africa" ... $ country : chr "Algeria" "Angola" "Benin" "Botswana" ... @@ -172,14 +172,14 @@ El primer paso es formatear los datos de ancho a largo. Usando el paquete `tidyr ![](fig/14-tidyr-fig3.png) -```r +``` r gap_long <- gap_wide %>% gather(obstype_year, obs_values, starts_with("pop"), starts_with("lifeExp"), starts_with("gdpPercap")) str(gap_long) ``` -```output +``` output 'data.frame': 5112 obs. of 4 variables: $ continent : chr "Africa" "Africa" "Africa" "Africa" ... $ country : chr "Algeria" "Angola" "Benin" "Botswana" ... @@ -197,12 +197,12 @@ sintaxis alternativa del uso del símbolo `-` para identificar qué variables qu ![](fig/14-tidyr-fig4.png) -```r +``` r gap_long <- gap_wide %>% gather(obstype_year, obs_values, -continent, -country) str(gap_long) ``` -```output +``` output 'data.frame': 5112 obs. of 4 variables: $ continent : chr "Africa" "Africa" "Africa" "Africa" ... $ country : chr "Algeria" "Angola" "Benin" "Botswana" ... @@ -216,7 +216,7 @@ Ahora, `obstype_year` en realidad contiene información en dos partes, la observ tipo (`pop`,` lifeExp`, o `gdpPercap`) y el año `year`. Podemos usar la función `separate()` para dividir las cadenas de caracteres en múltiples variables. -```r +``` r gap_long <- gap_long %>% separate(obstype_year, into = c("obs_type", "year"), sep = "_") gap_long$year <- as.integer(gap_long$year) ``` @@ -233,18 +233,18 @@ Usando el **data frame** `gap_long`, calcula el promedio de esperanza de vida, p ## Solución al Desafío 2 -```r +``` r gap_long %>% group_by(continent, obs_type) %>% summarize(means = mean(obs_values)) ``` -```output +``` output `summarise()` has grouped output by 'continent'. You can override using the `.groups` argument. ``` -```output +``` output # A tibble: 15 × 3 # Groups: continent [5] continent obs_type means @@ -275,36 +275,36 @@ gap_long %>% Siempre es bueno detenerse y verificar el trabajo. Entonces, usemos el opuesto de `gather()` para separar nuestras variables de observación con la función `spread()`. Para expandir nuestro objeto `gap_long()` al formato intermedio original o al formato ancho usaremos esta nueva función. Comencemos con el formato intermedio. -```r +``` r gap_normal <- gap_long %>% spread(obs_type,obs_values) dim(gap_normal) ``` -```output +``` output [1] 1704 6 ``` -```r +``` r dim(gapminder) ``` -```output +``` output [1] 1704 6 ``` -```r +``` r names(gap_normal) ``` -```output +``` output [1] "continent" "country" "year" "gdpPercap" "lifeExp" "pop" ``` -```r +``` r names(gapminder) ``` -```output +``` output [1] "country" "year" "pop" "continent" "lifeExp" "gdpPercap" ``` @@ -312,12 +312,12 @@ Ahora tenemos un marco de datos intermedio `gap_normal` con las mismas dimension eso antes de comprobar si son iguales con la función `all.equal()`. -```r +``` r gap_normal <- gap_normal[,names(gapminder)] all.equal(gap_normal,gapminder) ``` -```output +``` output [1] "Component \"country\": 1704 string mismatches" [2] "Component \"pop\": Mean relative difference: 1.634504" [3] "Component \"continent\": 1212 string mismatches" @@ -325,11 +325,11 @@ all.equal(gap_normal,gapminder) [5] "Component \"gdpPercap\": Mean relative difference: 1.162302" ``` -```r +``` r head(gap_normal) ``` -```output +``` output country year pop continent lifeExp gdpPercap 1 Algeria 1952 9279525 Africa 43.077 2449.008 2 Algeria 1957 10270856 Africa 45.685 3013.976 @@ -339,11 +339,11 @@ head(gap_normal) 6 Algeria 1977 17152804 Africa 58.014 4910.417 ``` -```r +``` r head(gapminder) ``` -```output +``` output country year pop continent lifeExp gdpPercap 1 Afghanistan 1952 8425333 Asia 28.801 779.4453 2 Afghanistan 1957 9240934 Asia 30.332 820.8530 @@ -357,12 +357,12 @@ Ya casi, el **data frame** original está ordenado por `country`, `continent`, y `year`. Entonces probemos con la función `arrange()`. -```r +``` r gap_normal <- gap_normal %>% arrange(country, continent, year) all.equal(gap_normal, gapminder) ``` -```output +``` output [1] TRUE ``` @@ -375,12 +375,12 @@ en las tres métricas (`pop`,` lifeExp`, `gdpPercap`) y año (` year`). Primero necesitamos crear etiquetas apropiadas para todas nuestras nuevas variables (combinaciones de métricas\*año) y también necesitamos unificar nuestras variables de **ID** para simplificar el proceso de definir el nuevo objeto `gap_wide`. -```r +``` r gap_temp <- gap_long %>% unite(var_ID, continent, country, sep = "_") str(gap_temp) ``` -```output +``` output 'data.frame': 5112 obs. of 4 variables: $ var_ID : chr "Africa_Algeria" "Africa_Angola" "Africa_Benin" "Africa_Botswana" ... $ obs_type : chr "gdpPercap" "gdpPercap" "gdpPercap" "gdpPercap" ... @@ -388,14 +388,14 @@ str(gap_temp) $ obs_values: num 2449 3521 1063 851 543 ... ``` -```r +``` r gap_temp <- gap_long %>% unite(ID_var, continent, country, sep = "_") %>% unite(var_names, obs_type, year, sep = "_") str(gap_temp) ``` -```output +``` output 'data.frame': 5112 obs. of 3 variables: $ ID_var : chr "Africa_Algeria" "Africa_Angola" "Africa_Benin" "Africa_Botswana" ... $ var_names : chr "gdpPercap_1952" "gdpPercap_1952" "gdpPercap_1952" "gdpPercap_1952" ... @@ -406,7 +406,7 @@ Usando la función `unite()` tenemos ahora un único **ID** que es la combinaci `continent`, `country`, y así definimos nuestras nuevas variables. Ahora podemos usar ese resultado con la función `spread()`. -```r +``` r gap_wide_new <- gap_long %>% unite(ID_var, continent, country, sep = "_") %>% unite(var_names, obs_type, year,sep = "_") %>% @@ -414,7 +414,7 @@ gap_wide_new <- gap_long %>% str(gap_wide_new) ``` -```output +``` output 'data.frame': 142 obs. of 37 variables: $ ID_var : chr "Africa_Algeria" "Africa_Angola" "Africa_Benin" "Africa_Botswana" ... $ gdpPercap_1952: num 2449 3521 1063 851 543 ... @@ -467,7 +467,7 @@ Crea un formato de datos `gap_super_wide` mediante la distribución por países, ## Solución para el desafío 3 -```r +``` r gap_super_wide <- gap_long %>% unite(var_names, obs_type, year, country, sep = "_") %>% spread(var_names, obs_values) @@ -480,7 +480,7 @@ gap_super_wide <- gap_long %>% Ahora tenemos un gran **data frame** con formato 'ancho', pero el `ID_var` podría ser más mejor, hay que separarlos en dos variables con `separate()` -```r +``` r gap_wide_betterID <- separate(gap_wide_new, ID_var, c("continent", "country"), sep = "_") gap_wide_betterID <- gap_long %>% unite(ID_var, continent, country, sep = "_") %>% @@ -490,7 +490,7 @@ gap_wide_betterID <- gap_long %>% str(gap_wide_betterID) ``` -```output +``` output 'data.frame': 142 obs. of 38 variables: $ continent : chr "Africa" "Africa" "Africa" "Africa" ... $ country : chr "Algeria" "Angola" "Benin" "Botswana" ... diff --git a/config.yaml b/config.yaml deleted file mode 100644 index a14156dd..00000000 --- a/config.yaml +++ /dev/null @@ -1,96 +0,0 @@ -#------------------------------------------------------------ -# Values for this lesson. -#------------------------------------------------------------ - -# Which carpentry is this (swc, dc, lc, or cp)? -# swc: Software Carpentry -# dc: Data Carpentry -# lc: Library Carpentry -# cp: Carpentries (to use for instructor training for instance) -# incubator: The Carpentries Incubator -carpentry: 'swc' - -# Overall title for pages. -title: 'R para Análisis Científicos Reproducibles' - -# Date the lesson was created (YYYY-MM-DD, this is empty by default) -created: '2018-03-20' - -# Comma-separated list of keywords for the lesson -keywords: 'software, data, lesson, The Carpentries' - -# Life cycle stage of the lesson -# possible values: pre-alpha, alpha, beta, stable -life_cycle: 'stable' - -# License of the lesson materials (recommended CC-BY 4.0) -license: 'CC-BY 4.0' - -# Link to the source repository for this lesson -source: 'https://github.com/swcarpentry/r-novice-gapminder-es' - -# Default branch of your lesson -branch: 'main' - -# Who to contact if there are any issues -contact: 'team@carpentries.org' - -# Navigation ------------------------------------------------ -# -# Use the following menu items to specify the order of -# individual pages in each dropdown section. Leave blank to -# include all pages in the folder. -# -# Example ------------- -# -# episodes: -# - introduction.md -# - first-steps.md -# -# learners: -# - setup.md -# -# instructors: -# - instructor-notes.md -# -# profiles: -# - one-learner.md -# - another-learner.md - -# Order of episodes in your lesson -episodes: -- 01-rstudio-intro.Rmd -- 02-project-intro.Rmd -- 03-seeking-help.Rmd -- 04-data-structures-part1.Rmd -- 05-data-structures-part2.Rmd -- 06-data-subsetting.Rmd -- 07-control-flow.Rmd -- 08-plot-ggplot2.Rmd -- 09-vectorization.Rmd -- 10-functions.Rmd -- 11-writing-data.Rmd -- 12-plyr.Rmd -- 13-dplyr.Rmd -- 14-tidyr.Rmd -- 15-knitr-markdown.Rmd -- 16-wrap-up.Rmd - -# Information for Learners -learners: - -# Information for Instructors -instructors: - -# Learner Profiles -profiles: - -# Customisation --------------------------------------------- -# -# This space below is where custom yaml items (e.g. pinning -# sandpaper and varnish versions) should live - - -url: 'https://swcarpentry.github.io/r-novice-gapminder-es' -analytics: carpentries -lang: 'es' diff --git a/fig/06-rmd-generate-figures.sh b/fig/06-rmd-generate-figures.sh old mode 100755 new mode 100644 diff --git a/fig/12-plyr-generate-figures.sh b/fig/12-plyr-generate-figures.sh old mode 100755 new mode 100644 diff --git a/md5sum.txt b/md5sum.txt index 0dee70d3..82466daa 100644 --- a/md5sum.txt +++ b/md5sum.txt @@ -1,28 +1,28 @@ "file" "checksum" "built" "date" -"CODE_OF_CONDUCT.md" "c93c83c630db2fe2462240bf72552548" "site/built/CODE_OF_CONDUCT.md" "2024-05-21" -"LICENSE.md" "b24ebbb41b14ca25cf6b8216dda83e5f" "site/built/LICENSE.md" "2024-05-21" -"NEWS.md" "5f095ea326686e040515b3a4083dac0c" "site/built/NEWS.md" "2024-05-21" -"config.yaml" "6937e343b4e3568a3bba5f2625125296" "site/built/config.yaml" "2024-05-21" -"index.md" "ebed87c856179ccf6edc852ade633afe" "site/built/index.md" "2024-05-21" -"episodes/01-rstudio-intro.Rmd" "df5a9cad0039f566bfc718b5f7c4a380" "site/built/01-rstudio-intro.md" "2024-05-21" -"episodes/02-project-intro.Rmd" "60939608000d5f306bc0e6fe0942a41f" "site/built/02-project-intro.md" "2024-05-21" -"episodes/03-seeking-help.Rmd" "f4deeccd811d73e36fea077fbb9c4032" "site/built/03-seeking-help.md" "2024-05-21" -"episodes/04-data-structures-part1.Rmd" "b6d6bc3443c6cdf89979a7365204574b" "site/built/04-data-structures-part1.md" "2024-05-21" -"episodes/05-data-structures-part2.Rmd" "da58cc64c0e5abcd959e9f0658f085e1" "site/built/05-data-structures-part2.md" "2024-05-21" -"episodes/06-data-subsetting.Rmd" "c67848164213c376b967f16a8a05f7d5" "site/built/06-data-subsetting.md" "2024-05-21" -"episodes/07-control-flow.Rmd" "c61eb1b5dce6e7ac620653e1b0b66ee9" "site/built/07-control-flow.md" "2024-05-21" -"episodes/08-plot-ggplot2.Rmd" "c404c7c88a8ff8f42987ca72f4a2a586" "site/built/08-plot-ggplot2.md" "2024-05-21" -"episodes/09-vectorization.Rmd" "9e8cc20afc79d243189bd9a19a54e174" "site/built/09-vectorization.md" "2024-05-21" -"episodes/10-functions.Rmd" "3c24c68a1c2a6f92b6c118c77b4bb23e" "site/built/10-functions.md" "2024-05-21" -"episodes/11-writing-data.Rmd" "f42fe99984f6768838eeb49d1bd518d9" "site/built/11-writing-data.md" "2024-05-21" -"episodes/12-plyr.Rmd" "a2aa9bef9e4e16f3ba3f277565aaf76a" "site/built/12-plyr.md" "2024-05-21" -"episodes/13-dplyr.Rmd" "fca99660f5859ef49493177aa0bc69de" "site/built/13-dplyr.md" "2024-05-21" -"episodes/14-tidyr.Rmd" "8861bff8f34f2054b75a1daef3cdcc39" "site/built/14-tidyr.md" "2024-05-21" -"episodes/15-knitr-markdown.Rmd" "e19009b2aedaaee3a6000f1ae81e6ecc" "site/built/15-knitr-markdown.md" "2024-05-21" -"episodes/16-wrap-up.Rmd" "f6f1d90a11b7c4b7a61813a1d678ba14" "site/built/16-wrap-up.md" "2024-05-21" -"instructors/instructor-notes.md" "3d04325668f1c897df5a0b46d5ac5a53" "site/built/instructor-notes.md" "2024-05-21" -"learners/discuss.md" "42ad66ab1907e030914dbb2a94376a47" "site/built/discuss.md" "2024-05-21" -"learners/reference.md" "c91dec1b149883b985376c211c6eba3e" "site/built/reference.md" "2024-05-21" -"learners/setup.md" "617894179d03d28c84916feeb439d542" "site/built/setup.md" "2024-05-21" -"profiles/learner-profiles.md" "60b93493cf1da06dfd63255d73854461" "site/built/learner-profiles.md" "2024-05-21" -"renv/profiles/lesson-requirements/renv.lock" "955b13fd2d1494bcad6e7b64fc14da5a" "site/built/renv.lock" "2024-05-21" +"CODE_OF_CONDUCT.md" "c93c83c630db2fe2462240bf72552548" "site/built/CODE_OF_CONDUCT.md" "2024-06-04" +"LICENSE.md" "b24ebbb41b14ca25cf6b8216dda83e5f" "site/built/LICENSE.md" "2024-06-04" +"NEWS.md" "5f095ea326686e040515b3a4083dac0c" "site/built/NEWS.md" "2024-06-04" +"config.yaml" "6937e343b4e3568a3bba5f2625125296" "site/built/config.yaml" "2024-06-04" +"index.md" "ebed87c856179ccf6edc852ade633afe" "site/built/index.md" "2024-06-04" +"episodes/01-rstudio-intro.Rmd" "df5a9cad0039f566bfc718b5f7c4a380" "site/built/01-rstudio-intro.md" "2024-06-04" +"episodes/02-project-intro.Rmd" "60939608000d5f306bc0e6fe0942a41f" "site/built/02-project-intro.md" "2024-06-04" +"episodes/03-seeking-help.Rmd" "f4deeccd811d73e36fea077fbb9c4032" "site/built/03-seeking-help.md" "2024-06-04" +"episodes/04-data-structures-part1.Rmd" "b6d6bc3443c6cdf89979a7365204574b" "site/built/04-data-structures-part1.md" "2024-06-04" +"episodes/05-data-structures-part2.Rmd" "da58cc64c0e5abcd959e9f0658f085e1" "site/built/05-data-structures-part2.md" "2024-06-04" +"episodes/06-data-subsetting.Rmd" "c67848164213c376b967f16a8a05f7d5" "site/built/06-data-subsetting.md" "2024-06-04" +"episodes/07-control-flow.Rmd" "c61eb1b5dce6e7ac620653e1b0b66ee9" "site/built/07-control-flow.md" "2024-06-04" +"episodes/08-plot-ggplot2.Rmd" "c404c7c88a8ff8f42987ca72f4a2a586" "site/built/08-plot-ggplot2.md" "2024-06-04" +"episodes/09-vectorization.Rmd" "9e8cc20afc79d243189bd9a19a54e174" "site/built/09-vectorization.md" "2024-06-04" +"episodes/10-functions.Rmd" "3c24c68a1c2a6f92b6c118c77b4bb23e" "site/built/10-functions.md" "2024-06-04" +"episodes/11-writing-data.Rmd" "f42fe99984f6768838eeb49d1bd518d9" "site/built/11-writing-data.md" "2024-06-04" +"episodes/12-plyr.Rmd" "a2aa9bef9e4e16f3ba3f277565aaf76a" "site/built/12-plyr.md" "2024-06-04" +"episodes/13-dplyr.Rmd" "fca99660f5859ef49493177aa0bc69de" "site/built/13-dplyr.md" "2024-06-04" +"episodes/14-tidyr.Rmd" "8861bff8f34f2054b75a1daef3cdcc39" "site/built/14-tidyr.md" "2024-06-04" +"episodes/15-knitr-markdown.Rmd" "e19009b2aedaaee3a6000f1ae81e6ecc" "site/built/15-knitr-markdown.md" "2024-06-04" +"episodes/16-wrap-up.Rmd" "f6f1d90a11b7c4b7a61813a1d678ba14" "site/built/16-wrap-up.md" "2024-06-04" +"instructors/instructor-notes.md" "3d04325668f1c897df5a0b46d5ac5a53" "site/built/instructor-notes.md" "2024-06-04" +"learners/discuss.md" "42ad66ab1907e030914dbb2a94376a47" "site/built/discuss.md" "2024-06-04" +"learners/reference.md" "c91dec1b149883b985376c211c6eba3e" "site/built/reference.md" "2024-06-04" +"learners/setup.md" "617894179d03d28c84916feeb439d542" "site/built/setup.md" "2024-06-04" +"profiles/learner-profiles.md" "60b93493cf1da06dfd63255d73854461" "site/built/learner-profiles.md" "2024-06-04" +"renv/profiles/lesson-requirements/renv.lock" "0fab9d91a0839c2aca5d6011a6187b33" "site/built/renv.lock" "2024-06-04" diff --git a/renv.lock b/renv.lock deleted file mode 100644 index ce81ec92..00000000 --- a/renv.lock +++ /dev/null @@ -1,1043 +0,0 @@ -{ - "R": { - "Version": "4.4.0", - "Repositories": [ - { - "Name": "carpentries", - "URL": "https://carpentries.r-universe.dev" - }, - { - "Name": "carpentries_archive", - "URL": "https://carpentries.github.io/drat" - }, - { - "Name": "CRAN", - "URL": "https://cran.rstudio.com" - } - ] - }, - "Packages": { - "DiagrammeR": { - "Package": "DiagrammeR", - "Version": "1.0.11", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "RColorBrewer", - "cli", - "dplyr", - "glue", - "htmltools", - "htmlwidgets", - "igraph", - "magrittr", - "purrr", - "readr", - "rlang", - "rstudioapi", - "scales", - "stringr", - "tibble", - "tidyr", - "viridisLite", - "visNetwork" - ], - "Hash": "584c1e1cbb6f9b6c3b0f4ef0ad960966" - }, - "MASS": { - "Package": "MASS", - "Version": "7.3-60.0.1", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "grDevices", - "graphics", - "methods", - "stats", - "utils" - ], - "Hash": "b765b28387acc8ec9e9c1530713cb19c" - }, - "Matrix": { - "Package": "Matrix", - "Version": "1.6-5", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "grDevices", - "graphics", - "grid", - "lattice", - "methods", - "stats", - "utils" - ], - "Hash": "8c7115cd3a0e048bda2a7cd110549f7a" - }, - "R6": { - "Package": "R6", - "Version": "2.5.1", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "R" - ], - "Hash": "470851b6d5d0ac559e9d01bb352b4021" - }, - "RColorBrewer": { - "Package": "RColorBrewer", - "Version": "1.1-3", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R" - ], - "Hash": "45f0398006e83a5b10b72a90663d8d8c" - }, - "Rcpp": { - "Package": "Rcpp", - "Version": "1.0.12", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "methods", - "utils" - ], - "Hash": "5ea2700d21e038ace58269ecdbeb9ec0" - }, - "base64enc": { - "Package": "base64enc", - "Version": "0.1-3", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "R" - ], - "Hash": "543776ae6848fde2f48ff3816d0628bc" - }, - "bit": { - "Package": "bit", - "Version": "4.0.5", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R" - ], - "Hash": "d242abec29412ce988848d0294b208fd" - }, - "bit64": { - "Package": "bit64", - "Version": "4.0.5", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "bit", - "methods", - "stats", - "utils" - ], - "Hash": "9fe98599ca456d6552421db0d6772d8f" - }, - "bslib": { - "Package": "bslib", - "Version": "0.7.0", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "base64enc", - "cachem", - "fastmap", - "grDevices", - "htmltools", - "jquerylib", - "jsonlite", - "lifecycle", - "memoise", - "mime", - "rlang", - "sass" - ], - "Hash": "8644cc53f43828f19133548195d7e59e" - }, - "cachem": { - "Package": "cachem", - "Version": "1.0.8", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "fastmap", - "rlang" - ], - "Hash": "c35768291560ce302c0a6589f92e837d" - }, - "cli": { - "Package": "cli", - "Version": "3.6.2", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "utils" - ], - "Hash": "1216ac65ac55ec0058a6f75d7ca0fd52" - }, - "clipr": { - "Package": "clipr", - "Version": "0.8.0", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "utils" - ], - "Hash": "3f038e5ac7f41d4ac41ce658c85e3042" - }, - "colorspace": { - "Package": "colorspace", - "Version": "2.1-0", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "grDevices", - "graphics", - "methods", - "stats" - ], - "Hash": "f20c47fd52fae58b4e377c37bb8c335b" - }, - "cpp11": { - "Package": "cpp11", - "Version": "0.4.7", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R" - ], - "Hash": "5a295d7d963cc5035284dcdbaf334f4e" - }, - "crayon": { - "Package": "crayon", - "Version": "1.5.2", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "grDevices", - "methods", - "utils" - ], - "Hash": "e8a1e41acf02548751f45c718d55aa6a" - }, - "digest": { - "Package": "digest", - "Version": "0.6.35", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "utils" - ], - "Hash": "698ece7ba5a4fa4559e3d537e7ec3d31" - }, - "dplyr": { - "Package": "dplyr", - "Version": "1.1.4", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "R6", - "cli", - "generics", - "glue", - "lifecycle", - "magrittr", - "methods", - "pillar", - "rlang", - "tibble", - "tidyselect", - "utils", - "vctrs" - ], - "Hash": "fedd9d00c2944ff00a0e2696ccf048ec" - }, - "evaluate": { - "Package": "evaluate", - "Version": "0.23", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "methods" - ], - "Hash": "daf4a1246be12c1fa8c7705a0935c1a0" - }, - "fansi": { - "Package": "fansi", - "Version": "1.0.6", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "grDevices", - "utils" - ], - "Hash": "962174cf2aeb5b9eea581522286a911f" - }, - "farver": { - "Package": "farver", - "Version": "2.1.1", - "Source": "Repository", - "Repository": "CRAN", - "Hash": "8106d78941f34855c440ddb946b8f7a5" - }, - "fastmap": { - "Package": "fastmap", - "Version": "1.1.1", - "Source": "Repository", - "Repository": "CRAN", - "Hash": "f7736a18de97dea803bde0a2daaafb27" - }, - "fontawesome": { - "Package": "fontawesome", - "Version": "0.5.2", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "htmltools", - "rlang" - ], - "Hash": "c2efdd5f0bcd1ea861c2d4e2a883a67d" - }, - "fs": { - "Package": "fs", - "Version": "1.6.4", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "methods" - ], - "Hash": "15aeb8c27f5ea5161f9f6a641fafd93a" - }, - "generics": { - "Package": "generics", - "Version": "0.1.3", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "R", - "methods" - ], - "Hash": "15e9634c0fcd294799e9b2e929ed1b86" - }, - "ggplot2": { - "Package": "ggplot2", - "Version": "3.5.1", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "MASS", - "R", - "cli", - "glue", - "grDevices", - "grid", - "gtable", - "isoband", - "lifecycle", - "mgcv", - "rlang", - "scales", - "stats", - "tibble", - "vctrs", - "withr" - ], - "Hash": "44c6a2f8202d5b7e878ea274b1092426" - }, - "glue": { - "Package": "glue", - "Version": "1.7.0", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "methods" - ], - "Hash": "e0b3a53876554bd45879e596cdb10a52" - }, - "gtable": { - "Package": "gtable", - "Version": "0.3.5", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "cli", - "glue", - "grid", - "lifecycle", - "rlang" - ], - "Hash": "e18861963cbc65a27736e02b3cd3c4a0" - }, - "highr": { - "Package": "highr", - "Version": "0.10", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "R", - "xfun" - ], - "Hash": "06230136b2d2b9ba5805e1963fa6e890" - }, - "hms": { - "Package": "hms", - "Version": "1.1.3", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "lifecycle", - "methods", - "pkgconfig", - "rlang", - "vctrs" - ], - "Hash": "b59377caa7ed00fa41808342002138f9" - }, - "htmltools": { - "Package": "htmltools", - "Version": "0.5.8.1", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "base64enc", - "digest", - "fastmap", - "grDevices", - "rlang", - "utils" - ], - "Hash": "81d371a9cc60640e74e4ab6ac46dcedc" - }, - "htmlwidgets": { - "Package": "htmlwidgets", - "Version": "1.6.4", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "grDevices", - "htmltools", - "jsonlite", - "knitr", - "rmarkdown", - "yaml" - ], - "Hash": "04291cc45198225444a397606810ac37" - }, - "igraph": { - "Package": "igraph", - "Version": "2.0.3", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "Matrix", - "R", - "cli", - "cpp11", - "grDevices", - "graphics", - "lifecycle", - "magrittr", - "methods", - "pkgconfig", - "rlang", - "stats", - "utils", - "vctrs" - ], - "Hash": "c3b7d801d722e26e4cd888e042bf9af5" - }, - "isoband": { - "Package": "isoband", - "Version": "0.2.7", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "grid", - "utils" - ], - "Hash": "0080607b4a1a7b28979aecef976d8bc2" - }, - "jquerylib": { - "Package": "jquerylib", - "Version": "0.1.4", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "htmltools" - ], - "Hash": "5aab57a3bd297eee1c1d862735972182" - }, - "jsonlite": { - "Package": "jsonlite", - "Version": "1.8.8", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "methods" - ], - "Hash": "e1b9c55281c5adc4dd113652d9e26768" - }, - "knitr": { - "Package": "knitr", - "Version": "1.46", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "evaluate", - "highr", - "methods", - "tools", - "xfun", - "yaml" - ], - "Hash": "6e008ab1d696a5283c79765fa7b56b47" - }, - "labeling": { - "Package": "labeling", - "Version": "0.4.3", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "graphics", - "stats" - ], - "Hash": "b64ec208ac5bc1852b285f665d6368b3" - }, - "lattice": { - "Package": "lattice", - "Version": "0.22-6", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "R", - "grDevices", - "graphics", - "grid", - "stats", - "utils" - ], - "Hash": "cc5ac1ba4c238c7ca9fa6a87ca11a7e2" - }, - "lifecycle": { - "Package": "lifecycle", - "Version": "1.0.4", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "cli", - "glue", - "rlang" - ], - "Hash": "b8552d117e1b808b09a832f589b79035" - }, - "magrittr": { - "Package": "magrittr", - "Version": "2.0.3", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "R" - ], - "Hash": "7ce2733a9826b3aeb1775d56fd305472" - }, - "memoise": { - "Package": "memoise", - "Version": "2.0.1", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "cachem", - "rlang" - ], - "Hash": "e2817ccf4a065c5d9d7f2cfbe7c1d78c" - }, - "mgcv": { - "Package": "mgcv", - "Version": "1.9-1", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "Matrix", - "R", - "graphics", - "methods", - "nlme", - "splines", - "stats", - "utils" - ], - "Hash": "110ee9d83b496279960e162ac97764ce" - }, - "mime": { - "Package": "mime", - "Version": "0.12", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "tools" - ], - "Hash": "18e9c28c1d3ca1560ce30658b22ce104" - }, - "munsell": { - "Package": "munsell", - "Version": "0.5.1", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "colorspace", - "methods" - ], - "Hash": "4fd8900853b746af55b81fda99da7695" - }, - "nlme": { - "Package": "nlme", - "Version": "3.1-164", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "R", - "graphics", - "lattice", - "stats", - "utils" - ], - "Hash": "a623a2239e642806158bc4dc3f51565d" - }, - "pillar": { - "Package": "pillar", - "Version": "1.9.0", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "cli", - "fansi", - "glue", - "lifecycle", - "rlang", - "utf8", - "utils", - "vctrs" - ], - "Hash": "15da5a8412f317beeee6175fbc76f4bb" - }, - "pkgconfig": { - "Package": "pkgconfig", - "Version": "2.0.3", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "utils" - ], - "Hash": "01f28d4278f15c76cddbea05899c5d6f" - }, - "plyr": { - "Package": "plyr", - "Version": "1.8.9", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "Rcpp" - ], - "Hash": "6b8177fd19982f0020743fadbfdbd933" - }, - "prettyunits": { - "Package": "prettyunits", - "Version": "1.2.0", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R" - ], - "Hash": "6b01fc98b1e86c4f705ce9dcfd2f57c7" - }, - "progress": { - "Package": "progress", - "Version": "1.2.3", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "R6", - "crayon", - "hms", - "prettyunits" - ], - "Hash": "f4625e061cb2865f111b47ff163a5ca6" - }, - "purrr": { - "Package": "purrr", - "Version": "1.0.2", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "cli", - "lifecycle", - "magrittr", - "rlang", - "vctrs" - ], - "Hash": "1cba04a4e9414bdefc9dcaa99649a8dc" - }, - "rappdirs": { - "Package": "rappdirs", - "Version": "0.3.3", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "R" - ], - "Hash": "5e3c5dc0b071b21fa128676560dbe94d" - }, - "readr": { - "Package": "readr", - "Version": "2.1.5", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "R6", - "cli", - "clipr", - "cpp11", - "crayon", - "hms", - "lifecycle", - "methods", - "rlang", - "tibble", - "tzdb", - "utils", - "vroom" - ], - "Hash": "9de96463d2117f6ac49980577939dfb3" - }, - "renv": { - "Package": "renv", - "Version": "1.0.7", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "utils" - ], - "Hash": "397b7b2a265bc5a7a06852524dabae20" - }, - "rlang": { - "Package": "rlang", - "Version": "1.1.3", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "utils" - ], - "Hash": "42548638fae05fd9a9b5f3f437fbbbe2" - }, - "rmarkdown": { - "Package": "rmarkdown", - "Version": "2.26", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "bslib", - "evaluate", - "fontawesome", - "htmltools", - "jquerylib", - "jsonlite", - "knitr", - "methods", - "tinytex", - "tools", - "utils", - "xfun", - "yaml" - ], - "Hash": "9b148e7f95d33aac01f31282d49e4f44" - }, - "rstudioapi": { - "Package": "rstudioapi", - "Version": "0.16.0", - "Source": "Repository", - "Repository": "CRAN", - "Hash": "96710351d642b70e8f02ddeb237c46a7" - }, - "sass": { - "Package": "sass", - "Version": "0.4.9", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R6", - "fs", - "htmltools", - "rappdirs", - "rlang" - ], - "Hash": "d53dbfddf695303ea4ad66f86e99b95d" - }, - "scales": { - "Package": "scales", - "Version": "1.3.0", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "R6", - "RColorBrewer", - "cli", - "farver", - "glue", - "labeling", - "lifecycle", - "munsell", - "rlang", - "viridisLite" - ], - "Hash": "c19df082ba346b0ffa6f833e92de34d1" - }, - "stringi": { - "Package": "stringi", - "Version": "1.8.4", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "R", - "stats", - "tools", - "utils" - ], - "Hash": "39e1144fd75428983dc3f63aa53dfa91" - }, - "stringr": { - "Package": "stringr", - "Version": "1.5.1", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "cli", - "glue", - "lifecycle", - "magrittr", - "rlang", - "stringi", - "vctrs" - ], - "Hash": "960e2ae9e09656611e0b8214ad543207" - }, - "tibble": { - "Package": "tibble", - "Version": "3.2.1", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "R", - "fansi", - "lifecycle", - "magrittr", - "methods", - "pillar", - "pkgconfig", - "rlang", - "utils", - "vctrs" - ], - "Hash": "a84e2cc86d07289b3b6f5069df7a004c" - }, - "tidyr": { - "Package": "tidyr", - "Version": "1.3.1", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "cli", - "cpp11", - "dplyr", - "glue", - "lifecycle", - "magrittr", - "purrr", - "rlang", - "stringr", - "tibble", - "tidyselect", - "utils", - "vctrs" - ], - "Hash": "915fb7ce036c22a6a33b5a8adb712eb1" - }, - "tidyselect": { - "Package": "tidyselect", - "Version": "1.2.1", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "cli", - "glue", - "lifecycle", - "rlang", - "vctrs", - "withr" - ], - "Hash": "829f27b9c4919c16b593794a6344d6c0" - }, - "tinytex": { - "Package": "tinytex", - "Version": "0.51", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "xfun" - ], - "Hash": "d44e2fcd2e4e076f0aac540208559d1d" - }, - "tzdb": { - "Package": "tzdb", - "Version": "0.4.0", - "Source": "Repository", - "Repository": "RSPM", - "Requirements": [ - "R", - "cpp11" - ], - "Hash": "f561504ec2897f4d46f0c7657e488ae1" - }, - "utf8": { - "Package": "utf8", - "Version": "1.2.4", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R" - ], - "Hash": "62b65c52671e6665f803ff02954446e9" - }, - "vctrs": { - "Package": "vctrs", - "Version": "0.6.5", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "cli", - "glue", - "lifecycle", - "rlang" - ], - "Hash": "c03fa420630029418f7e6da3667aac4a" - }, - "viridisLite": { - "Package": "viridisLite", - "Version": "0.4.2", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R" - ], - "Hash": "c826c7c4241b6fc89ff55aaea3fa7491" - }, - "visNetwork": { - "Package": "visNetwork", - "Version": "2.1.2", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "grDevices", - "htmltools", - "htmlwidgets", - "jsonlite", - "magrittr", - "methods", - "stats", - "utils" - ], - "Hash": "3e48b097e8d9a91ecced2ed4817a678d" - }, - "vroom": { - "Package": "vroom", - "Version": "1.6.5", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "bit64", - "cli", - "cpp11", - "crayon", - "glue", - "hms", - "lifecycle", - "methods", - "progress", - "rlang", - "stats", - "tibble", - "tidyselect", - "tzdb", - "vctrs", - "withr" - ], - "Hash": "390f9315bc0025be03012054103d227c" - }, - "withr": { - "Package": "withr", - "Version": "3.0.0", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "R", - "grDevices", - "graphics" - ], - "Hash": "d31b6c62c10dcf11ec530ca6b0dd5d35" - }, - "xfun": { - "Package": "xfun", - "Version": "0.43", - "Source": "Repository", - "Repository": "CRAN", - "Requirements": [ - "grDevices", - "stats", - "tools" - ], - "Hash": "ab6371d8653ce5f2f9290f4ec7b42a8e" - }, - "yaml": { - "Package": "yaml", - "Version": "2.3.8", - "Source": "Repository", - "Repository": "CRAN", - "Hash": "29240487a071f535f5e5d5a323b7afbd" - } - } -}