Instalación: 2 componentes

Instalación de R

• R es un lenguaje de programación (gramática). Una vez que sabemos hablarlo (escribirlo, vocabulario y gramática), podemos utilizarlo para mandar tareas al ordenador.

• R es un lenguaje gratuito y de código abierto.

• Podemos instalarlo desde https://www.r-project.org/

• Consola y primeras operaciones en R

Instalación de R

• Paso 1: entra en CRAN y selecciona tu sistema operativo.

• Paso 2: para Mac basta con que hacer click en el archivo .pkg, y abrirlo una vez descargado. Para sistemas Windows, debemos clickar en “install R for the first time” y después en “Download R for Windows”. Una vez descargado, abrirlo como cualquier archivo de instalación.

• Paso 3: abrir el ejecutable de instalación.

Primera operación

a <- 1

Primera operación

Mi segundo objeto: definiremos otra variable llamada b y le asignaremos el valor 2

a <- 1
b <- 2

Primera operación

Mi primera operación con objetos: haremos la suma a + b y nos devolverá su resultado

a <- 1
b <- 2
a + b

[1] 3

Instalación RStudio

• RStudio es un entorno de trabajo mucho más amigable y práctico (Word). IDE: entorno integrado de desarrollo.

• Es la aplicación más utilizada para escribir el código en el lenguaje R.

• RStudio es al código R como el Word a el texto.

• Podemos descargarlo desde la web de RStudio (ahora Posit)

Instalación RStudio

Paso 1: entra la web oficial de RStudio y selecciona la descarga gratuita.

Paso 2: selecciona el ejecutable que te aparezca acorde a tu sistema operativo.

Paso 3: tras descargar el ejecutable, hay que abrirlo como otro cualquier otro y dejar que termine la instalación.

Un poco de Rstudio IDE

Scripts

Un script será el documento en el que programamos, con extensión .R donde escribiremos las órdenes. Para abrir nuestro primero script, haz click en el menú en File < New File < R Script.

Lo tendremos en una ventana adicional en Rstudio.

Tenemos varias opciones para ejecutarlo:

1. Copiar y pegar en consola.

2. Seleccionar líneas y Ctrl+Enter.

3. “Source” o activar “Source on save” a la derecha de guardar: no solo guarda sino que ejecuta el código completo.

💻 Tu turno 1

Ejecuta tu primer script: crea un script de cero, programa lo indicado debajo y ejecútalo

a <- -1

b <- 5
a * b # sin guardar
multiplicacion <- a * b # guardado

c <- # deberías asignarle el valor 3
d <- # deberías asignarle el valor -1

c <- 3
d <- -1
c / d # sin guardar
division <- c / d # guardado

x <- 5
sqrt(x)

y <- -2
abs(y)

z <- ? - ? # completa el código
z

z <- x - 5
z

Definir variables

• Una de las características interesantes de R es la capacidad de definir objetos o variables. Lo usaré indistíntamente.

• Crear una variable implica asignarle un nombre a un valor que nos permitirá usarlo como referencia más adelante.

• Una variable/objeto puede ser un número, un texto, una base de datos, un modelo…

En R se usa la flecha para asignar a un objeto un nombre:

x <- 5
# x = 5

En la mayoría de ocasiones el operador de asignar y el igual son equivalentes. Excepto: - El igual solo se puede usar para definir los argumentos de una función - La flecha de asignación se puede usar en ambas direcciones.

5 -> x

Operaciones básicas 1

Operaciones básicas 2

💻 Tu turno 2

Programa los siguientes estadísticos:

mi_vector <- c(1,2,3,4,5)

media <- sum(mi_vector)/5

sd <- sum(mi_vector-media)^2/4

Función de ayuda

• La función de ayuda help es muy útil para consultar dudas de funciones de las que conocemos su nombre a priori.

help("rnorm")

