Jupyter: Notebooks y JupyterLab para Data Science

Jupyter Notebook es la herramienta preferida de los científicos de datos y los investigadores en Python. Combina código ejecutable, documentación en Markdown, visualizaciones y resultados de texto en un único documento interactivo. JupyterLab, la interfaz moderna de Jupyter, amplía esta experiencia al añadir un gestor de archivos, un terminal integrado y una extensibilidad completa. Esta guía te muestra cómo instalar, configurar y dominar Jupyter para desarrollar y documentar tus análisis de datos.

1. Instalación y configuración

Instalación con pip

# Instalación básica
# pip install jupyter

# Instalación con soporte completo
# pip install jupyterlab

# Verificar la instalación
# jupyter --version
# jupyter kernelspec list

Se recomienda realizar la instalación con pip en un entorno virtual dedicado, para evitar conflictos de dependencias.

# Crear un entorno virtual
# python -m venv env_jupyter
# source env_jupyter/bin/activate  # En Linux/macOS
# env_jupyter\Scripts\activate      # En Windows

# Instalar Jupyter en este entorno
# pip install jupyterlab numpy pandas matplotlib

Entornos virtuales y kernels

Cada entorno de Python debe disponer de su propio kernel de Jupyter. Un kernel es el proceso que ejecuta el código en tu notebook.

# Crear un entorno para data science
# python -m venv ds_env
# source ds_env/bin/activate
# pip install ipykernel

# Registrar este kernel en Jupyter
# python -m ipykernel install --user --name ds_env --display-name "Python (DS)"

# Crear otro entorno para desarrollo web
# python -m venv web_env
# source web_env/bin/activate
# pip install ipykernel flask django

# Registrar este kernel
# python -m ipykernel install --user --name web_env --display-name "Python (Web)"

# Listar todos los kernels disponibles
# jupyter kernelspec list

Una vez registrados los kernels, puedes cambiar entre ellos en Jupyter desde el menú «Kernel» o en la parte inferior derecha del notebook.

2. Notebook frente a JupyterLab

Notebook clásico

Jupyter Notebook es una interfaz minimalista y ligera. Se lanza con:

# jupyter notebook
# Este comando abre una interfaz web en http://localhost:8888

Ventajas del Notebook clásico:

• Ligero, consume pocos recursos
• Sencillo, con pocas distracciones
• Arranque rápido

JupyterLab

JupyterLab es la siguiente generación de Jupyter, con una interfaz modular y extensible.

# jupyter lab
# Este comando abre JupyterLab en http://localhost:8888

Ventajas de JupyterLab:

• Varios archivos abiertos en pestañas
• Gestor de archivos integrado a la izquierda
• Terminal y consola integrados
• Visor de imágenes nativo
• Extensibilidad mediante plugins TypeScript/JavaScript
• Barra lateral plegable

3. Estructura de las celdas

Celda de código

Una celda de código contiene Python ejecutable. Se ejecuta pulsando Ctrl+Entrée (o Cmd+Entrée en Mac).

# Celda de código

import numpy as np

data = np.array([1, 2, 3, 4, 5])
moyenne = data.mean()

print(f"Moyenne : {moyenne}")
# Salida: Moyenne : 3.0

El orden de ejecución lo determina el número entre corchetes: [1], [2], etc. Puedes volver a ejecutar una celda tantas veces como quieras, y el orden de ejecución cambia.

Celda Markdown

Las celdas Markdown permiten documentar tus análisis con texto con formato, títulos, listas y fórmulas matemáticas.

# Titre principal

## Sous-titre

Ceci est un paragraphe contenant du texte en **gras** et en *italique*.

- Élément 1
- Élément 2
- Élément 3

### Formules LaTeX

Voici une formule inline : $y = mx + b$

Et une formule centrée :

$$\sum_{i=1}^{n} x_i = \frac{n(n+1)}{2}$$

