R básico: aprende R desde cero, sin haber programado nunca

Empecemos con una pregunta, no con una definición: ¿cuántas veces has repetido el mismo informe en Excel — copiar, pegar, arrastrar la fórmula, rehacer el gráfico — porque llegaron datos nuevos? R existe para eso. R es un lenguaje de programación gratuito creado por y para gente que analiza datos: en lugar de hacer clics que nadie recuerda, escribes una receta (un script) que cualquiera puede leer, repetir y mejorar. Si mañana cambian los datos, no rehaces nada: vuelves a ejecutar la receta y sale el análisis actualizado. Por eso lo usan bancos centrales, farmacéuticas, periodistas de datos de la BBC y medio mundo académico. Y una noticia tranquilizadora para empezar: no necesitas 'saber programar' — R fue diseñado para analistas, no para ingenieros de software, y en esta guía cada concepto llega con su ejemplo y su porqué.

Vas a instalar dos programas, y la analogía que nunca falla es la del carro: R es el motor (el lenguaje que hace los cálculos) y RStudio es la cabina (la pantalla amigable desde donde lo manejas). Se instalan en ese orden, ambos gratis: primero R desde cran.r-project.org (el sitio oficial del lenguaje) y luego RStudio Desktop desde posit.co. Un consejo que evita horas de frustración: instala R en una ruta sin tildes, eñes ni espacios (por ejemplo C:\R\) — los nombres de usuario tipo 'José María' causan errores confusos más adelante. ¿Tu computador está bloqueado por tu empresa o universidad? Plan B sin instalar nada: posit.cloud te da RStudio completo en el navegador, gratis. Al abrir RStudio por primera vez, escribe esto en la consola (el panel con el símbolo >) para confirmar que todo respira:

# Escribe esto en la consola de RStudio y presiona Enter:
R.version.string
# [1] "R version 4.6.1 (2026-06-24)"  → si ves 4.6 o superior, perfecto

2 + 2
# [1] 4  → el motor responde. Ya estás programando (en serio).

R es interactivo: tú preguntas, él responde. Empecemos por lo más simple posible — sí, una suma — y subamos de a poco, porque cada línea enseña algo. Un detalle antes de empezar: la consola responde y olvida, pero un script (un archivo .R que creas con File → New File → R Script) queda guardado para siempre. Acostúmbrate desde hoy a escribir en el script y ejecutar cada línea con Ctrl+Enter: esa es la diferencia entre 'me salió una vez' y un análisis que puedes repetir el próximo mes. Fíjate también en la primera línea del ejemplo: todo lo que empieza con # es un comentario — R lo ignora, es una nota para humanos (para el tú del futuro, sobre todo):

# Esto es un comentario: R lo ignora por completo
1 + 1              # R como calculadora
# [1] 2

100 * 1.19         # un precio de $100 con IVA del 19%
# [1] 119

sqrt(144)          # tu primera función: sqrt() calcula la raíz cuadrada
# [1] 12

# ¿Qué acaba de pasar? Una función es una máquina con nombre:
# recibe algo entre paréntesis, hace su trabajo y devuelve el resultado.

Hasta ahora R responde y olvida. Para guardar un resultado, se lo asignas a un objeto con la flecha <- (piénsalo literal: 'el valor viaja hacia el nombre'). Un objeto es como un frasco etiquetado: adentro va el contenido, afuera el nombre con el que lo vuelves a llamar. Dos cosas van a sorprenderte al principio: la línea que asigna no muestra nada (asignar es silencioso — el frasco se llenó, aunque no lo veas), y los nombres importan más de lo que crees: ventas_enero le cuenta la historia a cualquiera; x no le cuenta nada a nadie. Regla profesional desde el día uno: nombres en minúsculas, palabras separadas con guion bajo, y que digan qué contienen:

ventas_enero <- 120        # asigna: el 120 viaja al nombre ventas_enero
# (no imprime nada: asignar es silencioso)

ventas_enero               # escribe el nombre para ver el contenido
# [1] 120

ventas_febrero <- 150
ventas_enero + ventas_febrero    # los objetos se usan como valores
# [1] 270

total <- ventas_enero + ventas_febrero   # y los resultados también se guardan
total
# [1] 270