• En ocasiones, no sabemos la función que queremos usar pero sí su finalidad. Podemos hacer una búsqueda de las funciones asociadas a un determinado tema.

help.search("normal distribution")

??normal

Librerias o paquetes

install.packages("SLBDD")

library("SLBDD")

Librerias o paquetes

• Podéis ver la gran cantidad de paquetes que hay disponibles aquí.

Rbase VS tydiverse

• Hay librerías o paquetes relativamente famosos dentro de la comunidad de R para Ciencia de Datos.

• Algunos ejemplos son el conjunto de paquete de Tidyverse.

• Son de gran utilidad para el tratamiento de datos y para visualización .

Carga de datos

• Para los fines de este curso recomiendo usar la pantalla “Environment/Import Dataset” que nos guiará en la carga de datos y nos dará el código que utiliza para cargarlos.

• Unos datos bien estructurados en su formato de origen nos ayudará a que la carga sea más fácil.

• Algunos ejemplos:

Archivos CSV

# Leer un archivo CSV desde tu ordenador
datos <- read.csv("ruta/del/archivo.csv", header = TRUE, sep = ",")

Archivos Excel (librería readxl)

# Leer un archivo CSV desde tu ordenador
library(readxl)
datos <- read_excel("ruta/del/archivo.xslx")

Forma de trabajar y buenas prácticas

• Lo ideal es escribir el código en un script, archivo .R que podamos ejecutar para obtener los resultados. Es buena opción también trabajar con notebooks de Quarto.

• Es recomendable guardar nuestro entorno de trabajo en una imagen o archivo .RData.

• Es recomendable iniciar un proyecto para cada trabajo que queramos realizar. Archivo .Rproj.

Definiciones

• Objeto/variable: Un objeto es cualquier entidad que vive en el espacio de trabajo de R (puede guardarse). Cuando creas una variable, una función, un vector, un modelo, etc., estás creando un objeto. Todo en R es un objeto.

• Estructura: La forma o contenedor del objeto (vector, lista, matriz,…).

• Tipo: Qué contiene la estructura o qué es el objeto que contiene (números, caracteres, booleanos,…).

• Clase: Cómo se comporta el objeto cuando lo imprimes, lo sumas, etc. Programación orientada a objetos (OOP) de R. Las clases permiten definir métodos específicos para funciones genéricas.

• Métodos: funciones diseñadas para trabajar con una clase específica de objeto.

Objetos

Sobre los nombres de los objetos:

• se distingue entre mayúsculas y minúsculas.

• Los nombres de objetos tienen que empezar por una letra y no incluir guiones.

• Pueden contener letras, números, barra baja, e incluso espacios. Pero la recomendación es que se usen únicamente letras minúsculas y barra bajas para separar palabras.

Tipos atómicos

Tipos atómicos en R

Son los “átomos” de los datos en R, porque no se pueden dividir en partes más simples dentro del lenguaje.

R tiene seis Tipos atómicos básicos:

NA en R

En R, NA significa “Not Available” y representa un valor faltante o ausente.

• Es un valor especial, no un tipo atómico.

• Se comporta como un marcador de datos perdidos en vectores, data frames y otros objetos.

• NA adopta el tipo del objeto que lo contiene.

• Cualquier operación con un NA devuelve NA por defecto.

• Diferente a NULL (no existe) y NaN (resultado indefinido).

💻 Tu turno 3

Programa los siguientes estadísticos con NAs:

mi_vector <- c(1,2,NA,4,5)

media <- sum(mi_vector, na.rm = TRUE)/(sum(!is.na(mi_vector)))

Estructuras de datos

Las estructuras organizan los datos:

• Vector: unidimensional, homogéneo.

• Matriz: 2D, homogénea.

• Array: N-dimensional, homogénea.

• Lista: 1D, heterogénea.

• Data frame y Tibble: lista con vectores del mismo largo. Cada columna tiene el mismo tipo. Tibble es una versión moderna del data frame.