Consejo: pulsa Ctrl+Entrée para ejecutar (renderizar) una celda Markdown, o Esc y luego M para convertir una celda de código en Markdown.

4. Atajos de teclado esenciales

Atajo	Modo	Acción
Ctrl+Entrée	Edición/Cmd	Ejecutar la celda
Shift+Entrée	Edición	Ejecutar y pasar a la celda siguiente
Alt+Entrée	Edición	Ejecutar e insertar una nueva celda
Esc	Edición	Pasar al modo comando
Entrée	Comando	Pasar al modo edición
A	Comando	Insertar una celda encima
B	Comando	Insertar una celda debajo
D D	Comando	Eliminar la celda (dos veces D)
M	Comando	Convertir a Markdown
Y	Comando	Convertir a código
Ctrl+Shift+P	Comando	Paleta de comandos
H	Comando	Mostrar la ayuda de atajos

5. Comandos mágicos

Los comandos mágicos son atajos especiales con el prefijo % (línea) o %% (celda). Facilitan la depuración y la optimización.

%timeit: medir el tiempo de ejecución

# Medir el tiempo de una línea

%timeit sum(range(100))
# Resultado: 1.25 µs ± 41.2 ns per loop (mean ± std. dev. of 7 runs)

%%time: medir una celda completa

%%time

# Cálculo completo de la celda
resultat = sum(range(1_000_000))
print(resultat)
# CPU times: user 23.4 ms, sys: 1.23 ms, total: 24.6 ms
# Wall time: 25.1 ms

%matplotlib inline

Para mostrar los gráficos de Matplotlib directamente en el notebook (obligatorio antes de cualquier uso de Matplotlib).

%matplotlib inline

import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y = [1, 4, 9, 16]

plt.plot(x, y)
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Courbe simple")
plt.show()
# El gráfico se muestra directamente debajo de la celda

%run: ejecutar un archivo Python externo

# Supongamos que tienes un archivo helper.py
# con funciones reutilizables

%run helper.py

# Las funciones y variables del archivo ya están disponibles
print(ma_fonction(5))

%pip: instalar paquetes directamente en el notebook

# Instalar una biblioteca sin salir del notebook
%pip install requests

import requests
# Usar la biblioteca inmediatamente

%pwd y %cd: navegación por el sistema de archivos

%pwd
# Muestra el directorio actual
# /Users/utilisateur/projects/analysis

%cd ../data
# Cambia el directorio actual

%ls
# Lista los archivos del directorio actual

6. Visualización enriquecida y salida

Jupyter puede mostrar mucho más que texto: imágenes, DataFrames con formato, HTML, LaTeX, etc.

from IPython.display import display, HTML, Image, DataFrame
import pandas as pd

# Mostrar HTML
display(HTML("<h3 style='color:red;'>Attention!</h3>"))
# Resultado: Attention! (en rojo y grande)

# Mostrar una imagen desde una URL
display(Image(url="https://example.com/image.png"))

# DataFrame de Pandas con formato automático
df = pd.DataFrame({
    'Nom': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Ville': ['Paris', 'Lyon', 'Marseille']
})

display(df)
# Muestra una tabla con formato e interactiva

7. Extensiones y plugins útiles

JupyterLab dispone de un rico ecosistema de extensiones para mejorar la experiencia.

Gestionar las extensiones

# Listar las extensiones instaladas
# jupyter labextension list

# Instalar una extensión
# jupyter labextension install @jupyter-widgets/jupyterlab-manager

# Verificar las extensiones desde la línea de comandos
# pip install jupyterlab_execute_time
# pip install jupyterlab-code-formatter
# pip install jupyterlab-lsp

Extensiones populares

Extensión	Utilidad
jupyterlab-execute-time	Muestra el tiempo de ejecución de cada celda
jupyterlab-code-formatter	Da formato al código Python (Black, Autopep8, etc.)
jupyterlab-lsp	Compatibilidad con servidores Language Server Protocol (autocompletado avanzado)
ipywidgets	Widgets interactivos (sliders, botones, etc.)
jupyterlab-git	Integración de Git directamente en JupyterLab

