Práctica 1

Instalación y uso de R / RStudio (Posit)

Author

Dr. Jorge Párraga Álava

Minería de datos

Preliminares

Algo de historia

R fue creado en 1993 como un entorno para el análisis estadístico y gráfico por Roberth Gentleman y Ross Ihaka, de la Universidad de Auckland en Nueva Zelanda.

A partir de 1997 su desarrollo (R-base) es llevado por un grupo de programadores conocido como “The R-core team”. En la actualidad, los usuarios pueden publicar paquetes que extienden la funcionalidad básica de R en distintas áreas. Existe un repositorio oficial de paquetes llamado: Comprehensive R Archive Network (CRAN).

En 2026, R continúa siendo uno de los lenguajes más utilizados en ciencia de datos, estadística y aprendizaje automático, con más de 21.000 paquetes disponibles en CRAN y una comunidad global muy activa.

¿Por qué usar R?

  • R es software libre 😁 al distribuirse bajo licencia GNU GPL.

  • R es multiplataforma 💻, disponible para Windows, macOS y GNU/Linux.

  • La sintaxis es simple e intuitiva 🤑 y con buena variedad de funciones gráficas 📊, incluyendo el ecosistema ggplot2 y visualizaciones interactivas con plotly o shiny.

  • R es extensible 📝 mediante funciones y paquetes 📦 que son publicados por los usuarios.

  • La comunidad de R es muy prolífica 💬 y colaborativa 🤝: R-bloggers, Posit Community, etc.

  • Cada vez más usado 📈, no sólo en la academia, sino también en el mundo empresarial por gigantes como Google, Microsoft, Meta, Amazon, etc., y fuertemente integrado con herramientas de IA y aprendizaje automático.

  • Desde 2022, RStudio pasó a llamarse oficialmente Posit, ampliando su soporte también a Python y otras herramientas de ciencia de datos.

Instalación de R

⚠️ Nota (2026): La versión actual de R es la 4.4.x. Se recomienda instalar siempre la versión más reciente desde CRAN.

Windows

  1. Ingrese a https://cran.r-project.org/ y seleccione el vínculo “Download R for Windows”.

  1. Haga clic en el vínculo “base”. Seleccione la opción “Download R-4.4.x for Windows” (la versión más reciente disponible), descargue el instalador.

  1. Con el instalador descargado, realice la instalación con las opciones predeterminadas.

  2. Una vez finalizada la instalación abra R y observará la siguiente interfaz:

Instalación de R en Ubuntu / Debian

Para instalar la última versión de R en Ubuntu 22.04 / 24.04 (versiones LTS recomendadas en 2026), utilice los siguientes comandos actualizados. El método con apt-key ya está obsoleto; se debe usar gpg:

# Instalar dependencias necesarias
sudo apt update
sudo apt install -y software-properties-common dirmngr wget

# Agregar la clave GPG oficial de CRAN
wget -qO- https://cloud.r-project.org/bin/linux/ubuntu/marutter_pubkey.asc \
  | sudo gpg --dearmor -o /usr/share/keyrings/r-project.gpg

# Agregar el repositorio de CRAN
echo "deb [signed-by=/usr/share/keyrings/r-project.gpg] \
  https://cloud.r-project.org/bin/linux/ubuntu $(lsb_release -cs)-cran40/" \
  | sudo tee /etc/apt/sources.list.d/r-project.list

# Instalar R
sudo apt update
sudo apt install -y r-base r-base-dev

Luego de ello, podrá ejecutar R desde la terminal escribiendo el comando R:

Instalación de R en macOS

En macOS, la forma recomendada en 2026 es instalar R mediante el instalador oficial de CRAN o usando Homebrew:

# Usando Homebrew (recomendado)
brew install r

# O descargue el instalador .pkg desde:
# https://cran.r-project.org/bin/macosx/

💡 En Mac con chip Apple Silicon (M1/M2/M3/M4), asegúrese de descargar la versión arm64 de R para máximo rendimiento.

Instalación de RStudio (Posit)

La interfaz de usuario de R no es muy amigable ni versátil. Por ello, interactuaremos con R a través de RStudio, ahora llamado oficialmente Posit desde 2022. Es una interfaz que facilita muchas de las tareas de programación y análisis de datos en R (y también en Python).

