Clase 1: primeros pasos en Python y Colab

#@title Estilo de la clase (ejecutar, no hace falta leer) {display-mode: "form"}
from IPython.display import HTML, display
display(HTML(r'''
<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: Nicolás Bruno; Tomás D’Amelio y Jerónimo Rodriguez Cuello · 2do Cuatrimestre 2026 · 08/08/2026

Lenguaje: Python. A lo largo de la notebook, los comentarios en cursiva presentan como se vería el código en R. Aún así, la versión equivalente del notebook en R 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 Python donde buscarlo
2	Celdas de código y de texto	un notebook se lee y se corre, celda por celda
3	Librerías	Python solo no alcanza, se importan herramientas
4	Variables y tipos de datos	todo dato tiene un tipo, y el tipo define qué podés hacer con él
5	Listas y diccionarios	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

En la primera mitad de la clase 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 la herramienta con la que vamos a trabajar toda la materia: Python, 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 Python 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 Python 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 una librería \(\to\) reconocer variables y tipos \(\to\) agrupar datos en listas y diccionarios \(\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 Python explícitamente dónde buscarlo. En esta clase vamos a practicar la forma más común de acceder a datos en Colab: montar tu Google Drive y leer un archivo desde ahí.

Vamos a usar dos tablas de Nimbus:

1. Empleados (nimbus_empleados.csv): un renglón por empleado, con su sede, área y antigüedad.
2. Salario (nimbus_salario.csv): el salario mensual de cada empleado, año a año.

Lo primero que vas a hacer es descargar los archivos y cargarlos en tu drive. Te recomendamos crear una carpeta llamada analitica_de_datos/clase_01, y volcar los archivos ahí.

La celda de abajo ya carga nimbus_empleados.csv desde tu drive. La librería que usamos para manejar tablas de datos en Python se llama pandas, y la convención universal es importarla con el alias pd. Corre la celda e intentá entender que está haciendo cada linea.

import pandas as pd

# En Colab montamos Google Drive; fuera de Colab (autoria/render local) usamos la copia del repo.
IN_COLAB = "google.colab" in str(get_ipython())

if IN_COLAB:
    from google.colab import drive
    drive.mount('/content/drive')
    NIMBUS_PATH = '/content/drive/MyDrive/analitica_de_datos/clase_01/nimbus_empleados.csv'
else:
    NIMBUS_PATH = '../../../data/toy-nimbus/nimbus_empleados.csv'

empleados = pd.read_csv(NIMBUS_PATH)
empleados.head()

pd.read_csv(...) lee un archivo de valores separados por comas y lo convierte en un DataFrame: 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 cinco filas, para chequear que la carga salió bien sin imprimir la tabla entera.

print("Filas y columnas de empleados:", empleados.shape)
print("Columnas:", list(empleados.columns))

Ejercicio: cargar nimbus_salario.csv desde tu Drive

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 = '/content/drive/MyDrive/analitica_de_datos/clase_01/...'
else:
    SALARIO_PATH = '../../../data/toy-nimbus/nimbus_salario.csv'  # linea por si quisieramos correr fuera de Colab

salario = pd.read_csv(SALARIO_PATH)
salario.head()

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 Python 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.

Una celda puede devolver un output: el resultado de la última línea se muestra debajo, automáticamente, sin necesidad de pedirlo con print.

2 + 2

Pero si querés mostrar más de un resultado, o mostrar algo que no es la última línea, hace falta print explícito.

print("Empleados en Nimbus:", len(empleados))
5 + 5
print("Sedes:", empleados["sede"].nunique())
2 + 2

Notá que solo se imprimió lo que pedimos con print, más el resultado de la última línea (2 + 2), que Colab muestra solo. Esta es una de las cosas que más confunde al empezar: un notebook no imprime todo lo que calcula, solo lo último de cada celda, salvo que se lo pidas explícitamente.

3. Librerías

Python, tal cual viene instalado, sabe hacer cuentas básicas y manejar texto, pero no sabe nada de tablas, gráficos o estadística. Esas capacidades viven en librerías: paquetes de código que otras personas escribieron, y que cualquiera puede instalar y usar con una línea de import.

Ya usamos una: import pandas as pd. En R el equivalente es library(pandas) -> pero R no usa pandas, usa library(readr) para leer datos y library(dplyr) para tablas, sin necesidad de alias. El as pd es un alias, un apodo más corto para no escribir pandas entero cada vez. No es obligatorio, pero es una convención tan fuerte en la comunidad de Python que casi todo el mundo la sigue, y vas a verla en cualquier notebook de ciencia de datos que abras.

Las librerías que más vamos a usar en la materia:

Librería	Alias convencional	Para qué sirve
pandas	pd	tablas de datos (DataFrames)
numpy	np	cuentas numéricas rápidas, vectores y matrices
matplotlib.pyplot	plt	gráficos
seaborn	sns	gráficos estadísticos, construida sobre matplotlib, con menos código
scikit-learn	sklearn	machine learning: la librería principal de la materia, la vamos a usar a partir de la Clase 3

Si una librería no está instalada, Python tira un error al importarla (ModuleNotFoundError). En Google Colab, las cinco de arriba ya vienen instaladas de fábrica.

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import sklearn

print("Version de scikit-learn:", sklearn.__version__)

antiguedades = empleados["antiguedad_anios"]
print("Antiguedad promedio en Nimbus:", round(np.mean(antiguedades), 1), "años")

# El mismo histograma, dos librerias: matplotlib (mas control manual) y seaborn (mas directo)
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(9, 3.5))

ax1.hist(antiguedades, color="#00529B")
ax1.set_title("Con matplotlib")

sns.histplot(antiguedades, color="#00529B", ax=ax2)
ax2.set_title("Con seaborn")

plt.tight_layout()
plt.show()

4. Variables y tipos de datos

Una variable es un nombre que apunta a un valor guardado en memoria. Se crea con =, y a diferencia de otros lenguajes, en Python no hace falta declarar de antemano qué tipo de dato va a guardar.

En R lo mismo se escribe con <- en vez de = (aunque R también acepta =, <- es la convención): a <- 1.

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

ciudad = "Rosario"
cantidad = 6
print(ciudad)
print(cantidad)

Todo valor en Python tiene un tipo, y el tipo determina qué operaciones tienen sentido. Los cuatro tipos básicos que vas a ver todo el tiempo: texto (str), número entero (int), número con decimales (float) y verdadero/falso (bool).

nombre_empresa = "Nimbus"        # str: texto, entre comillas
empleados_totales = 600          # int: numero entero
rotacion_pct = 19.0               # float: numero con decimales
tiene_oficinas_multiples = True   # bool: verdadero o falso

print(type(nombre_empresa))
print(type(empleados_totales))
print(type(rotacion_pct))
print(type(tiene_oficinas_multiples))

type(...) le pregunta a Python de qué tipo es un valor. Esto importa en la práctica: sumar dos int da un número, pero sumar dos str los pega uno atrás del otro (concatenación), no los suma como si fueran números.

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

sede_a = "Buenos Aires"
sede_b = "Córdoba"
print(sede_a + " y " + sede_b)   # concatena texto

edad_2025 = 45
antiguedad = 8
print(edad_2025 + antiguedad)     # suma numeros

Ahora llevemos esto al dataset. Una columna de un DataFrame 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.loc[0, "sede"] # .loc sirve para ver los valores de un dataframe. Quedará más claro en clase 2!
print("Sede del primer empleado:", primera_sede, "-", type(primera_sede))

5. Listas y diccionarios

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

Una lista (list) es una secuencia ordenada de valores, entre corchetes. Se accede a cada elemento por su posición, empezando en 0.

En R lo más parecido es un vector, con c(...) en vez de [...], y las posiciones empiezan en 1, no en 0: sedes <- c("Rosario", "Cordoba").

Un ejemplo simple, sin el dataset:

sedes = ["Rosario", "Cordoba", "Buenos Aires", "Mendoza", "Bahia Blanca", "Mar del Plata"]
print(sedes)
print("Primera sede:", sedes[0])
print("Ultima sede:", sedes[-1])
print("Cantidad de sedes:", len(sedes))

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, y list(...) lo convierte en la lista que acabamos de ver.

sedes_nimbus = list(empleados["sede"].unique())
print(sedes_nimbus)
print("Primera sede de la lista:", sedes_nimbus[0])
print("Cantidad de sedes:", len(sedes_nimbus))

Un diccionario (dict) guarda pares de clave y valor, entre llaves. En vez de acceder por posición, accedés por nombre (la clave), lo que lo hace ideal para representar algo con atributos con nombre, como un empleado.

En R lo más parecido es una lista con nombre: list(sede = "Rosario", area = "Ventas"), y se accede con $, no con corchetes: empleado$sede.

Otro ejemplo simple primero:

empleado_ejemplo = {
    "sede": "Rosario",
    "area": "Ventas",
}
print(empleado_ejemplo)
print("Área del ejemplo:", empleado_ejemplo["area"])

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

empleado_1 = {
    "sede": empleados.loc[0, "sede"],
    "area": empleados.loc[0, "area"],
    "antiguedad_anios": int(empleados.loc[0, "antiguedad_anios"]),
}
print(empleado_1)
print("Área del empleado 1:", empleado_1["area"])

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 R la sintaxis es casi igual, cambia solo : por llaves { }: if (x >= 5) { ... } else { ... }.

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

antiguedad_ejemplo = 8

if antiguedad_ejemplo >= 5:
    print("Empleado senior:", antiguedad_ejemplo, "años")
else:
    print("Empleado junior:", antiguedad_ejemplo, "años")

Con el dato real del empleado 1 que armamos antes:

antiguedad_1 = empleado_1["antiguedad_anios"]

if antiguedad_1 >= 5:
    print("Empleado senior:", antiguedad_1, "años en Nimbus")
else:
    print("Empleado junior:", antiguedad_1, "años en Nimbus")

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

En R también cambia : por llaves: for (sede in sedes) { ... }.

Con la lista simple de antes:

for sede in sedes:
    print("Sede:", sede)

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

for sede in sedes_nimbus:
    empleados_en_sede = (empleados["sede"] == sede).sum()
    print(f"{sede}: {empleados_en_sede} empleados")

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 = (empleados["sede"] == sede).sum()
    if empleados_en_sede > 100:
        print(f"{sede} es una sede grande: {empleados_en_sede} empleados")

Resumen de hoy

Concepto	En una línea
drive.mount(...)	conecta tu Google Drive a este notebook
pd.read_csv(ruta)	carga una tabla desde un archivo en un DataFrame
celda de código vs. texto	el código se corre (Shift+Enter), el texto solo explica
import libreria as alias	trae herramientas que Python no tiene de fábrica
str, int, float, bool	los cuatro tipos de dato básicos
variable = valor	crea o actualiza una variable, sin declarar tipo
lista = [a, b, c]	secuencia ordenada, se accede por posición (lista[0])
dic = {"clave": valor}	pares clave-valor, se accede por nombre (dic["clave"])
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 pandas para algo más que cargar una tabla.