8. Exportación y conversión con nbconvert

Un notebook .ipynb no es más que un archivo JSON. Puedes exportar tu trabajo a otros formatos.

# Exportar a PDF (requiere pandoc y LaTeX)
# jupyter nbconvert --to pdf notebook.ipynb

# Exportar a HTML estático
# jupyter nbconvert --to html notebook.ipynb
# Resultado: notebook.html

# Exportar a Python puro (solo celdas de código)
# jupyter nbconvert --to python notebook.ipynb
# Resultado: notebook.py

# Exportar a Markdown
# jupyter nbconvert --to markdown notebook.ipynb

# Exportar a diapositivas (reveal.js)
# jupyter nbconvert --to slides notebook.ipynb --post serve

9. Versionar notebooks con Git

Los archivos .ipynb son complejos de versionar con Git. Existen varias estrategias:

Problema nativo

// notebook.ipynb es un JSON con salidas, metadatos, etc.
{
  "cells": [...],
  "metadata": {...},
  "nbformat": 4,
  "nbformat_minor": 5
}
// Los diffs son ilegibles, las fusiones son imposibles

Solución 1: limpiar las salidas antes de hacer commit

# nbstripout: elimina las salidas y los metadatos superfluos
# pip install nbstripout

# git config filter.strip-notebook.clean "nbstripout"
# Añadir a .gitattributes:
# *.ipynb filter=strip-notebook

Solución 2: mantener el código Python al lado

# Exportar regularmente a Python
# jupyter nbconvert --to python notebook.ipynb

# Versionar notebook.py en lugar de notebook.ipynb
# Los diffs son claros y las fusiones, sencillas

Solución 3: usar Jupyter Book o Quarto

Para un proyecto serio, migra a Jupyter Book (.md + código) o a Quarto (formato universal), que son más adecuados para el control de versiones.

10. Buenas prácticas

• Una sección = un notebook: mantén un notebook por tema de análisis. Los notebooks muy largos se vuelven difíciles de navegar.
• Celdas cortas y centradas: cada celda debe hacer una sola cosa. Esto facilita la depuración y la reutilización.
• Documenta con Markdown: no dudes en escribir celdas Markdown que expliquen tus pasos. Los notebooks también sirven para contar una historia.
• Limpia antes de compartir: elimina las celdas de pruebas, las variables temporales y las salidas antiguas. Exporta o vuelve a ejecutar todo desde cero antes de entregar.
• Usa variables con nombres explícitos: df_sales_2024 en lugar de df1.
• Guarda con regularidad: Jupyter guarda automáticamente, pero un guardado manual (Ctrl+S) no está de más.
• Reinicia el kernel antes de compartir: menú «Kernel» → «Restart & Run All» para comprobar que todo se ejecuta en orden.

11. Alternativas y complementos

Herramienta	Caso de uso
VS Code + Jupyter	Si prefieres VS Code a una interfaz web
Google Colab	Notebooks gratuitos en la nube, GPUs/TPUs gratis
Kaggle Notebooks	Competiciones de data science y notebooks colaborativos
Pluto.jl	Notebooks reactivos para Julia (concepto similar)
Observable	Notebooks JavaScript para la visualización web

Conclusión

Jupyter Notebook y JupyterLab se han vuelto imprescindibles en el ecosistema Python para la data science, el machine learning y la investigación. Su combinación de código ejecutable, documentación y visualización interactiva los convierte en el entorno ideal para explorar datos, prototipar modelos y comunicar tus resultados. Si dominas los comandos mágicos, los atajos de teclado y las extensiones, ganarás una productividad considerable. No olvides que Jupyter no es una herramienta de producción: para pipelines de análisis robustos, es preferible usar scripts de Python bien organizados, probados y versionados correctamente.