⚠️ Nota (2026): Posit ofrece dos entornos: RStudio Desktop (local) y Posit Cloud (en la nube, sin instalación). Para este curso usaremos RStudio Desktop.

  1. Vaya a la página de descarga de Posit.

  1. Seleccione y descargue la versión de RStudio Desktop gratuita según su sistema operativo (Windows, macOS o Linux).

  1. Ejecute el instalador recién descargado y realice los pasos siguientes:

    • Paso 1.

    • Paso 2.

    • Paso 3.

    • Paso 4.

    • Paso 5.

Si abrimos RStudio vamos a ver algo parecido a lo que se muestra en la imagen:

💡 Alternativa en la nube: Si no desea instalar nada, puede usar Posit Cloud directamente desde su navegador con una cuenta gratuita.

Instalación de Rtools

En Windows, para compilar paquetes en R (4.0.0 o superior) es necesario instalar Rtools, que incluye el compilador GCC y otras herramientas de desarrollo.

⚠️ Nota (2026): La versión actual es Rtools44 (para R 4.4.x). Verifique siempre que la versión de Rtools coincida con su versión de R.

  1. Haga clic aquí y descargue Rtools44.

  1. Ejecute el asistente de instalación y realice los pasos siguientes:

    • Paso 1.

    • Paso 2.

    • Paso 3.

    • Paso 4.

    • Paso 5.

  2. Abrimos RStudio y en la consola verificamos que Rtools esté disponible:

# Verificar disponibilidad de Rtools (R 4.4.x)
pkgbuild::has_build_tools(debug = TRUE)

💡 En versiones recientes de Rtools (44+), ya no es necesario modificar manualmente el archivo .Renviron como se hacía antes. La instalación configura el PATH automáticamente.

  1. Finalmente, en la consola escribir:
Sys.which("make")

Deberá obtener el siguiente mensaje:

           make 
"/usr/bin/make"

En Linux, no es necesario instalar Rtools, pero sí algunas bibliotecas de desarrollo del sistema:

# Ubuntu / Debian
sudo apt install -y libcurl4-openssl-dev libssl-dev libxml2-dev \
  libfontconfig1-dev libharfbuzz-dev libfribidi-dev \
  libfreetype6-dev libpng-dev libtiff5-dev libjpeg-dev

En macOS, las herramientas de compilación se instalan con:

xcode-select --install

Empezar a trabajar con R

Creación de Proyectos

Los proyectos en RStudio son una forma de organizar nuestros archivos y mantener entornos de trabajo reproducibles.

  • Para crear un proyecto en RStudio, se debe hacer clic en el menú "File" -> "New Project" -> "New Directory" -> "New Project".

  • Ingrese el nombre del directorio para guardar su proyecto, por ejemplo: “Curso-MD”, y clic en "Create Project".

  • Una vez creado el proyecto, genere la siguiente estructura de directorios, dirigiéndose al panel Files (ventana inferior derecha de RStudio), en la pestaña "Files" y luego clic en "New Folder".

  • Todas las operaciones por código que se realicen deben ser guardadas dentro de la carpeta Scripts. Estos archivos deben tener la extensión .R

💡 Buena práctica (2026): Se recomienda usar también archivos Quarto (.qmd) para documentar el análisis de forma reproducible, combinando código R con texto explicativo. Quarto reemplaza a R Markdown como estándar en 2026.

Paquetes en R

Un paquete (package en inglés) es simplemente un conjunto de funciones, datos y documentación disponible para usar en R. Cuando abrimos RStudio, se cargan automáticamente paquetes de R-base. Puedes ver sus nombres tecleando en la consola loadedNamespaces().

R, en su repositorio oficial CRAN, dispone de más de 21.000 paquetes (2026). Además, existen repositorios alternativos como Bioconductor (bioinformática) y GitHub (paquetes en desarrollo).

Para instalar un paquete desde la consola use install.packages("nombre_paquete").

Para instalar en modo gráfico diríjase al panel de Files/Packages, en la pestaña Packages, luego en Install, escriba el nombre del paquete y clic en Install.

Para cargar un paquete previamente instalado use library("nombre_paquete").

💡 Nuevo en 2026: El paquete pak es ahora la forma recomendada de instalar paquetes, ya que es más rápido y gestiona dependencias de manera más eficiente:

