R-base: algunas ideas básicas

class: inverse, center, middle

<br>

#### ITA (modulo práctico)

## R-base: algunas ideas básicas

<br>

### Pedro J. Pérez

<br><br>
  
#### e-mail: [pedro.j.perez@uv.es](mailto:pedro.j.perez@uv.es)

---
class: inverse, center, middle

## R-base (algunas ideas básicas)

#### Es muy importante *empezar* a entenderlas

---
##### Veremos conceptos/ideas como

<br>

- asignación

- tipos de datos

- estructuras de datos

- funciones

- paquetes: instalación y ayuda

<br>

---
class: inverse, center, middle

### Creación de objetos (asignación)

#### En R, la asignación se hace, generalmente, con el símbolo: .large[<-]

---

##### Creación de objetos y asignación (.large[<-])

- 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:

``` r
#- ¿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 <- bb
```

---

##### 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: .white.bg-purple[nombre_del_objeto <- valor] , por ejemplo .white.bg-purple[aa <- 2 + 2]  [ 🌟 ]

<br>

- 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:

``` r
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.
```

---
class: inverse, center, middle

### Tipos de datos

#### numéricos (enteros y doubles), lógicos y textuales

---

##### Tipos de datos

- Hay **3 tipos principales**: numéricos, de texto y lógicos

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

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

``` r
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)
```

<br>

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

---

##### Operaciones con variables numéricas

- Operaciones aritméticas

``` r
2 + 2
5 * 6
```

- Operaciones de comparación

``` r
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 FALSE 
```

- 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.

``` r
2 = 2    #- ¿qué ocurre? ¿xq se queja R?
```

---

##### 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:

``` r
aa <- "mi nombre es"
bb <- "pedro"

paste(aa, bb)

paste(aa, bb, sep = " ... ")

# Prueba tú mismo que hace la función paste0()
```

<br>

``` r
toupper(aa)
tolower(aa)

nchar(bb)                      #- nchar() nos devuelve el número de caracteres de un string

substring(bb, 2, nchar(bb))    #- substring() extrae caracteres de un string  [🌶🌶]
```

---

##### Operaciones lógicas

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

``` r
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
!FALSE
```

``` r
(4 > 3) & (3 < 2)  #- AND: como solo se cumple la primera condición, nos devuelve FALSE

(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: TRUE

```

- 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.

---
class: inverse, center, middle

## Estructuras de datos

#### Es muy importante!!! [ 🌟 ] pero en realidad para el curso basta con una "ligera" idea, porque trabajaremos (casi siempre) con una sola estructura de datos: los *data.frame*

---

##### 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.

---
class: inverse, center, middle

## VECTORES

#### No los utilizaremos mucho-mucho, pero es la estructura de datos fundamental

---

##### 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 .white.bg-purple[c()]

``` r
aa <- c(3, 22, 6)

aa
is.vector(aa)
typeof(aa)
```

<br>

.panelset[
.panel[.panel-name[Tarea]

.white.bg-green[Tarea]: crea un vector de tipo character con 3 elementos

]

.panel[.panel-name[Solución]

``` r
aa <- c("Hola", "número", "9")

is.vector(aa)
typeof(aa)
```

]
]

---

##### 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

``` r
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?
```

- 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.

``` r
aa <- c(1:4)
aa
aa <- as.character(aa)
aa
```

---

##### 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

``` r
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
```
  
--
 
###### 2. Eliminar por posición

``` r
aa <- c(10:1)
aa[-2]

aa[- c(1, 2, 9:10)]
```
  
--

###### 3. Subsetting lógico

``` r
aa <- 1:10
aa[aa >= 7]
aa[aa < 4]

aa[(aa >= 9) | (aa < 2)]
aa[(aa >= 9) & (aa < 2)]
```

---

##### Intenta entender bien el siguiente chunk. Es importante!!

``` r
aa <- 1:10

aa <= 4
aa[aa <= 4]
aa <- aa[aa <= 4]
aa
```
  
--

##### Modificando elementos de un vector

``` r
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 aa
```

##### Los vectores se pueden concatenar

``` r
aa <- c(1:5)
bb <- c(100:105)
cc <- c(aa, bb)
```

---

##### Operaciones con vectores

- Generalmente son operaciones elemento a elemento

``` r
aa <- 1:10
bb <- 1:10

aa + bb
aa * bb
```

<br>
 
--

--------------------------------------------------

#####  Recycling

``` r
aa <- 1:10
aa + 1
```

---

##### 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.

``` r
aa <- c(4, 9, 25)

sqrt(aa)
```

<br>

-----------------------------

<br>

##### Operaciones de comparación

``` r
aa <- 1:3
bb <- 3:1

aa == bb
aa >= bb
aa != bb
```

---
class: inverse, center, middle

## LISTAS

#### Veremos un poco, pero más adelante

---
class: inverse, center, middle

## DATA FRAMES

#### Estaremos todos el curso trabajando con DATA FRAMES

---

##### DATA FRAME's

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

<br>

- Un data.frame (df) es una agrupación de vectores con la misma longitud, de forma que al final tenemos una tabla de datos, donde **cada columna será una variable**

<br>

