Veremos conceptos/ideas como

• asignación

• tipos de datos

• estructuras de datos

• funciones

• paquetes: instalación y ayuda

Creación de objetos y asignación (<-)

• El operador de asignación (<-) permite asignar datos/valores a variables/objetos. Con la asignación se crean objetos/variables que después podremos usar en otras operaciones.

• Es mucho más fácil explicarlo apoyándose en ejemplos:

#- ¿Qué diferencias hay entre las siguientes 2 expresiones?
2 + 2
aa <- 2 + 2
#- una vez hemos creado una variable, podemos usarla para efectuar nuevos cálculos
aa + 1
#- podemos cambiar el valor de una variable
aa
aa <- 10
aa
#- ¿Qué hacen las siguientes lineas de código? 
aa <- 2 + 2
bb <- 5 + aa
cc <- 1 + aa * 2
dd <- bbCopy Code

Se que te ha resultado muy fácil, pero vuelvo a insistir:

En R, la forma genérica de una operación de asignación, o de “creación de objetos”, es: nombre_del_objeto <- valor , por ejemplo aa <- 2 + 2 [ 🌟 ] [🌶]

• Recuerda que para que un nombre sea sintácticamente válido en R sólo puede contener caracteres alfanuméricos (letras y números), puntos (.) y guiones bajos (_).

• Además, hay nombres reservados (TRUE, NA, if, while, do , next, for ...)

Global environment (primera referencia al)

Cada vez que asignamos un nombre a un valor, R crea un nuevo objeto en el Global environment. Veámoslo:

aa <- 2 + 2
bb <- 5 + aa
cc <- 1 + aa * 2
dd <- bb
ls()              #- muestra los objetos q hay en el  Global env. 
rm(cc)            #- borra/elimina el objeto cc del Global env.
rm(list = ls())   #- borra todos los objetos del Global env.Copy Code

Tipos de datos

• Hay 3 tipos principales: numéricos, de texto y lógicos, pero en realidad R tiene 6 tipos de datos.

• Además, hay 4 valores especiales: NULL, NA, NaN, e infinito

• Cada dato, valor o variable es de un tipo.

aa <- "La calle en la que vivo es"    #- texto (character)
bb <- 4L                              #- número entero
cc <- 4.3                             #- número decimal
dd <- TRUE                            #- logical
typeof(aa)
typeof(dd)Copy Code

• IMPORTANTE [ 🌟 ]: El tipo de una variable determina las operaciones que se pueden hacer con él.

Operaciones con variables numéricas

• Operaciones aritméticas

2 + 2
5 * 6Copy Code

• Operaciones de comparación

2 < 4    # MENOR que: esta expresión chequea si 2 es MENOR que cuatro. Como es cierto, nos devuelve un TRUE
2 > 4    # MAYOR que: esta expresión chequea si 2 es MAYOR que cuatro. Como es cierto, nos devuelve un TRUE
5 >= 7   # MAYOR o IGUAL que.
8 <= 8   # MENOR o IGUAL que.
5 == 4  # == IGUAL: == chequea si dos valores son iguales, como no son iguales devolverá FALSE
2 != 4   # NO IGUAL: como 2 no es igual a 4 nos devuelve TRUE
5 != 5   # NO IGUAL: como 5 es igual a 5, nos devuelve FALSECopy Code

• Fíjate que las expresiones de comparación al ser ejecutadas devuelven un “boolean”: el resultado de la comparación solo puede ser TRUE (si la afirmación es cierta) o FALSE.

2 = 2    #- ¿qué ocurre? ¿xq se queja R?Copy Code

Operaciones con texto

• En R hay muchas funciones para trabajar/operar sobre texto

• Por ejemplo, la función paste() nos permite pegar o concatenar dos variables de tipo character:

aa <- "mi nombre es"
bb <- "pedro"
paste(aa, bb)
paste(aa, bb, sep = " ... ")
# Prueba tú mismo que hace la función paste0()Copy Code