install.packages("pak")
pak::pkg_install("nombre_paquete")

Ejemplo:

Instalemos el paquete igraph que se utiliza para manipular/gestionar grafos:

install.packages("igraph")

Una vez instalado, cargue el paquete con la instrucción:

library("igraph")

Para no reinstalar paquetes ya instalados use:

if(!require(igraph)) {install.packages("igraph")}

Ayuda en R

Hay varias formas de pedir la ayuda de R.

  • Para ayuda de funciones use help(sum) o ?sum. Esto muestra la documentación de ayuda de la función sum.

  • Para ayuda de paquetes use library(help="stats"). Esto muestra la documentación de ayuda del paquete stats.

  • Para ver las vignettes de un paquete, use vignette("dplyr"). Esto muestra las viñetas del paquete dplyr.

  • En RStudio 2026, la pestaña “Help” del panel inferior derecho permite buscar documentación de forma interactiva.

  • También puede consultar documentación en línea en https://rdrr.io/ o https://www.rdocumentation.org/.

Programación en R

Variables y tipos de datos

El símbolo <- es el operador para asignar valores a las variables. También se puede utilizar =.

  variable1 <- 5000
  variable1
[1] 5000
  variable2 <- "FCI"
  variable2
[1] "FCI"

El símbolo # se utiliza para introducir un comentario. Todo lo que quede a la derecha de # no se ejecutará.

  # esto es un comentario
  variable3 <- TRUE
  variable3
[1] TRUE

Las variables en R pueden almacenar los siguientes tipos de datos.

  variable1 <- 12.34 #numérico
  variable2 <- "UTM" #caracter
  variable3 <- FALSE #lógico
  variable4 <- 4L #entero, agrega L al valor numérico
  variable5 <- factor(c("hombre", "mujer", "mujer", "mujer", "hombre", "mujer"), 
                      levels = c("hombre", "mujer")) 
                      #factor sin orden
  variable6 <- factor(c("alto", "bajo", "bajo", "medio", "alto"), 
                      levels = c("bajo", "medio", "alto"),
                      ordered = TRUE) 
                      #factor con orden

Para conocer el tipo de variable, se utiliza la función class.

  class(variable4) 
[1] "integer"

Para probar si el objeto es de un tipo de dato particular:

  is.integer(variable1)
[1] FALSE
  is.character(variable1)
[1] FALSE
  is.factor(variable1)
[1] FALSE
  is.logical(variable3)
[1] TRUE

Para visualizar objetos en R, usamos cat() o print().

  cat(variable2)
UTM
  print(variable6)
[1] alto  bajo  bajo  medio alto 
Levels: bajo < medio < alto

Operadores

En R, los operadores son símbolos especiales que realizan operaciones específicas en uno o más valores. Entender estos operadores es fundamental para programar eficazmente en R.

Operadores Aritméticos

Los operadores aritméticos realizan operaciones matemáticas básicas.

# Suma
5 + 3
[1] 8
# Resta
10 - 4
[1] 6
# Multiplicación
6 * 2
[1] 12
# División
15 / 3
[1] 5
# Potenciación
2 ^ 3
[1] 8
# División entera
17 %/% 5
[1] 3
# Módulo (resto de la división)
17 %% 5
[1] 2

Operadores de Comparación

Estos operadores comparan valores y devuelven un resultado booleano (TRUE o FALSE).

# Igual a
5 == 5
[1] TRUE
# No igual a
5 != 4
[1] TRUE
# Mayor que
10 > 5
[1] TRUE
# Menor que
3 < 7
[1] TRUE
# Mayor o igual que
10 >= 10
[1] TRUE
# Menor o igual que
5 <= 6
[1] TRUE

Operadores Lógicos

Los operadores lógicos se utilizan para combinar condiciones.

# AND lógico
TRUE & FALSE
[1] FALSE
# OR lógico
TRUE | FALSE
[1] TRUE
# NOT lógico
!TRUE
[1] FALSE

Operadores Especiales

R tiene algunos operadores especiales para tareas específicas.

# Operador de secuencia
1:5
[1] 1 2 3 4 5
# Operador de pertenencia
5 %in% c(1, 3, 5, 7, 9)
[1] TRUE
# Operador de multiplicación de matrices
matrix(1:4, 2, 2) %*% matrix(5:8, 2, 2)
     [,1] [,2]