- Otra propiedad de los data.frames es que sus vectores (o columnas) tienen que tener un nombre, que 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 sí vamos a crear uno con la función, se hace con la función **`data.frame()`**

``` r
#- creamos 3 vectores de la misma longitud
aa <- c(4, 8, 6, 3)
bb <- c("Juan", "Paz", "Adrian", "Marquitos")
cc <- c(FALSE, TRUE, TRUE, FALSE)

#- agrupamos los 3 vectores en un data.frame
df <- data.frame(aa, bb, cc)

#- veamos el data.frame. Veremos que las columnas tienen nombre
df
```

<br>

- Podemos ponerle otros nombres a las columnas, nombres que tengan sentido para que nos recuerden las variables que contienen en cada columna:

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

---

##### 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 $**.

<br>

------------------------------

##### subsetting como si fuera matriz (con [ )

``` r
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.
```

---

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

#### Como lista con [

- siempre devuelve un df

``` r
df_s <- df[3]       
df_s <- df[c(1,2)]

#- también se puede hacer por nombre
df_s <- df["Name"]              
df_s <- df[c("Name", "Grade")]   
```

#### Como lista con [[

``` r
df_s <- df[[2]]   #- Extraemos la segunda columna.
```

#### Como lista con $

``` r
df_s <- df$Name   #- Extraemos la columna con nombre "Name".

df_s <- df$Grade  #- Extraemos la columna con nombre "Grade". 
```

---
class: inverse, center, middle

# FUNCIONES

#### Quizás lo más importante del curso sea entender bien cómo "funciona" una función

---

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

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

<br>

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

<br>

- **¿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 asignado un nombre; entonces, cuando invoquemos ese nombre se ejecutarán esas lineas de código. (!!!)

<br>

- 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 [🌶🌶🌶]

.panelset[
.panel[.panel-name[Tarea]

.white.bg-green[Tarea]: crea una función que permita sumar 2 números

]

.panel[.panel-name[Pistas]

**Pista**: Las funciones en R se crean con la función llamada `function()`. Sí, un poco trabalenguas.

**Pista**: La función que vamos a crear será un objeto de R, así que le tenemos que asignar un nombre

**Pista**: Los argumentos de la función van dentro de los paréntesis separados por comas

**Pista**: El código que queramos que se ejecute cuando llamemos a la función va entre llaves

<br>

Por lo tanto, en genérico, una función en R se crea así:

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

<br>

**Sí lo conseguís sois genios/genias** o ya habéis visto esto en otro lenguaje

]
.panel[.panel-name[Solución]

``` r
#- 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, 
#- tenemos que llamar a la función my_suma() y pasarle los argumentos que necesita

my_suma(3 , 5)

my_suma(n1 = 3 , n2 = 5)

aa <- my_suma(30 , 50)
```

]
]

##### 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 nueva función, 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 .white.bg-purple[F1]. También puedes hacer:

``` r
help(sqrt)
```

- 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:  .white.bg-purple[nombre_de_la_funcion(argumento_1, argumento_2, ....) ] . Luego volveremos a este punto.

<br>

- .white.bg-green[Tarea:]Ejecuta estas instrucciones e intenta entender que ocurre.

``` r
sqrt(9)

sqrt(9, 4)   #- no funciona, ¿por qué? ¿cuantos argumentos tiene la f. sqrt()?

sqrt("9")    #- no funciona, ¿por qué? ¿de que tipo ha de ser el argumento?
```

<br>

---

##### 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, ....)
```

- 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. (!!!).

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

--------------------------

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

``` r
sqrt(9)
sqrt(x = 9)

x <- 25
sqrt(x)

sqrt(x = x)          #- !!! ¿cual es el nombre y el valor del argumento?
sqrt(x = un_valor)   #- !!! ¿qué ocurre?
sqrt(nn = 9)         #- !!! ¿qué ocurre?
```

---

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

- .white.bg-green[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**.

.panelset[
.panel[.panel-name[Tarea]
    
- Venga, que os ayudo: `log(1000)` no va a funcionar. ¿Por qué? para saberlo tendrás que mirar la ayuda de la función `log()`

``` r
help(log)
```
]

.panel[.panel-name[Solución]

``` r
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 naturales
```

``` r
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 ...
```

¿Por qué no podemos usar la expresión de abajo?

``` r
log(10, 1000)
```

``` r
log(base = 10, 1000)
```

]
]

-
---
class: inverse, center, middle

## Paquetes: instalación y ayuda

#### Es importante entender la diferencia entre paquetes en CRAN y en otros repositorios, y sobre todo, saber buscar la ayuda de un paquete.

---

##### Paquetes (primeras ideas)

<br>

- **¿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.

<br>

- Los paquetes suelen estar en **repositorios**

- R tiene un **repositorio oficial** llamado [**CRAN**](https://cran.r-project.org/). Ahora mismo tiene 16.273 paquetes. [Aquí](https://cran.r-project.org/web/packages/index.html) puedes ver el listado de paquetes ordenados alfabéticamente y por fecha, y [aquí](https://cran.r-project.org/web/views/) 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:

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

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

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

----------------------------

<br>

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

``` r
library(dplyr)    #- cargamos dplyr en memoria de R para así poder usarlo
```