toupper(aa)
tolower(aa)
stringr::str_to_sentence(aa)   #- stringr es un pkg del tidyverse
nchar(bb)                      #- nchar() nos devuelve el número de caracteres de un string
substring(bb, 2, nchar(bb))    #- substring() extrae caracteres de un string  [🌶🌶]Copy Code

Operaciones lógicas

• Los 3 principales operadores lógicos son: ( & ), ( |) y ( ! ). Son los operadores lógicos AND, OR y NOT

TRUE & TRUE    #- AND: para q devuelva TRUE hace falta que TODAS las condiciones sean ciertas
TRUE & FALSE
FALSE & FALSE
TRUE | TRUE   #- OR: devuelve TRUE si ALGUNA de las condiciones es cierta
TRUE | FALSE
FALSE | FALSE
!TRUE         #- NOT: devuelve el valor contrario
!FALSECopy Code

(4 > 3) & (3 < 2)  #- AND: como solo se cumple la primera condición, nos devuelve TRUE
(1==2) | (2 >3)   #- OR: Como no se cumple ninguna de las 2 condiciones nos devuelve FALSE
!(4 > 3)          #- NOT: 4 es mayor que 3 es TRUE, pero el ! delante de esa condición la niega y pasa a FALSE
!!(4 > 3)         #- si niegas dos veces, vuelves al principio: TRUECopy Code

• Hay más operadores lógicos, por ejemplo: xor(), all(), any(), && y || , pero es fácil que no los usemos ,y si los usamos ya los veremos.

Estructuras de datos

R sirve para hacer análisis estadísticos con datos, y los datos tienen que estar almacenados en alguna estructura. Las principales estructuras de datos en R son:

• vectores

• matrices

• arrays (matrices multidimensionales)

• listas

• data.frames

• Las que más utilizaremos en el curso son los *data.frames, y en segundo lugar las listas.

• Si, pero en realidad estas 2 estructuras (data.frames y listas) son en realidad agrupaciones de vectores; es decir, la estructura básica, la más importante en R son los vectores.

• Son los más importantes porque el resto de estructuras se construyen a partir de grupos de vectores o añadiendo alguna propiedad adicional, o atributo, a un vector.

Vectores

• La estructura de datos fundamental en R es el vector.

• En R, un vector es una estructura de datos que sirve para almacenar un conjunto ordenado de valores o elementos.

• Un vector puede contener cualquier número de elementos; sin embargo, todos los elementos deben ser del mismo tipo. Por ejemplo, un vector no puede contener simultáneamente números y texto.

¿Cómo crear un vector?

• Con la función c()

aa <- c(3, 22, 6)
aa
is.vector(aa)
typeof(aa)Copy Code

aa <- c("Hola", "número", "9")
is.vector(aa)
typeof(aa)Copy Code

Coerción (implicita)

• Sabemos que un vector solo puede contener elementos de un tipo (es una estructura homogénea)

• ¿Qué ocurre si intentamos mezclar en un vector elementos de distinto tipo? R convertirá (coercerá) los elementos para que sean del mismo tipo

aa <- c(4, 6,  "Hola")  #- intentamos poner en aa elementos numéricos y character (¿?)
is.vector(aa)
typeof(aa)       #- ¿qué ha pasado?
aa               #- ¿qué ha pasado?Copy Code

• R convertirá todos los elementos al tipo más flexible: character > double > integer > logical. Por ejemplo, si en el vector hay un valor textual, todos los valores se convertirán al tipo character.

Coerción (explicita)

• A veces tendremos un vector de un tipo, por ejemplo numérico, pero nos gustaría convertirlo a por ejemplo character.

aa <- c(1:4)
aa
aa <- as.character(aa)
aaCopy Code

Subsetting con vectores

• En R podemos agrupar valores en vectores. Perfecto, pero habrá veces que necesitemos manipular los vectores. Por ejemplo necesitaremos acceder a determinados elementos de un vector. Este tipo de operaciones sobre los vectores se les conoce genéricamente como subsetting.

• Para hacer subsetting se usan los corchetes: []

• Vemos 3 tipos de subsetting

3 tipos de subsetting

1. Seleccionar por posición