Los datos vienen en sabores, y R distingue tres fundamentales: números (23, 4.5), texto entre comillas ('Ana' — R le dice character) y lógicos (TRUE o FALSE, siempre en mayúsculas). Hay un cuarto personaje que te vas a encontrar toda la vida: NA, que significa 'dato faltante' — la casilla vacía de la encuesta. Ojo: NA no es cero; es 'no sé'. Y R es honesto con lo que no sabe: si le pides el promedio de datos donde falta uno, responde NA — porque no puede prometerte un promedio correcto con información incompleta. Tú decides explícitamente qué hacer con los faltantes (na.rm = TRUE significa 'remueve los NA y calcula con lo que hay'). La función class() te dice de qué tipo es cualquier cosa — úsala cada vez que dudes:

edad   <- 35
nombre <- "Ana"          # el texto SIEMPRE va entre comillas
activo <- TRUE           # lógico: TRUE o FALSE, en mayúsculas

class(edad)              # [1] "numeric"
class(nombre)            # [1] "character"
class(activo)            # [1] "logical"

ingresos <- c(1200, NA, 950)    # el NA es un dato faltante, no un cero
mean(ingresos)                  # [1] NA → R es honesto: "no sé"
mean(ingresos, na.rm = TRUE)    # [1] 1075 → "calcula con lo que hay"

Aquí está el concepto más importante de toda la guía. Un vector es una colección ordenada de valores del mismo tipo — imagínalo como una columna de tu hoja de cálculo. Se crea con c() (de 'combinar'). ¿Y por qué es LA idea? Porque en R las operaciones se aplican al vector completo de un solo golpe: nada de arrastrar fórmulas celda por celda, nada de repetir. A eso se le llama vectorización. Antes de mirar el resultado del ejemplo, haz la prueba de predecir: si salarios tiene tres valores y lo multiplico por 1.09, ¿qué esperas que salga? Piénsalo un segundo... y ahora mira: los tres valores aumentados a la vez. Con 3 salarios o con 3 millones de registros, el código es exactamente el mismo — esa es la promesa que Excel no puede hacerte:

salarios <- c(2.4, 3.1, 1.8)    # c() combina valores en un vector
salarios
# [1] 2.4 3.1 1.8

salarios * 1.09                 # aumento del 9% a TODOS a la vez
# [1] 2.616 3.379 1.962

mean(salarios)                  # las funciones reciben el vector completo
# [1] 2.433333

salarios[2]                     # los corchetes sacan un elemento: el segundo
# [1] 3.1

Analizar datos es, en el fondo, hacer preguntas: ¿quién gana más de 2 millones? ¿quién es menor de 30? Las comparaciones responden con vectores de TRUE y FALSE, y son la base de todos los filtros que harás en tu vida analítica. Los operadores son los del colegio (>, <, >=, <=) más dos que debes memorizar con cuidado: == (doble igual) pregunta '¿es igual?', y != pregunta '¿es distinto?'. La confusión clásica de todo principiante — y de varios veteranos — es usar un solo = para comparar: el = solo se usa para pasar argumentos a funciones (como na.rm = TRUE); para comparar, siempre doble ==. Mira cómo las comparaciones se convierten inmediatamente en filtros:

edades <- c(23, 35, 41, 28)

edades > 30              # ¿quiénes son mayores de 30? R responde uno por uno
# [1] FALSE  TRUE  TRUE FALSE

edades == 35             # ¿quién tiene exactamente 35? (¡doble igual!)
# [1] FALSE  TRUE FALSE FALSE

edades[edades > 30]      # y la magia: usar la pregunta como filtro
# [1] 35 41

sum(edades > 30)         # ¿cuántos cumplen? TRUE cuenta como 1
# [1] 2

Cuando una variable solo puede tomar valores de una lista cerrada — ciudad, sexo, nivel educativo, mes — no es texto libre: es una categoría. En R las categorías se guardan como factores, y la diferencia con el texto normal es que el factor tiene memoria: sabe cuáles son todos sus niveles posibles, aunque en tus datos de hoy no aparezcan todos. Esa memoria es la que alimenta las tablas de frecuencia, los grupos de colores en los gráficos y las variables categóricas en los modelos estadísticos que verás más adelante. Para un principiante, el uso estrella es table(): tu primer resumen de datos reales en una línea:

ciudad <- factor(c("Bogotá", "Cali", "Bogotá", "Cali", "Bogotá"))

table(ciudad)            # conteo por categoría, en una línea
# ciudad
# Bogotá   Cali
#      3      2

levels(ciudad)           # los niveles: la "memoria" del factor
# [1] "Bogotá" "Cali"