[1,]   23   31
[2,]   34   46

💡 Nuevo en R 4.1+: El operador nativo de tubería |> permite encadenar operaciones sin necesidad de cargar magrittr:

c(1, 4, 9, 16) |> sqrt() |> sum()

Estructuras de datos

R ofrece una variedad de estructuras de datos que permiten almacenar y manipular información de manera eficiente.

Vectores

Los vectores son la estructura de datos más básica en R. Contienen elementos del mismo tipo.

# Vector numérico
numeros <- c(1, 2, 3, 4, 5)
print(numeros)
[1] 1 2 3 4 5
# Vector de caracteres
frutas <- c("manzana", "banana", "cereza")
print(frutas)
[1] "manzana" "banana"  "cereza" 
# Vector lógico
logico <- c(TRUE, FALSE, TRUE, TRUE)
print(logico)
[1]  TRUE FALSE  TRUE  TRUE

Matrices

Las matrices son arreglos bidimensionales que contienen datos del mismo tipo.

# Crear una matriz
m <- matrix(1:9, nrow = 3, ncol = 3)
print(m)
     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9
# Acceder a elementos
print(m[2, 3])  # Elemento en la fila 2, columna 3
[1] 8

También es posible crear una matriz a partir de la una unión de vectores. La función cbind() une columnas (vectores) en una matriz. Mientras que rbind() une filas (vectores).

Ahora crearemos una matriz con pesos y altura de personas, a partir de dos vectores:

peso <- c(68, 70, 80, 76) 
altura <- c(165, 169, 175, 170)
# Crear matriz a partir de dos vectores
matriz <- cbind(peso, altura)
matriz
     peso altura
[1,]   68    165
[2,]   70    169
[3,]   80    175
[4,]   76    170

Arrays

Los arrays son similares a las matrices, pero pueden tener más de dos dimensiones.

# Crear un array tridimensional
arr <- array(1:24, dim = c(2, 3, 4))
print(arr)
, , 1

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

, , 2

     [,1] [,2] [,3]
[1,]    7    9   11
[2,]    8   10   12

, , 3

     [,1] [,2] [,3]
[1,]   13   15   17
[2,]   14   16   18

, , 4

     [,1] [,2] [,3]
[1,]   19   21   23
[2,]   20   22   24

Listas

Las listas pueden contener elementos de diferentes tipos, incluyendo otras listas.

# Crear una lista
mi_lista <- list(nombre = "Juan", edad = 30, notas = c(90, 85, 88))
print(mi_lista)
$nombre
[1] "Juan"

$edad
[1] 30

$notas
[1] 90 85 88
# Acceder a elementos de la lista
print(mi_lista$nombre)
[1] "Juan"
print(mi_lista[[2]])
[1] 30
print(mi_lista$notas[2])
[1] 85

Data Frames

Los data frames son similares a las tablas en una base de datos relacional. Son listas de vectores de igual longitud.

# Crear un data frame
df <- data.frame(
  nombre = c("Ana", "Jorge", "Carlos"),
  edad = c(25, 30, 35),
  ciudad = c("Portoviejo", "Guayaquil", "Santiago")
)
print(df)
  nombre edad     ciudad
1    Ana   25 Portoviejo
2  Jorge   30  Guayaquil
3 Carlos   35   Santiago
# Acceder a columnas
print(df$nombre)
[1] "Ana"    "Jorge"  "Carlos"
# Acceder a filas
print(df[2, ])
  nombre edad    ciudad
2  Jorge   30 Guayaquil

💡 Buena práctica (2026): Para manipulación avanzada de data frames se recomienda usar el paquete dplyr del ecosistema tidyverse, que ofrece una sintaxis más clara y eficiente.

Factores

Los factores se utilizan para representar datos categóricos.

# Crear un factor
niveles_educacion <- factor(c("Primaria", "Secundaria", "Universidad", "Primaria", "Universidad"))
print(niveles_educacion)
[1] Primaria    Secundaria  Universidad Primaria    Universidad
Levels: Primaria Secundaria Universidad
# Ver niveles
print(levels(niveles_educacion))
[1] "Primaria"    "Secundaria"  "Universidad"

Estructuras de control