aa <- c(10:1)
aa[c(1:2)]        #- primer y segundo elemento del vector
aa[c(1, 2, 9, 10)]   #- dos primeros y 2 últimos
aa[c(1, 1, 10, 10)]  #- si repites el indice se repite el elemento del vectorCopy Code

2. Eliminar por posición

aa <- c(10:1)
aa[-2]
aa[- c(1, 2, 9:10)]Copy Code

3. Subsetting lógico

aa <- 1:10
aa[aa >= 7]
aa[aa < 4]
aa[(aa >= 9) | (aa < 2)]
aa[(aa >= 9) & (aa < 2)]Copy Code

Intenta entender bien el siguiente chunk. Es importante!!

aa <- 1:10
aa <= 4
aa[aa <= 4]
aa <- aa[aa <= 4]
aaCopy Code

Modificando elementos de un vector

aa <- c(1:10)
aa[4] <- 88             #- el cuarto elemento de aa tomará el valor 88
aa <- c(aa, 111, 112)   #- añadimos 2 elementos al vector aaCopy Code

Los vectores se pueden concatenar

aa <- c(1:5)
bb <- c(100:105)
cc <- c(aa, bb)Copy Code

Operaciones con vectores

• Generalmente son operaciones elemento a elemento

aa <- 1:10
bb <- 1:10
aa + bb
aa * bbCopy Code

• Si quieres hacer álgebra matricial son otros operadores

aa  %*% bbCopy Code

Recycling

aa <- 1:10
aa + 1Copy Code

Funciones vectorizadas

• La mayoría de funciones, y todos los operadores de R están vectorizados; es decir, si una función recibe como input un vector, se aplicará la función a cada uno de los elementos del vector.

aa <- c(4, 9, 25)
sqrt(aa)Copy Code

Operaciones de comparación

aa <- 1:3
bb <- 3:1
aa == bb
aa >= bb
aa != bbCopy Code

• En las operaciones de comparación también aplica el Recycling

aa <- 1:3
bb <- 2
aa == bb
aa >= bb
aa != bbCopy Code

Lists

• Esta estructura de datos, aunque en realidad se construye por agrupación de vectores, sí que se comporta de forma diferente a los vectores.

• Las listas son una estructura de datos heterogénea: sí pueden contener elementos de distinto tipo.

• La mejor forma de entender como funciona una lista es pensar que es como una cajonera. En cada cajón podemos poner objetos de diferentes tipos.

• Vamos a crear una lista. Se hace con list()

# defino 3 vectores y una matriz
vec_numerico <- c(1:8)
vec_character <- c("Pedro", "Rebeca", "Susana")
vec_logic <- c(TRUE, FALSE, TRUE)
matriz <- matrix(1:6, nrow = 2, ncol = 3)
# creo una lista con cuatro elementos
my_list <- list(vec_numerico, vec_character, vec_logic, matriz)
my_listCopy Code

más cosas sobre las listas

• Las listas son sumamente flexibles porque un elemento de una lista puede ser otra lista.

• Como son tan flexibles, se usan para muchas cosas, por ejemplo para almacenar los resultados de la estimación de modelos estadísticos. (por ejemplo, los gráficos de ggplot internamente son listas)

• Un ejemplo:

my_list_2 <- list(primer_slot = c(44:47), segundo_slot = my_list)
my_list_2Copy Code

Subsetting con listas

• Ya lo veremos cuando lo necesitemos!!

DATA FRAME's

• Son otra estructura de R para almacenar datos. Se utiliza para almacenar datos tabulares, tablas de datos

• En el fondo, un data.frame es una lista. Al ser una lista puede almacenar elementos de distinto tipo (numéricos, carácter etc…).

• PERO es una lista especial: está restringida a que sus elementos/slots son vectores con la misma longitud; de forma que, al final tenemos una tabla de datos, donde cada columna será una variable

• Otra propiedad de los data.frames es que sus vectores (o columnas) tienen que tener un nombre: será el nombre de la variable.

Creación de data frame's

• Generalmente no crearemos data.frames sino que los importaremos de repositorios de datos, por ejemplo de Eurostat o del INE, pero hoy vamos a crear uno con la función data.frame()