Llegamos a la estructura reina del análisis de datos. Un data frame es una tabla donde cada columna es un vector (¿ves por qué el paso 6 era tan importante?): una columna de nombres, una de edades, una de salarios — todas del mismo largo. Es tu hoja de cálculo de siempre, pero programable, auditable y sin límite práctico de filas. Cuatro movimientos cubren la mayoría del trabajo diario: radiografiar la estructura con str(), extraer una columna con el signo $, filtrar filas con corchetes y una condición, y crear columnas calculadas. Fíjate en la última línea del ejemplo: la columna nueva nace de una operación vectorizada sobre otra columna — todo lo aprendido se junta aquí:

equipo <- data.frame(
  nombre  = c("Ana", "Luis", "Sofía"),
  edad    = c(23, 35, 41),
  salario = c(2.4, 3.1, 1.8)     # en millones de pesos
)

str(equipo)                 # radiografía: 3 observaciones, 3 variables
equipo$salario              # una columna es... un vector (todo conecta)
# [1] 2.4 3.1 1.8

equipo[equipo$edad > 30, ]  # filtrar filas: solo mayores de 30
#   nombre edad salario
# 2   Luis   35     3.1
# 3  Sofía   41     1.8

equipo$anual <- equipo$salario * 12    # columna nueva, calculada
equipo$anual
# [1] 28.8 37.2 21.6

R viene con mucho incluido, pero su superpoder real es CRAN: un repositorio con más de 21.000 paquetes — extensiones gratuitas revisadas que le agregan capacidades, como las apps a un teléfono. Se instalan una sola vez con install.packages() y se cargan en cada sesión con library() (instalar es comprar el libro; library() es abrirlo hoy). Y hay un paquete que merece mención propia: el tidyverse, la colección moderna para manipular y graficar datos que la comunidad recomienda hoy como camino principal (dplyr para transformar, ggplot2 para graficar, readr para importar, y más). Esta guía te deja en la puerta; los siguientes niveles viven ahí adentro:

install.packages("tidyverse")   # una sola vez (descarga de CRAN)

library(tidyverse)              # en cada sesión que lo uses
# ── Attaching core tidyverse packages ──────────
# ✔ dplyr    ✔ readr    ✔ ggplot2    ✔ tidyr ...

# De ahora en adelante tienes disponibles sus funciones.

El análisis real empieza cuando entran TUS datos. Para un archivo CSV (el formato universal: valores separados por comas), el tidyverse trae read_csv(), que lee rápido y te informa qué tipos detectó en cada columna. Apenas importes algo, aplica el ritual de reconocimiento de todo analista serio — tres preguntas, tres funciones: ¿qué estructura llegó? (glimpse()), ¿se ven bien las primeras filas? (head()), ¿los rangos tienen sentido y cuántos NA hay? (summary()). Para practicar sin descargar nada, el tidyverse incluye datasets de prueba como mpg (234 modelos de carros con su consumo) — el mismo que usaremos para tu primer gráfico:

library(tidyverse)

# Con tus propios archivos será así:
# datos <- read_csv("mis_ventas.csv")

# Hoy practicamos con mpg, un dataset incluido:
glimpse(mpg)      # estructura: filas, columnas y tipo de cada una
# Rows: 234
# Columns: 11
# $ manufacturer <chr> "audi", "audi", ...
# $ displ        <dbl> 1.8, 1.8, 2.0, ...

head(mpg)         # primeras filas: ¿se ve como esperabas?
summary(mpg)      # rangos, medias y NAs de cada variable

Cerremos con la recompensa. Una pregunta real: en los carros de mpg, ¿los motores más grandes consumen más gasolina? En lugar de leerte 234 filas, dibujémoslo. ggplot2 construye gráficos por capas, como un sándwich: primero el lienzo con los datos (ggplot(mpg)), luego el mapeo — qué variable va en cada eje (aes(x = displ, y = hwy): cilindraje contra rendimiento en carretera) — y encima la capa de puntos (geom_point()). Las capas se suman literalmente con un +. Ejecuta el ejemplo y ahí está: cada punto es un carro, y la nube que baja hacia la derecha responde la pregunta — a más motor, menos kilómetros por galón. Acabas de hacer análisis de datos de verdad: pregunta, datos, evidencia visual. Ese es el ciclo completo, y apenas es el comienzo:

library(tidyverse)

ggplot(mpg, aes(x = displ, y = hwy)) +   # lienzo + ejes: motor vs rendimiento
  geom_point()                           # capa de puntos: un punto por carro

# ¿Quieres más? Colorea por tipo de carro cambiando UNA cosa:
ggplot(mpg, aes(x = displ, y = hwy, color = class)) +
  geom_point()