Las estructuras de control permiten ejecutar código de manera condicional o repetitiva. En R se las puede usar de la siguiente forma:

If-Else

La estructura if-else permite ejecutar código basado en condiciones.

x <- 7
if (x > 5) {
  print("x es mayor que 5")
} else if (x < 5) {
  print("x es menor que 5")
} else {
  print("x es igual a 5")
}
[1] "x es mayor que 5"

For Loop

El bucle for se utiliza para iterar sobre una secuencia de elementos.

for (i in 1:5) {
  print(paste("Número:", i))
}
[1] "Número: 1"
[1] "Número: 2"
[1] "Número: 3"
[1] "Número: 4"
[1] "Número: 5"

While Loop

El bucle while se ejecuta mientras una condición sea verdadera.

contador <- 1
while (contador <= 5) {
  print(paste("Contador:", contador))
  contador <- contador + 1
}
[1] "Contador: 1"
[1] "Contador: 2"
[1] "Contador: 3"
[1] "Contador: 4"
[1] "Contador: 5"

Repeat Loop

El bucle repeat se ejecuta indefinidamente hasta que se encuentra una instrucción break.

x <- 1
repeat {
print(x)
x = x+1
if (x == 6){
break
}
}
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5

Funciones

Las funciones en R son objetos que encapsulan un conjunto de instrucciones que realizan una tarea específica.

Definición de funciones

# Función simple
saludar <- function(nombre) {
  paste("Hola,", nombre, "!")
}

# Usar la función
print(saludar("FCI"))
[1] "Hola, FCI !"

Funciones con argumentos por defecto

potencia <- function(base, exponente = 2) {
  base ^ exponente
}

print(potencia(3))    # Usa el exponente por defecto (2)
[1] 9
print(potencia(3, 3)) # Especifica un exponente diferente
[1] 27

Funciones con número variable de argumentos

suma_variable <- function(...) {
  args <- list(...)
  sum(unlist(args))
}

print(suma_variable(1, 2, 3))
[1] 6
print(suma_variable(1, 2, 3, 4, 5))
[1] 15

Funciones anónimas

R permite crear funciones sin nombre, útiles para operaciones rápidas.

numeros <- 1:5
cuadrados <- sapply(numeros, function(x) x^2)
print(cuadrados)
[1]  1  4  9 16 25

💡 Nuevo en R 4.1+: Sintaxis abreviada \(x) para funciones anónimas:

cuadrados <- sapply(1:5, \(x) x^2)

Funciones como argumentos

En R, las funciones pueden ser pasadas como argumentos a otras funciones.

aplicar_funcion <- function(f, x) {
  f(x)
}

doble <- function(x) x * 2
triple <- function(x) x * 3

print(aplicar_funcion(doble, 5))
[1] 10
print(aplicar_funcion(triple, 5))
[1] 15

Carga de funciones desde un Script externo

Primero, creemos un nuevo script R llamado funciones_utiles.R con algunas funciones:

# Contenido de funciones_utiles.R

calcular_promedio <- function(numeros) {
  sum(numeros) / length(numeros)
}

fahrenheit_a_celsius <- function(fahrenheit) {
  (fahrenheit - 32) * 5/9
}

saludar <- function(nombre) {
  paste("¡Hola,", nombre, "! Bienvenido/a.")
}

Hay varias formas de cargar funciones desde un script externo:

  1. Usando source()
source("funciones_utiles.R")

# Ahora podemos usar las funciones
print(calcular_promedio(c(10, 20, 30)))
print(fahrenheit_a_celsius(98.6))
print(saludar("FCI"))
  1. Usando sys.source()

Esta función es similar a source(), pero ejecuta el script en un nuevo entorno:

env <- new.env()
sys.source("funciones_utiles.R", envir = env)

# Para usar las funciones, necesitamos referenciar el entorno
print(env$calcular_promedio(c(10, 20, 30)))
print(env$fahrenheit_a_celsius(98.6))
print(env$saludar("Juan"))
  1. Cargando funciones específicas

Si solo necesitamos algunas funciones del script, podemos cargarlas individualmente:

source("funciones_utiles.R")
calcular_promedio <- get("calcular_promedio")

# Ahora podemos usar la función cargada
print(calcular_promedio(c(15, 25, 35)))

Referencias