Clase 1: primeros pasos en R y Colab

IRdisplay::display_html('
<style>
@import url("https://fonts.googleapis.com/css2?family=Work+Sans:wght@400;600&family=Amiri:wght@400;700&display=swap");
.rendered_html, .markdown, .cell .text_cell_render { font-family:"Work Sans",system-ui,sans-serif; color:#122535; }
.rendered_html h1,.rendered_html h2,.rendered_html h3 { font-family:"Amiri",Georgia,serif; color:#00529B; }
.rendered_html h2 { border-bottom:2px solid #00529B; padding-bottom:.2em; }
.rendered_html a { color:#00529B; }
.rendered_html table th { background:#00529B; color:#fff; }
.rendered_html h1,.rendered_html h2,.rendered_html h3 { scroll-margin-top:16px; }
</style>
')

Analítica de Datos · Maestría en Ciencias del Comportamiento, Universidad de San Andrés

Docentes: Tomás D’Amelio y Nicolás Bruno · 2do Cuatrimestre 2026 · 08/08/2026

Lenguaje: R. A lo largo de la notebook, los comentarios en cursiva presentan como se vería el código en Python. Aún así, la versión equivalente del notebook en Python está disponible en el sitio de la materia.

Abrir en Colab

Índice

#	Tema	Idea central
1	Cargar los datos de Nimbus desde Google Drive	un dataset vive en algun lugar, y hay que decirle a R donde buscarlo
2	Celdas de código y de texto	un notebook se lee y se corre, celda por celda
3	Librerías	R solo no alcanza, se cargan paquetes
4	Variables y tipos de datos	todo dato tiene un tipo, y el tipo define qué podés hacer con él
5	Vectores y listas	dos formas de agrupar datos relacionados
6	Condicionales y loops	cómo un programa decide y repite

Tip: hacé click en cualquier tema para saltar directo ahí.

Dónde estamos parados

Esta es la segunda mitad de la Clase 1. En la primera mitad presentamos la materia, y contamos el caso que nos va a acompañar buena parte del semestre: Nimbus, una empresa de software que tiene un problema de rotación de personal muy alto, y un equipo de People Analytics tratando de entenderlo.

Qué ya vimos. El equipo de Nimbus armó un primer experimento (fruta gratis en la oficina) y encontró una diferencia significativa en el bienestar de sus empleados. Eso es estadística inferencial. También planteamos la pregunta que va a guiar el resto del semestre: ¿podemos predecir si un empleado va a renunciar?

Qué hacemos ahora. Antes de poder responder esa pregunta con machine learning, necesitamos manejar una herramienta de trabajo: R, corriendo en un notebook de Google Colab. Hoy no vamos a construir ningún modelo todavía. Vamos a aprender a cargar los datos reales de Nimbus, a leer y correr celdas, y a reconocer las piezas básicas de R que vamos a usar en cada clase siguiente.

A dónde nos lleva. En la Clase 2 arrancamos a trabajar de verdad con estos datos: limpieza, datos faltantes, primeras preguntas exploratorias sobre el bienestar en Nimbus.

viene de	esta clase	lleva a
El caso Nimbus, presentado en las slides	Fundamentos de R y Colab, sin ejercicios todavía	Clase 2: limpieza y exploración de los datos de Nimbus

El hilo de hoy

Cargar los datos de Nimbus desde internet $\to$ entender qué es una celda $\to$ entender qué es un paquete $\to$ reconocer variables y tipos $\to$ agrupar datos en vectores y listas $\to$ tomar decisiones y repetir acciones con condicionales y loops.

1. Cargar los datos de Nimbus desde Google Drive

Un dataset no vive “en la computadora”: vive en algún lugar (un archivo, una base de datos, una carpeta de Drive) y hay que decirle a R explícitamente dónde buscarlo. Jupyter no permite montar Drive usando R (solo en Python), por lo que recomendamos ir a la notebook de Python para seguir la clase.

De todas formas, R acepta leer datasets utilizando links que dirijen a donde el archivo vive. Podés encontrar los links en la página de la clase.

Vamos a usar dos tablas de Nimbus:

Empleados (nimbus_empleados.csv): un renglón por empleado, con su sede, área y antigüedad. La celda de abajo ya está resuelta, así que primero mirala correr y entendé qué hace cada línea.
Salario (nimbus_salario.csv): el salario mensual de cada empleado, año a año. Esa tabla la vas a cargar vos, como único ejercicio de hoy.

La librería que usamos para leer archivos de datos en R se llama readr (parte de tidyverse), y su función principal es read_csv().

library(readr)

# En Colab, Drive se monta una vez desde el panel izquierdo (icono de carpeta -> Drive) y
# queda disponible en /content/drive/MyDrive/. Fuera de Colab (autoria/render local) usamos
# la copia del repo.
IN_COLAB <- dir.exists("/content")

if (IN_COLAB) {
  NIMBUS_PATH <- "https://analiticadedatos-udesa.com/data/toy-nimbus/nimbus_empleados.csv"
} else {
  NIMBUS_PATH <- "../../../data/toy-nimbus/nimbus_empleados.csv"
}

empleados <- read_csv(NIMBUS_PATH, show_col_types = FALSE)
head(empleados)

read_csv(...) lee un archivo de valores separados por comas y lo convierte en un tibble: una tabla, con filas y columnas con nombre, que es la estructura de datos que más vamos a usar en toda la materia. head() muestra las primeras seis filas, para chequear que la carga salió bien sin imprimir la tabla entera.

cat("Filas y columnas de empleados:", nrow(empleados), "x", ncol(empleados), "\n")
cat("Columnas:", paste(names(empleados), collapse = ", "), "\n")

Ejercicio: cargar `nimbus_salario.csv` desde el link

Este es el único ejercicio de la clase de hoy. Completá la ruta en la celda de abajo, reemplazando ..., y corré la celda.

Fijate que la estructura es idéntica a la celda de empleados: cambia el nombre del archivo, nada más.

if (IN_COLAB) {
  SALARIO_PATH <- "https://analiticadedatos-udesa.com/data/toy-nimbus/..."
} else {
  SALARIO_PATH <- "../../../data/toy-nimbus/nimbus_salario.csv"  # placeholder para correr fuera de Colab
}

salario <- read_csv(SALARIO_PATH, show_col_types = FALSE)
head(salario)

2. Celdas de código y de texto

Un notebook está hecho de celdas. Esta celda que estás leyendo es una celda de texto (markdown): sirve para explicar, no se ejecuta. Las celdas de arriba, con fondo gris y un [ ] o un número al costado, son celdas de código: contienen instrucciones reales de R que la computadora ejecuta cuando las corrés.

Para correr una celda: hacé click adentro y apretá Shift + Enter (corre esa celda y pasa a la siguiente) o el botón de play que aparece a la izquierda. El número que aparece entre corchetes, por ejemplo [3], te dice en qué orden se corrió esa celda durante la sesión actual, no su posición en el notebook. Si corrés las celdas fuera de orden, ese número lo va a mostrar.

Usando R, una celda de Google Colab muestra automáticamente el resultado de sus líneas aunque no se lo pida explícitamente.

5 + 5
2 + 2

Pero si querés mostrar más de un resultado, o mostrar algo que no es la última línea, en la mayoría de IDEs (por ejemplo, RStudio) hace falta cat o print explícito.

cat("Empleados en Nimbus:", nrow(empleados), "\n")
5 + 5
cat("Sedes:", length(unique(empleados$sede)), "\n")
2 + 2

3. Librerías

R, tal cual viene instalado, sabe hacer cuentas básicas y manejar texto, pero no sabe nada de tablas prolijas, gráficos modernos o estadística avanzada. Esas capacidades viven en paquetes: código que otras personas escribieron, y que se carga con library(...).

Ya usamos uno: library(readr). tidyverse es en realidad una colección de paquetes (readr, dplyr, ggplot2, entre otros) pensados para trabajar juntos, y es el que más vamos a usar en la materia. En Python el equivalente es import pandas as pd: una sola libreria (pandas) cubre lo que en R son varios paquetes de tidyverse juntos.

Paquete	Para qué sirve
`readr`	leer archivos de datos (CSV, etc)
`dplyr`	transformar tablas (filtrar, agrupar, resumir)
`ggplot2`	gráficos con gramática de capas, la forma mas comun de graficar en R

Si un paquete no está instalado, R tira un error al cargarlo. Usando R en Google Colab, tidyverse ya viene preinstalado.

library(dplyr)
library(ggplot2)

antiguedades <- empleados$antiguedad_anios
cat("Antiguedad promedio en Nimbus:", round(mean(antiguedades), 1), "anios\n")

ggplot(empleados, aes(x = antiguedad_anios)) +
  geom_histogram(fill = "#00529B", bins = 15) +
  labs(title = "Antiguedad de los empleados de Nimbus", x = "Años de antiguedad", y = "Cantidad")

4. Variables y tipos de datos

Una variable es un nombre que apunta a un valor guardado en memoria. En R se crea con <- (aunque = también funciona, <- es la convención), y no hace falta declarar de antemano qué tipo de dato va a guardar.

En Python lo mismo se escribe con = en vez de <-: a = 1.

Empecemos con ejemplos sueltos, sin el dataset todavía.

ciudad <- "Rosario"
cantidad <- 6
print(ciudad)
print(cantidad)

Todo valor en R tiene un tipo (class), y el tipo determina qué operaciones tienen sentido. Los tipos básicos que vas a ver todo el tiempo: texto (character), número entero (integer), número con decimales (numeric) y verdadero/falso (logical).

nombre_empresa <- "Nimbus"          # character: texto, entre comillas
empleados_totales <- 600L            # integer: numero entero
rotacion_pct <- 19.0                 # numeric: numero con decimales
tiene_oficinas_multiples <- TRUE     # logical: verdadero o falso

cat(class(nombre_empresa), "\n")
cat(class(empleados_totales), "\n")
cat(class(rotacion_pct), "\n")
cat(class(tiene_oficinas_multiples), "\n")

class(...) le pregunta a R de qué tipo es un valor. Esto importa en la práctica: sumar dos números da un número, pero pegar dos textos necesita paste, no +.

En Python, el equivalente de class(...) es type(...).

sede_a <- "Buenos Aires"
sede_b <- "Córdoba"
cat(paste(sede_a, "y", sede_b), "\n")   # pega texto

edad_2025 <- 45
antiguedad <- 8
cat(edad_2025 + antiguedad, "\n")        # suma numeros

Ahora llevemos esto al dataset. Una columna de un tibble no es más que muchas variables del mismo tipo, una por fila. Miremos el tipo de un dato real de la tabla de empleados.

primera_sede <- empleados$sede[1]
cat("Sede del primer empleado:", primera_sede, "-", class(primera_sede), "\n")

5. Vectores y listas

Cuando el dato no es un valor suelto sino un grupo de valores relacionados, R ofrece dos estructuras básicas.

Un vector (c(...)) es una secuencia ordenada de valores del mismo tipo. Se accede a cada elemento por su posición, empezando en 1.

En Python lo más parecido es una lista, con [...] en vez de c(...), y las posiciones empiezan en 0: sedes = ["Rosario", "Cordoba"].

Un ejemplo simple, sin el dataset:

sedes <- c("Rosario", "Cordoba", "Buenos Aires", "Mendoza", "Bahia Blanca", "Mar del Plata")
print(sedes)
cat("Primera sede:", sedes[1], "\n")
cat("Ultima sede:", sedes[length(sedes)], "\n")
cat("Cantidad de sedes:", length(sedes), "\n")

Ahora con el dataset. La columna sede de la tabla de empleados tiene muchos valores repetidos (un empleado por fila). unique(...) nos da cada sede una sola vez.

sedes_nimbus <- unique(empleados$sede)
print(sedes_nimbus)
cat("Primera sede del vector:", sedes_nimbus[1], "\n")
cat("Cantidad de sedes:", length(sedes_nimbus), "\n")

Una lista (list(...)) guarda elementos con nombre, y se accede por nombre con $, no por posición, lo que la hace ideal para representar algo con atributos, como un empleado.

En Python lo más parecido es un diccionario: empleado = {"sede": "Rosario", "area": "Ventas"}, accediendo con corchetes en vez de $: empleado["area"].

Otro ejemplo simple primero:

empleado_ejemplo <- list(
  sede = "Rosario",
  area = "Ventas"
)
print(empleado_ejemplo)
cat("Área del ejemplo:", empleado_ejemplo$area, "\n")

Ahora con un empleado real de la tabla de Nimbus, armado a partir de tres columnas de la fila 1.

empleado_1 <- list(
  sede = empleados$sede[1],
  area = empleados$area[1],
  antiguedad_anios = empleados$antiguedad_anios[1]
)
print(empleado_1)
cat("Área del empleado 1:", empleado_1$area, "\n")

6. Condicionales y loops

Un condicional (if) ejecuta código solo si se cumple una condición. Es cómo un programa toma una decisión.

En Python la sintaxis es casi igual, cambia solo las llaves { } por : y la indentación: if x >= 5: ... else: ....

Empecemos con un número cualquiera, sin el dataset:

antiguedad_ejemplo <- 8

if (antiguedad_ejemplo >= 5) {
  cat("Empleado senior:", antiguedad_ejemplo, "años\n")
} else {
  cat("Empleado junior:", antiguedad_ejemplo, "años\n")
}

Con el dato real del empleado 1 que armamos antes:

antiguedad_1 <- empleado_1$antiguedad_anios

if (antiguedad_1 >= 5) {
  cat("Empleado senior:", antiguedad_1, "años en Nimbus\n")
} else {
  cat("Empleado junior:", antiguedad_1, "años en Nimbus\n")
}

Un loop (for) repite una acción para cada elemento de una secuencia, como un vector. Es cómo un programa evita escribir la misma línea muchas veces.

En Python también cambia solo las llaves por : e indentación: for sede in sedes: ....

Con el vector simple de antes:

for (sede in sedes) {
  cat("Sede:", sede, "\n")
}

Ahora con las sedes reales de Nimbus, contando cuántos empleados tiene cada una:

for (sede in sedes_nimbus) {
  empleados_en_sede <- sum(empleados$sede == sede)
  cat(sede, ":", empleados_en_sede, "empleados\n")
}

Combinando las dos ideas: un for que recorre las sedes, y un if adentro que solo imprime las sedes grandes.

for (sede in sedes_nimbus) {
  empleados_en_sede <- sum(empleados$sede == sede)
  if (empleados_en_sede > 100) {
    cat(sede, "es una sede grande:", empleados_en_sede, "empleados\n")
  }
}

Resumen de hoy

Concepto	En una línea
montar Drive	conecta tu Google Drive a este notebook, desde el panel izquierdo
`read_csv(ruta)`	carga una tabla desde un archivo en un tibble
celda de código vs. texto	el código se corre (`Shift+Enter`), el texto solo explica
`library(paquete)`	trae herramientas que R base no tiene
`character`, `integer`/`numeric`, `logical`	los tipos de dato básicos
`variable <- valor`	crea o actualiza una variable, sin declarar tipo
`vector <- c(a, b, c)`	secuencia ordenada del mismo tipo, se accede por posición (`vector[1]`)
`lista <- list(clave = valor)`	elementos con nombre, se accede con `$`
`if (condicion) { ... }`	ejecuta código solo si la condición es verdadera
`for (x in secuencia) { ... }`	repite código para cada elemento de la secuencia

Para la próxima clase: vamos a volver a estos mismos datos de Nimbus, y también a la tabla de salario que cargaste hoy, para limpiarlos y explorarlos en serio, ya usando dplyr para algo más que cargar una tabla.