Vectores

• Unidimensional

• Homogéneo: todos los elementos del mismo tipo

v <- c(1, 2, 3)
typeof(v)  # "double"

[1] "double"

length(v)  # 3

[1] 3

Vectores: creación

Podemos generalos de diferentes formas:

c(1,2,3,4)

[1] 1 2 3 4

1:5

[1] 1 2 3 4 5

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

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

seq(from = 1, to = 3, by = 0.75)

[1] 1.00 1.75 2.50

rep(c(1, 3), times = 3)

[1] 1 3 1 3 1 3

💻 Tu turno 4

Mezclando tipos atómicos en un vector

mi_vector <- c(1,2, "Tres", 4, 5)

sum(mi_vector)

typeof(mi_vector)

Vectores: acceso

R indexa los elementos iniciando en 1

x <- 10:15

Accederemos a los elementos del vector con su posición:

x[3]

[1] 12

También podemos seleccionar varios elementos:

x[3:5]

[1] 12 13 14

o eliminar elementos:

x[-2]

[1] 10 12 13 14 15

También podemos acceder usando un vector lógico:

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

[1] 10 15

Vectores: nombres

Vectores con nombres:

x <- 10:14
names(x) <- c("Antonio", "Clara", "Jaime", "Luis")

x["Luis"]

Luis 
  13 

Matrices y arrays

• Matriz: 2 dimensiones

• Array: 3 o más dimensiones

• Ambos son homogéneos

m <- matrix(NA, nrow = 2)

a <- array(NA, dim = c(2,2,2))

Matrices

Las matrices son también vectores pero con dos atributos adicionales: número de filas y número de columnas.

Los vectores no son matrices con una fila o con una columna.

Para generar una matriz, usaremos el comando

A <- matrix(1:9, ncol = 3, nrow = 3)
A

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

Accederemos a sus elementos usando la posición de filas y columnas:

A[1,2]

[1] 4

Arrays

Un array es una matriz multidimensional.

miarray <- array(data = NA, 
                 dim = c(7, 2, 3),
                 dimnames = list(1:7,
                                 1:2,
                                 1:3))

Se acceden a los elementos de la misma forma que las matrices

miarray[1,,]

   1  2  3
1 NA NA NA
2 NA NA NA

Listas: creación

• Son objetos multidimensionales.

• Elementos pueden ser de tipos o estructuras distintas.

• Típicamente usada para representar objetos complejos (modelos, resultados, etc).

milista <- list(5, 
                "a", 
                1:10, 
                c("a", "b", "c"),
                matrix(c(2, 4, 3, 1, 5, 7), nrow = 2))

Listas: acceso

Podemos acceder a los elementos de la lista usando [i] y [[i]]. La primera devolverá una lista mientras que la segunda devolverá un objeto con la clase original del elemento i.

class(milista[5])

[1] "list"

class(milista[[5]])

[1] "matrix" "array" 

Nombres de los elementos de la lista:

milista <- list(number = 5, 
                character = "a", 
                vector = 1:10, 
                vector_character = c("a", "b", "c"),
                matrix = matrix(c(1, 2, 3, 4, 5, 6), nrow = 2))

Acceso con nombre:

milista["number"]
milista$number

Acceso con número índice:

milista[1]

💻 Tu turno 5

Acceso a listas

mean(milista[["vector"]])

[1] 5.5

milista[["vector_character"]][2]

[1] "b"

milista[["matrix"]][,2]

[1] 3 4

str(datos)

Data.frame

La estructura básica para organizar los datos es un data frame: ficheros de datos con \(n\) observaciones y \(p\) variables.

Un data frame es una es una lista de vectores atómicos (columnas), todos de la misma longitud, estructuradas como una matriz. Las columnas pueden ser de distinto tipo pero todas tienen la misma longitud.

Para crear un data frame con R se usa el comando data.frame().

💻 Tu turno 6