aa <- c(4, 8, 6, 3)
bb <- c("Juan", "Paz", "Adrian", "Marquitos")
cc <- c(FALSE, TRUE, TRUE, FALSE)
df <- data.frame(aa, bb, cc)Copy Code

• Podemos ponerle otros nombres a las columnas, nombres que tengan sentido y que nos recuerden las variables que contienen:

df <- data.frame(Nota = aa, Nombre = bb, Aprobado = cc)Copy Code

Subsetting en data frames

Generalmente, cuando tengamos que hacer subsetting en un data frame, lo haremos à la tidyverse, pero conviene al menos conocer lo básico de como hacer subsetting con R-base.

Varias formas de subsetting:

• como si fuera una matriz, usando el corchete; o sea, con [.

• como si fuera una lista. De hecho un df es una clase especial de lista. Podemos usar 3 operadores: [, [[ y $.

subsetting como si fuera matriz (con [ )

df_s <- df[,1]        #- seleccionamos la primera columna. devuelve un vector !!!
df_s <- df[,c(2,3)]   #- seleccionamos la segunda y tercera columna. devuelve un df
df_s <- df[1, ]       #- seleccionamos primera fila de todas las variables. devuelve un df. ¿xq no devuelve un vector? Preguntad si no lo sabéis
df_s <- df[c(1,4), ]  #- seleccionamos primera y cuarta fila. devuelve un df
df_s <- df[2, 3]      #- seleccionamos segunda observación de la tercera variable. Devuelve un vector.Copy Code

data.frames: subsetting como si fuera una lista (con [, [[, $)

Como lista con [

• siempre devuelve un df

df_s <- df[3]        #- devuelve un df. Good!!
df_s <- df[c(1,2)]
#- también se puede hacer por nombre
df_s <- df["Name"]                #- devuelve un df
df_s <- df[c("Name", "Grade")]Copy Code

Como lista con [[

df_s <- df[[2]]   #- Extraemos la segunda columna. Devuelve un vector, concretamente un factor. Ahhhh!!!!!Copy Code

Como lista con $

df_s <- df$Name   #- Extraemos la columna con nombre "Name". Devuelve un vector, concretamente un factor. Ahhhh!!!!!
df_s <- df$Grade  #- Extraemos la columna con nombre "Grade". Devuelve un vector numéricoCopy Code

Entender qué es una función y ...

... cómo “funciona una función” es muuuuy importante!!!

• Repito, es muy importante entender qué es y cómo usar una función. De hecho, todo lo que ocurre/pasa en R es porque has llamado a una función. Si algo ocurre en R es porque has hecho una llamada a una función, una “function call”.

To understand computations in R, two slogans are helpful:

- Everything that exists is an object.  
- Everything that happens is a function call.  
Copy Code

— John Chambers (creador de S)

• ¿Qué es una función? Una función no es más un trozo de código R, unas instrucciones de R, a las que les hemos puesto/asignado un nombre; entonces, cuando invoquemos ese nombre, esa función, se ejecutarán esas lineas de código. (!!!)

• Como no creo que lo anterior os diga mucho, voy a usar 5 minutos para crear nuestra primera función. Vamos a R.

Creamos nuestra primera función [🌶🌶🌶]

nombre_de_mi_funcion <- function(primer_argumento, segundo_argumento, ...) {
  <el-codigo-q-quiero-q-se-ejecute-cuando-se-invoque-a-la-función>
}Copy Code

#- creamos una función llamada "my_suma()". Lo hacemos con la función de R llamada "function()"
my_suma <- function(n1 , n2){
  n1 + n2
}
#- para usar la función que hemos creado
my_suma(3 , 5)
my_suma(n1 = 3 , n2 = 5)
aa <- my_suma(30 , 50)Copy Code

entiendes mejor ahora qué es una función?

• Tras haber creado nuestra primera función, yo creo que ahora entenderás mejor que una función no es más que un trozo de instrucciones/código en R que alguien ha creado para ser usada. Solo tenemos que invocar su nombre y dar valores a sus argumentos.

seguimos con las funciones

• Vamos a profundizar en nuestro conocimiento de las funciones usando una: usando la función sqrt(). Resulta que alguien se ha preocupado de construir una función llamada sqrt() que sirve para calcular raíces cuadradas. Vamos a usarla!! Cómo??

saber consultar la ayuda de una función is VERY important [ 🌟 ]

• Para saber como usar una función lo que hay que hacer es consultar la ayuda de la función; sí cada función de R tiene una página de ayuda interna.

• Para abrir la ayuda de una función tienes que situar el cursor en el nombre de la función y pinchar en F1. También puedes hacer:

help(sqrt)Copy Code

• Pufff!!! la ayuda de la función parece muy complicada. Sí, eso parece: hay que aprender a leer las ayudas de las funciones. Esto es MUY IMPORTANTE!!!! si quieres aprender a manejarte con R. Enseguida lo vemos

seguimos con las funciones

• Aunque no lo entiendas del todo, tienes que saber que, cuando vamos a usar una función, su estructura es: nombre_de_la_funcion(argumento_1, argumento_2, ....) . Luego volveremos a este punto.

• Tarea:Ejecuta estas instrucciones e intenta entender que ocurre.

sqrt(9)
sqrt(9, 4)   #- no funciona ¿por qué? ¿cuantos argumentos tiene la f. sqrt()?
sqrt("9")    #- no funciona, ¿por qué? ¿Cómo, de que tipo, ha de ser el argumento?Copy Code

seguimos con las funciones (más detalles) [🌶🌶🌶]

• En realidad, cuando vamos a usar una función, cada argumento de la función tiene 2 elementos: el nombre del argumento y un valor para el argumento

nombre_de_la_funcion(name_argumento_1 = valor_1, name_argumento_2 = valor_2, ....)Copy Code

• El nombre de la función sqrt() es sqrt, ok, pero ¿cuales son sus argumentos? La ayuda nos dice que sólo tiene un argumento, cuyo nombre es x; además, el valor del argumento debe ser numérico. (!!!).

sqrt(9)       #- en realidad "no hace falta" poner el nombre del argumento
sqrt(x = 9)   #- 
sqrt(x = 4)Copy Code

• Vamos a aprender a diferenciar el nombre y el valor del argumento de una función:

sqrt(9)
sqrt(x = 9)
x <- 25
sqrt(x)
sqrt(x = x)          #- !!!
sqrt(x = un_valor)   #- !!!
sqrt(nn = 9)         #- !!!Copy Code

seguimos con las funciones (ya casí lo tenemos!!)

• Tarea: calculad con R el logaritmo de 1000 en base 10.

  Para ello tenéis que usar la función log(), y cómo no sabéis cómo se usa, no sabéis cómo es su sintaxis, no sabéis cuales son sus argumentos, os tocará mirar la ayuda de la función.

help(log)Copy Code

log(1000)  #- como no especificamos el valor del argumento "base",
           #- R lo fija a su valor x defecto; es decir, base = exp(1) 
           #- así que estamos tomando logaritmos naturalesCopy Code

log(x = 1000, base = 10)    #- GOOD
log(1000, base = 10)        #- es equivalente
log(x = 1000, 10)           #- es equivalente
log(1000, 10)               #- es equivalente
log(1000, bas = 10)         #- funciona, pero ...Copy Code

log(10, 1000)Copy Code

log(base = 10, 1000)Copy Code

Para finalizar (de momento) con las funciones, 3 cosas:

• Leeros el apéndice A.1.1 del libro Data Visualization A practical introduction de Kieran Healy. El apéndice está (aquí)[https://socviz.co/appendix.html#a-little-more-about-r], y se llama "How to read an R help page".

• En casa, podéis ver [este video]: en él nos cuentan que, cuando creas una función, su estructura general es:

    function_name <- function(my_args) {
    # process the arguments
    # return some value
    }Copy Code

Por ejemplo, podríamos crear una función para sumar 1 a un número:

add1 <- function(my_number) {
  my_number + 1
}Copy Code

• Para finalizar de verdad con las funciones, tenéis una nueva tarea: cread una función que sume tres números (!!)

venga a hacer la tarea para finalizar con las funciones!! [🌶🌶🌶🌶]

name_of_my_function <- function(<los argumentos van AQUI>){
  #- aquí tienes que poner el código de la función
}Copy Code

... <- function(n1 = ... , ... = 6, ... = ... ){
   ... + n2 + ...
}Copy Code

my_suma <- function(n1 , n2, n3){
   n1 + n2 + n3
}
#- vamos a usar nuestra función
my_suma(2, 2, 2)
my_suma(2)        #- xq no funcionaCopy Code

my_suma <- function(n1 = 4 , n2 = 6, n2 = 3){
   n1 + n2 + n3
}
#- vamos a usar nuestra función
my_suma(2, 2, 2)
my_suma(2)        #- xq ahora sí funcionaCopy Code

Paquetes (primeras ideas)

• ¿Qué son los paquetes? trozos/porciones de código R que podemos instalar en nuestro ordenador

• ¿Qué ganamos instalando un paquete? Los paquetes nos proveen de nuevas funciones o nuevos datos; es decir incrementa la funcionalidad de R: por ejemplo, con el pkg meme podemos hacer memes.

• Los paquetes suelen estar en repositorios

• R tiene un repositorio oficial llamado CRAN. Ahora mismo tiene 16.273 paquetes. Aquí puedes ver el listado de paquetes ordenados alfabéticamente y por fecha, y aquí ordenados por tópico.

• Hay otros repositorios: Github, Gitlab, Bioconductor, ...

¿Cómo me instalo un paquete? (Forma habitual)

• Para instalar un paquete que está en CRAN hay que usar:

install.packages("dplyr")    #- instalamos el pkg dplyr en nuestro ordenador
library(dplyr)               #- cargamos dplyr en memoria de R para así poder usarloCopy Code

• Para instalar un paquete que está en GitHub hay que tener instalado el paquete remotes o el paquete devtools y hacer:

install.packages("remotes")    #- previamente hay que instalar el pkg remotes
remotes::install_github("tidyverse/dplyr")   #- instalamos la versión de github del pkg dplyrCopy Code

• Recuerda que, una vez instalado un paquete, cada vez que queramos usar ese paquete hay que cargarlo en memoria con

library(dplyr)    #- cargamos dplyr en memoria de R para así poder usarloCopy Code

• Recuerda que los paquetes se instalan una sola vez, pero que cada vez que queramos usarlo hay que "cargarlo" en memoria con library()

Obtener ayuda de un paquete

• Los paquetes que están en CRAN, tienen obligatoriamente un manual en pdf, pero son mucho más didácticas las vignettes (que no son obligatorias).

• Por ejemplo, el paquete dplyr está en CRAN en esta dirección. Como podéis ver tiene un manual en pdf y un listado de viñetas.

• Si el paquete tiene vignettes, también puedes consultarlas desde RStudio usando cualquiera de las 2 expresiones de abajo:

help(package = "dplyr")
browseVignettes("dplyr")Copy Code

• Generalmente los paquetes, incluso los que están en CRAN, tienen una versión de desarrollo en Github. Por ejemplo, aquí tienes el link al repo de dplyr en Github.

• Además, cada vez es más frecuente que los paquetes tengan una pagina web propia. Por ejemplo aquí tienes la pagina web de dplyr. Generalmente tienen una sección llamada "Articles" donde tienes las vignettes.

• Aunque la verdad, muchas veces, la forma más rápida de aprender a usar un paquete es buscar en Google, y generalmente encuentras un post con una buena introducción al paquete.

Ejemplo: vamos a buscar ayuda para poder usar el paquete "explore"

#- post: https://rolkra.github.io/start-to-explore/
#- CRAN: https://cran.r-project.org/web/packages/explore/index.html
#- Github: https://github.com/rolkra/explore
#- install.packages("explore")                 #- instalamos la versión de CRAN
#- devtools::install_github("rolkra/explore")  #- instalamos la versión de Github
#- vamos a usar el paquete con el conjunto de datos `iris`
library(explore)
explore(iris)
#- vamos a usar explore para analizar `penguins`
library(palmerpenguins)
library(explore)
explore(penguins)Copy Code