Sesión 1
Primeros pasos en R y RStudio
Juan David Leongómez
Universidad El Bosque
3 de junio de 2026
El sitio del curso
Aquí encontrarás todo el material del curso:
- Diapositivas de cada sesión
- Archivos de datos y materiales para las actividades
- Descripciones detalladas de los retos
Ábrelo ahora en tu computador (o teléfono).
Agenda
- ¿Qué es un lenguaje de programación y qué es R?
- FOSS y ciencia abierta
- El ecosistema de paquetes: CRAN
- Scripts y el entorno RStudio
- Funciones, argumentos y objetos
- Primera figura con
ggplot2
R y los lenguajes de programación
Programas con interfaz vs. código
Programa con interfaz gráfica (GUI)
- Haces clic en botones y menús
- Solo puedes hacer lo que el programa ya tiene implementado
- Cambias un parámetro → repites el proceso completo a mano
- Difícil de compartir exactamente lo que hiciste
Ejemplos: Excel, SPSS, GraphPad
Lenguaje de programación
- Le das instrucciones escritas al computador
- Puedes hacer (casi) cualquier cosa que el computador pueda hacer
- Cambias una línea → todo se recalcula solo
- Puedes compartir exactamente qué hiciste, paso a paso
Ejemplos: R, Python, Julia
¿Qué es R?
R es un lenguaje de programación diseñado para el análisis estadístico y la visualización de datos.
- Gratuito y de código abierto (FOSS)
- Creado en 1993 por Ross Ihaka y Robert Gentleman (Universidad de Auckland)
- Mantenido por el R Core Team y una comunidad global enorme
- Estándar de facto en muchas disciplinas científicas
R es un lenguaje completo con acceso a todos los recursos del computador: análisis estadístico, manejo de archivos, conexión a internet, generación de documentos, aplicaciones web, y mucho más.
¿Qué se puede hacer con R? Algunos ejemplos
📊 Análisis estadístico
Desde estadística básica hasta modelos bayesianos, machine learning y simulaciones complejas.
📈 Visualizaciones publicables
Gráficas listas para revistas científicas, totalmente personalizables y reproducibles.
📄 Documentos y reportes
Artículos, informes y presentaciones donde el texto y los resultados se generan juntos.
→ este sitio del curso y estas diapositivas son ejemplos
📋 CVs y portfolios
Documentos con formato profesional generados directamente desde R.
→ ejemplo: mi CV
🌐 Aplicaciones web interactivas
Apps que cualquier persona puede usar desde el navegador, sin instalar nada.
→ ejemplo: app Shiny
💻 Sitios web completos
Sitios personales, blogs y portafolios académicos publicados directamente desde R.
→ ejemplo: mi sitio web
FOSS y ciencia abierta
FOSS = Free and Open Source Software
“Free” en FOSS significa libre:
- Cualquiera puede ver el código fuente y verificar qué hace exactamente
- Cualquiera puede modificarlo y mejorarlo
- No depende de una empresa que puede cambiar precios o descontinuarlo
¿Por qué importa para la ciencia?
Un análisis en R es reproducible: el script documenta cada paso, y cualquier persona puede replicar tus resultados exactamente.
CRAN: el repositorio central de paquetes
El verdadero poder de R viene de los paquetes: colecciones de funciones creadas por la comunidad que amplían R base.
CRAN (Comprehensive R Archive Network) es el repositorio oficial:
- cran.r-project.org
- Más de 23 000 paquetes disponibles
- Cada día se publican o actualizan decenas
Demo en vivo: veamos cuántos paquetes hay hoy y cuáles se actualizaron recientemente.
Muchos paquetes también viven en GitHub y se instalan con herramientas adicionales.
De la terminal al script
Puedes darle instrucciones a R directamente desde la terminal:
Funciona, pero al cerrar la terminal pierdes todo lo que escribiste.
De la terminal al script
Un script es un archivo de texto plano con extensión .R; la extensión indica al sistema operativo que lo abra con R, y cualquier editor puede abrirlo.
# mi_primer_script.R
2 + 2
sqrt(16)
El script es tu registro permanente de lo que hiciste. Es la base de la reproducibilidad científica.
R sin IDE: ventanas sueltas
R funciona solo, pero cada pieza vive en su propia ventana flotante: consola, editor de scripts, gráficas, entorno… Todo disperso.
RStudio: el entorno de trabajo
R es el perro. RStudio es la pinta: un IDE (Integrated Development Environment) que facilita el trabajo: todo lo que ejecutas en RStudio lo procesa R internamente.
RStudio: el entorno de trabajo
R es el perro. RStudio es la pinta: un IDE (Integrated Development Environment) que facilita el trabajo: todo lo que ejecutas en RStudio lo procesa R internamente.
- Editor de scripts con resaltado de sintaxis
- Consola integrada
- Visualizador de objetos, gráficas, archivos y ayuda
- Integración con Quarto/RMarkdown, Git, y más
Los paneles de RStudio
A. Editor — escribes y guardas tus scripts
B. Consola — R ejecuta el código aquí
C. Entorno / Historial — objetos en memoria
D. Archivos / Gráficas / Ayuda — explorador y visualizador
Configura RStudio
Abre RStudio y ve a Tools > Global Options
General > Basic
- Desmarca Restore most recently opened project at startup
- Desmarca Restore previously open source documents at startup
- Desmarca Restore .RData into workspace at startup
- En Save workspace to .RData on exit selecciona Never
- Desmarca Always save history
Code > Editing
- Marca Use native pipe operator
|>
Code > Display
- Marca Use rainbow parentheses
Code > Saving
- Default text encoding:
UTF-8
Appearance
- Escoge el tema y la fuente que más te gusten
Comentarios: #
Todo lo que sigue a # en una línea es ignorado por R (es un mensaje para humanos).
# Calcular el índice de masa corporal
peso <- 70 # kg
altura <- 1.75 # metros
imc <- peso / altura^2
# Resultado
imc
Los comentarios son para ti dentro de seis meses, para tu colaboradora, y para cualquiera que quiera entender o reproducir tu análisis.
Un buen comentario explica qué hace un código, y/o por qué se hizo algo.
¡No olvides comentar tus scripts! Es parte de la buena práctica de programación y ciencia abierta.
Un script bien organizado y comentado
⬇ Descargar script
# =========================================================
# Ejemplo de script organizado y comentado en R
# =========================================================
# ---------------------------------------------------------
# 1. Cargar paquetes necesarios
# ---------------------------------------------------------
library(ggplot2) # visualización
library(dplyr) # manipulación de datos
# ---------------------------------------------------------
# 2. Crear un conjunto de datos de ejemplo
# ---------------------------------------------------------
# Fijar semilla para que los resultados sean reproducibles
set.seed(123)
# Crear datos simulados
datos <- tibble(
participante = 1:20,
puntaje = rnorm(20, mean = 75, sd = 10),
grupo = rep(c("Control", "Experimental"), each = 10)
)
# ---------------------------------------------------------
# 3. Resumen descriptivo
# ---------------------------------------------------------
# Calcular promedio y desviación estándar de puntajes por grupo
resumen <- datos |>
group_by(grupo) |>
summarise(
promedio = mean(puntaje),
desviacion = sd(puntaje)
)
print(resumen)
# ---------------------------------------------------------
# 4. Visualización
# ---------------------------------------------------------
# Crear gráfico de distribución de puntajes por grupo
colores <- c("Control" = "#225faa", "Experimental" = "#6b1220")
ggplot(datos, aes(x = grupo, y = puntaje, fill = grupo, colour = grupo)) +
geom_violin(alpha = 0.2, width = 0.7, linewidth = 0.4) +
geom_boxplot(width = 0.12, alpha = 0.8, outlier.shape = NA, linewidth = 0.6) +
geom_jitter(width = 0.07, size = 2.8, alpha = 0.75) +
stat_summary(fun = mean, geom = "point", shape = 23,
size = 4.5, fill = "white", colour = "grey25") +
scale_fill_manual(values = colores) +
scale_colour_manual(values = colores) +
labs(
title = "Distribución de puntajes por grupo",
subtitle = "Cada punto = un participante · El rombo señala la media grupal",
x = NULL, y = "Puntaje", caption = "Datos simulados · set.seed(123)"
) +
theme_minimal(base_size = 14) +
theme(
legend.position = "none",
panel.grid.major.x = element_blank(),
panel.grid.minor = element_blank(),
plot.title = element_text(face = "bold", size = 16),
plot.subtitle = element_text(colour = "grey50", size = 11),
axis.text.x = element_text(size = 13, face = "bold")
)
Funciones y argumentos
Una función es como una fábrica: recibe insumos, hace algo con ellos, y produce un resultado.
Funciones y argumentos
ARGUMENTOS (insumos)
material = "cuero"
talla = 42
color = "azul"
→
→
Funciones y argumentos
En R, la sintaxis es siempre:
nombre_funcion(argumento1 = valor1, argumento2 = valor2)
El nombre de la función va antes del paréntesis.
Los argumentos van dentro del paréntesis, separados por comas.
Funciones en R
# sqrt() calcula la raíz cuadrada - recibe un número
sqrt(144)
# round() redondea - recibe un número y los decimales deseados
round(3.14159, digits = 2)
# paste() une texto - recibe los fragmentos y el separador
paste("Hola", "mundo", sep = ", ")
Escribe el nombre de cualquier función seguido de ? en la consola para ver su documentación: ?round
Objetos: la memoria de trabajo de R
Cuando usas <- para asignar, guardas el resultado en un objeto.
🧠 OBJETOS (RAM)
Existen mientras R está abierto.
Rápidos de usar.
Se pierden al cerrar la sesión.
💾 ARCHIVOS (disco)
Permanentes.
Los lees con funciones como read.csv().
No cambian solos.
resultado <- sqrt(144) # guardamos, no imprimimos
resultado # ahora sí lo vemos
Reglas para nombres de objetos: sin espacios, sin acentos, no empezar con número, distingue mayúsculas (datos ≠ Datos). Convención en tidyverse: snake_case.
Vectores: el tipo de dato básico
c() (combine) crea vectores: secuencias de valores del mismo tipo.
# Vector numérico
edades <- c(25, 31, 19, 42)
edades
# Vector de texto (caracteres entre comillas)
nombres <- c("Ana", "Luis", "Sara", "Pedro")
nombres
[1] "Ana" "Luis" "Sara" "Pedro"
Todo en R es, en el fondo, un vector.
Data frames: la base de datos en R
Un data frame es una tabla: una colección de vectores de igual longitud.
personas <- data.frame(
nombre = nombres,
edad = edades
)
personas
nombre edad
1 Ana 25
2 Luis 31
3 Sara 19
4 Pedro 42
Es la estructura más común para datos: filas son observaciones, columnas son variables.
Primera figura con ggplot2
Instalar y cargar ggplot2
ggplot2 es el paquete que usaremos para crear gráficas. Antes de usarlo hay que instalarlo una sola vez, y cargarlo cada sesión.
# Solo la primera vez (instala en el disco)
install.packages("ggplot2")
# Cada sesión (carga en memoria)
library(ggplot2)
install.packages() es como comprar un libro y ponerlo en el estante. library() es como abrirlo y tenerlo en la mesa.
El conjunto de datos diamonds
diamonds viene incluido con ggplot2. Contiene información de 53 940 diamantes.
ggplot2: el lienzo
ggplot() crea un lienzo. Definimos qué datos usar y qué variables mapear a los ejes con aes().
ggplot(
data = diamonds,
mapping = aes(x = carat, y = price)
)
+ puntos
Añadimos una capa geométrica con geom_point().
ggplot(diamonds, aes(x = carat, y = price)) +
geom_point()
+ transparencia (alpha)
Con tantos puntos hay sobreposición. alpha controla la transparencia (0 = invisible, 1 = sólido).
ggplot(diamonds, aes(x = carat, y = price)) +
geom_point(alpha = 0.05)
+ color por variable
Mapeamos colour a cut dentro de aes() para colorear por grupo.
ggplot(
diamonds,
aes(x = carat, y = price, colour = cut)
) +
geom_point(alpha = 0.1)
+ tema
Los temas controlan la apariencia general. theme_minimal() es un buen punto de partida.
ggplot(
diamonds,
aes(x = carat, y = price, colour = cut)
) +
geom_point(alpha = 0.1) +
theme_linedraw()
+ paleta de colores
Viridis tiene tres variantes según el tipo de variable mapeada, y dos funciones según la estética usada.
ggplot(
diamonds,
aes(x = carat, y = price, colour = cut)
) +
geom_point(alpha = 0.1) +
theme_minimal() +
scale_colour_viridis_d(option = "magma")
cut es categórica → _d (discrete). Usa scale_colour_* cuando el mapping es colour =, y scale_fill_* cuando es fill =.
Viridis: _d, _c y _b
Cuando la variable es numérica continua, usa _c (gradiente suave) o _b (intervalos discretos).
# sin tema ni paleta
ggplot(
faithfuld,
aes(waiting, eruptions, fill = density)
) +
geom_tile()
ggplot(
faithfuld,
aes(waiting, eruptions, fill = density)
) +
geom_tile() +
scale_fill_viridis_c(option = "plasma")
ggplot(
faithfuld,
aes(waiting, eruptions, fill = density)
) +
geom_tile() +
scale_fill_viridis_b(option = "plasma")
+ etiquetas con labs()
labs() controla todos los textos de la figura: título, subtítulo, ejes y leyenda.
ggplot(
diamonds,
aes(x = carat, y = price, colour = cut)
) +
geom_point(alpha = 0.1) +
theme_minimal() +
scale_colour_viridis_d(option = "magma") +
labs(
title = "Precio según peso del diamante",
subtitle = "Color según calidad del corte",
caption = "Fuente: conjunto de datos diamonds (ggplot2)",
x = "Peso (quilates)",
y = "Precio (USD)",
colour = "Corte"
)
Partiendo del código que acabamos de ver, cambia al menos dos cosas:
- Las variables en
x y/o y (prueba depth, table, carat, price)
- La variable de color (
cut, color, clarity)
¿Qué relaciones encuentras?
¿Con qué datos seguir practicando?
ggplot2 y tidyverse incluyen varias bases de datos listas para usar:
# Ver todas las bases de datos disponibles en los paquetes cargados
data()
# Algunos interesantes
glimpse(mpg) # autos y consumo de combustible
glimpse(gapminder::gapminder) # esperanza de vida por país y año
Escribe ?mpg, ?diamonds o ?[nombre_de_los_datos] en la consola para ver la descripción completa de cualquier base de datos.
Quiz · 1 de 5
R y RStudio son básicamente lo mismo; solo cambia el nombre.
- Verdad: RStudio es el nombre oficial de R desde 2011
- Verdad: son el mismo programa con dos interfaces
- Falso: R es el lenguaje; RStudio es un entorno que facilita trabajar con R
- Falso: R fue reemplazado por RStudio en 2015
✓ c) R es el motor (el perro); RStudio es la pinta: un entorno cómodo para escribir y organizar código (sin R no hace nada).
![]()
Quiz · 2 de 5
¿Qué es sqrt en este código?
- Un argumento: es el valor que se le pasa a la operación
- Una función: es la instrucción que le damos a R
- Un objeto: es un resultado guardado en memoria
- Un operador: como
+ o <-
✓ b) sqrt es una función: una instrucción con nombre que recibe insumos y produce un resultado. 144 es su argumento.
Quiz · 3 de 5
¿Qué es digits = 2 en este código?
round(3.14159, digits = 2)
- Una función: calcula el número de decimales
- Un objeto: guarda el valor 2 en memoria
- Un argumento: le indica a
round() cuántos decimales conservar
- Un operador: asigna 2 a la variable
digits
✓ c) digits = 2 es un argumento: un parámetro (es este caso con nombre “digits”) que modifica el comportamiento de la función. digits es el nombre del argumento; 2 es su valor.
Quiz · 4 de 5
¿Qué hace <- en este código?
- Compara si
resultado y sqrt(144) son iguales
- Imprime el resultado de
sqrt(144) en pantalla
- Define una función nueva llamada
resultado
- Guarda el resultado de
sqrt(144) en un objeto llamado resultado
✓ d) <- es el operador de asignación: evalúa lo que está a la derecha y guarda el resultado en el objeto nombrado a la izquierda. Después puedes usar resultado en cualquier parte del código.
Quiz · 5 de 5
¿Qué tipo de cosa es aes(x = carat, y = price) aquí?
ggplot(diamonds, aes(x = carat, y = price))
- Un data frame: contiene los datos de
diamonds
- Una capa geométrica: define cómo se dibujan los puntos
- Un argumento de
ggplot() que a su vez es una función
- El nombre del tema visual de la figura
✓ c) aes() es una función (tiene nombre y paréntesis), pero aquí aparece dentro de ggplot() como uno de sus argumentos. En R, pasar funciones como argumentos de otras funciones es completamente normal ¡y hace que sea poderosísimo!
A practicar
Antes de la próxima sesión, elige un conjunto de datos de los que vimos (o cualquier otro que encuentres) y crea al menos una figura con ggplot2.
Experimenta cambiando:
- El tipo de geometría (
geom_point, geom_jitter, geom_col, geom_histogram…)
- Las variables en
x, y, colour, size, shape
- El tema (
theme_minimal, theme_classic, theme_bw, theme_dark…)
- La paleta de colores
- Las etiquetas con
labs()
No importa si la figura no queda perfecta. Lo importante es jugar con el código y ver qué pasa.
![]()
jdleongomez.github.io/curso-r
jdleongomez.github.io/curso-r