Crea un data.frame:

datos <- data.frame(
  nombre = c("Ana", "Luis"),       # character
  edad = c(30, 25),              # integer
  aprobado = c(TRUE, FALSE)        # logical
)

typeof(datos)  # "list"

class(datos)   # "data.frame"

str(datos)

Tibble

• Tibble: es un data frame mejorado a través de la librería .

• Mejores impresiones, no convierte strings a factores, etc.

library(tibble)
tb <- tibble(nombre = c("Ana", "Luis"), edad = c(30, 25))

Clases derivadas comunes en R

Algunos tipos de datos son clases que extienden tipos básicos:

Clases derivadas comunes en R: Factores

Útiles para manejar las variables cualitativas.

Es un vector al que se le añade un poco más de información consistente en los distintos valores presentes en el vector, llamados niveles (levels).

Se crean usando el comando factor():

interes <- c("poco", "indiferente", "poco", "mucho", "poco")
factor(interes)

[1] poco        indiferente poco        mucho       poco       
Levels: indiferente mucho poco

Clases derivadas comunes en R: Factores

Podemos ordenarlo usando el argumento levels

factor(interes, levels = c("poco", "indiferente", "mucho"))

[1] poco        indiferente poco        mucho       poco       
Levels: poco indiferente mucho

y cambiar sus etiquetas con el argumento labels

factor(interes, levels = c("poco", "indiferente", "mucho"), labels = c("0", "1", "2"))

[1] 0 1 0 2 0
Levels: 0 1 2

Clases derivadas comunes en R: Fechas

Las fechas se almacenan internamente como números:

• Date → días desde “1970-01-01”.
• POSIXct → segundos desde “1970-01-01”.

Fecha simple:

f1 <- as.Date("2024-07-19")
typeof(f1)  # "double"

[1] "double"

class(f1)   # "Date"

[1] "Date"

Fecha + hora:

f2 <- as.POSIXct("2024-07-19 12:30:00")
typeof(f2)  # "double"

[1] "double"

class(f2)   # "POSIXct" "POSIXt"

[1] "POSIXct" "POSIXt" 

# Lista detallada (componentes)
f3 <- as.POSIXlt(f2)
str(f3)     # lista con año, mes, día, hora, minuto, segundo, etc.

 POSIXlt[1:1], format: "2024-07-19 12:30:00"

Clases derivadas comunes en R: Fechas

Funciones útiles:

# Diferencias de tiempo
difftime(as.Date("2024-08-01"), f1, units = "days")  # 13 días

Time difference of 13 days

# Formato personalizado
format(f2, "%d/%m/%Y %H:%M")  # "19/07/2024 12:30"

[1] "19/07/2024 12:30"

Operaciones: Lógicas

• Comparación

2 > 3 

[1] FALSE

2 < 3

[1] TRUE

2 >= 3

[1] FALSE

2 != 3

[1] TRUE

2 == 3

[1] FALSE

2 == 2

[1] TRUE

Operaciones: Lógicas

• Lógico AND

TRUE & TRUE

[1] TRUE

TRUE & FALSE

[1] FALSE

• Lógico OR

TRUE | TRUE

[1] TRUE

TRUE | FALSE

[1] TRUE

• Funciones which()

Operaciones: Vectores

age <- c(12, 18, 22, 21, 17)

Vectorización y aritmética de vectores:

length(age)

[1] 5

age - 1

[1] 11 17 21 20 16

age2 <- age * 2

age2 + age

[1] 36 54 66 63 51

age > 20

[1] FALSE FALSE  TRUE  TRUE FALSE

💻 Tu turno 7

¿Qué está haciendo R en los siguientes ejemplos?:

mi_vector <- c(1, 2, 3, 4, 5)

mi_vector - c(1, 2)

[1] 0 0 2 2 4

1 + mi_vector

[1] 2 3 4 5 6

1 + mi_vector

[1] 2 3 4 5 6

mi_vector %in% c(1, 2)

[1]  TRUE  TRUE FALSE FALSE FALSE

match(c(1, 2), mi_vector)

[1] 1 2

which(mi_vector %in% c(1, 2))

[1] 1 2

Operador |>

• El operador |> (“entonces” o “pipe”) encadena secuencialmente acciones.

• Lo que aparece a la izquierda de este operador es el primer argumento del comando que aparece a su derecha.

• Requiere una versión de R igual o superior a 4.1.0.

💻 Tu turno 8

x1 <- 1:6

sqrt(sum((x1-mean(x1))^2))

(x1 - mean(x1))^2 |>
  sum() |>
  sqrt() 

Operaciones: Matrices

A <- matrix(1:4, nrow = 2, ncol = 2)
B <- matrix(4:1, nrow = 2, ncol = 2)

• Producto matricial:

A %*% B

     [,1] [,2]
[1,]   13    5
[2,]   20    8

• Producto componente a componente:

A*B

     [,1] [,2]
[1,]    4    6
[2,]    6    4

Operaciones: Matrices

• Determinante:

det(A)

[1] -2

• Transpuesta:

t(A)

     [,1] [,2]
[1,]    1    2
[2,]    3    4

• Obtener diagonal:

diag(A)

[1] 1 4

Operaciones: Matrices

• Inversa:

solve(A)

     [,1] [,2]
[1,]   -2  1.5
[2,]    1 -0.5

• Resolver sistema de ecuaciones \(A x = b\):

b <- c(1,2)
solve(A, b)

[1] 1 0

• Autovalores y autovectores

eigen(A)

eigen() decomposition
$values
[1]  5.3722813 -0.3722813

$vectors
           [,1]       [,2]
[1,] -0.5657675 -0.9093767
[2,] -0.8245648  0.4159736

• Descomposición de Cholesky

A <- matrix(c(4, 2, 2, 3), ncol = 2)

chol(A)

     [,1]     [,2]
[1,]    2 1.000000
[2,]    0 1.414214

Estructuras de programación: bucle for

• Bucle For:

for(i in 1:n){
  <code to repeat for each i>
}

💻 Tu turno 9

A <- matrix(1:(100*1000), nrow = 100, ncol = 1000)

media_por_columna <- c()
for(i in 1:1000){
  media_por_columna <- c(media_por_columna, mean(A[,i]))
}

Estructuras de programación: apply()

Familia apply

💻 Tu turno 10

A <- matrix(1:(100*1000), nrow = 100, ncol = 1000)

media_por_columna <- apply(A, MARGIN = 2, mean)

Estructuras de programación: condicionantes

• While:

while(condition){
  <code>
}

• Condiciones if:

if(condition){
  <code>
}

• Condiciones ifelse:

if(condition){
  <code condition>
}else{
  <code otherwise>
}

Estructuras de programación: funciones

Una función es un conjunto de instrucciones que realiza una tarea específica
y puede recibir argumentos y devolver un resultado.

my_function_name <- function(argument1 = value, argument2 = value, ...){
  <code>
  return(<what to return>)
}

• function(): palabra clave que define una función.

• argument1, argument2: Argumentos o variables que recibe.

• <code>: Cuerpo de la función, incluye el código que ejecuta.

• return(): valor que devuelve (opcional, R devuelve el último valor por defecto).

💻 Tu turno 11

mi_media <- function(x){
  
  x_no_NA <- x[!is.na(x)]
    
  media <- sum(x_no_NA)/length(x_no_NA)
  
  return(media)
}

mi_media(c(100, 2, 3))

[1] 35

mi_media(c(100, NA, 3))

[1] 51.5

mi_media(mi_vector)

[1] 3

A <- matrix(1:(100*1000), nrow = 100, ncol = 1000)

media_por_columna <- apply(A, MARGIN = 2, mi_media)