Anexo: JupyterLab, cuadernos para aprender
Una herramienta donde escribes Python por bloques, los ejecutas al momento y ves el resultado justo debajo. No forma parte del lenguaje, es una herramienta opcional, pero es probablemente el mejor entorno para experimentar y aprender.
Qué es JupyterLab
JupyterLab es un entorno de desarrollo que funciona en el navegador. En lugar de escribir un archivo Python completo y ejecutarlo todo de golpe, aquí escribes el código en bloques pequeños llamados celdas y los ejecutas uno a uno, viendo el resultado inmediatamente debajo de cada uno.
La analogía más útil es la de un cuaderno donde alternas texto con calculadora: escribes una cuenta, pulsas Intro y aparece el resultado; sigues escribiendo más cosas. Eso es un cuaderno de Jupyter: código y resultados entrelazados, en orden, sobre el mismo documento.
Los archivos que crea JupyterLab se llaman cuadernos (notebooks) y tienen extensión .ipynb. Guardan tanto el código como los resultados, así que puedes cerrar y volver a abrirlos exactamente como los dejaste.
Nota: Jupyter es la herramienta estándar en ciencia de datos, machine learning y enseñanza de Python. Si alguna vez has visto un tutorial donde el código aparece en bloques numerados con su resultado debajo, casi seguro que es un cuaderno de Jupyter exportado.
Instalarlo
JupyterLab se distribuye como un paquete de PyPI, así que se instala con pip dentro de un entorno virtual, exactamente como cualquier otro paquete:
# crea un entorno dedicado para Jupyter
$ python3 -m venv ~/jupyter-env
# actívalo e instala JupyterLab
$ source ~/jupyter-env/bin/activate
(jupyter-env) $ pip install jupyterlab
Nota: conviene tener un entorno virtual específico para Jupyter, separado de los entornos de tus proyectos. Así puedes arrancar Jupyter desde cualquier carpeta sin tener que activar cada vez el entorno del proyecto correspondiente. Si más adelante necesitas usar paquetes de un proyecto concreto dentro de un cuaderno, hay formas de conectarlos, pero para empezar un entorno común para Jupyter es lo más sencillo.
Arrancarlo
Una vez instalado, puedes lanzar el servidor de JupyterLab así:
$ ~/jupyter-env/bin/jupyter labVerás algo así en la terminal:
To access the server, open this file in a browser:
file:///home/usuario/.local/share/jupyter/runtime/jpserver-XXXX-open.html
Or copy and paste one of these URLs:
http://localhost:8888/lab?token=...
El navegador debería abrirse solo en http://localhost:8888/lab. Si no lo hace, copia esa URL y pégala manualmente.
Nota: la terminal queda ocupada mientras JupyterLab está corriendo. Para parar el servidor, vuelve a esa terminal y pulsa Ctrl+C. Si necesitas otra terminal mientras tanto, abre una nueva.
Desde qué directorio arrancarlo
JupyterLab muestra en el panel lateral los archivos del directorio desde donde lo arrancas. Si lo lanzas desde tu carpeta personal (~), verás todos tus archivos de usuario; si lo lanzas desde otro sitio, verás los de ese otro sitio. Lo más cómodo es arrancarlo siempre desde la misma carpeta donde guardas tus cuadernos.
La interfaz
Al abrir JupyterLab en el navegador verás tres zonas principales:
| Zona | Qué es |
|---|---|
| Panel izquierdo | Explorador de archivos. Muestra los archivos y carpetas del directorio desde donde arrancaste JupyterLab. |
| Área central | Aquí se abren los cuadernos y las terminales. Puedes tener varios abiertos a la vez en pestañas. |
| Launcher | La pantalla de inicio (fondo oscuro con iconos grandes). Desde aquí creas un cuaderno nuevo o abres una terminal. |
Crear un cuaderno nuevo
En el Launcher, haz clic en Python 3 (ipykernel) bajo el apartado "Notebook". Se abre un cuaderno nuevo con una celda vacía lista para escribir.
Nota: el kernel es el intérprete de Python que ejecuta tu código. Cuando JupyterLab te pregunte qué kernel seleccionar, elige siempre Python 3 (ipykernel): es el que viene instalado por defecto con JupyterLab.
Las celdas: la pieza fundamental
Un cuaderno está formado por celdas. Cada celda es una cajita donde escribes código. Las ejecutas por separado y el resultado aparece justo debajo.
Así se ve una celda antes de ejecutarla:
In [ ]: print("hola, mundo")Después de ejecutar la celda (pulsando Shift+Enter):
In [1]: print("hola, mundo")
hola, mundo
El número entre corchetes ([1]) indica el orden en que fue ejecutada. Si la ejecutas otra vez se convierte en [2], y así sucesivamente. Es útil para saber qué orden seguiste, sobre todo cuando vuelves a un cuaderno días después.
El resultado de la última línea se muestra automáticamente
Si la última línea de una celda es un valor (no una instrucción), Jupyter lo muestra sin necesidad de print():
In [2]: 2 + 2
Out[2]: 4
Es una de las razones por las que Jupyter es tan cómodo para experimentar: puedes evaluar una expresión y ver el resultado al vuelo, como si fuera una calculadora.
Las celdas comparten memoria
Todo lo que defines en una celda (variables, funciones, imports) está disponible en las demás celdas del mismo cuaderno, siempre que las hayas ejecutado primero. Es como si fuera un único programa dividido en trozos:
In [3]: nombre = "Python"
In [4]: print(nombre) # funciona aunque está en otra celda
Python
Nota: ojo con el orden de ejecución. Las celdas no tienen que ejecutarse de arriba a abajo: puedes saltarlas, repetirlas o ejecutarlas en cualquier orden. Si algo falla de forma rara, suele ser porque el estado en memoria ya no se corresponde con lo que ves en pantalla. La solución: Kernel → Restart Kernel and Run All Cells para empezar de cero.
Dos modos: edición y comandos
JupyterLab tiene dos modos de funcionamiento. Saber en cuál estás evita muchas confusiones:
| Modo | Indicador visual | Para qué sirve |
|---|---|---|
| Edición | La celda tiene el cursor parpadeando dentro. Borde izquierdo azul. | Escribir código dentro de la celda. |
| Comandos | Ninguna celda está en edición. Borde izquierdo gris. | Navegar entre celdas, añadir, borrar, mover. |
Cambias entre uno y otro con dos teclas:
- Enter: pasa al modo edición (empieza a escribir en la celda seleccionada).
- Escape: sale del modo edición y vuelve al modo comandos.
Atajos de teclado esenciales
Estos funcionan en cualquier modo:
| Atajo | Qué hace |
|---|---|
Shift+Enter | Ejecuta la celda actual y pasa a la siguiente (o crea una nueva si era la última). |
Ctrl+Enter | Ejecuta la celda actual y se queda en ella. |
Alt+Enter | Ejecuta la celda actual e inserta una nueva justo debajo. |
Estos solo en modo comandos (pulsa Escape primero):
| Atajo | Qué hace |
|---|---|
A | Insertar celda arriba (above) de la actual. |
B | Insertar celda abajo (below) de la actual. |
D D | Borrar la celda actual (pulsa D dos veces seguidas). |
Z | Deshacer el borrado de celda. |
↑ / ↓ | Navegar entre celdas. |
M | Convertir la celda a Markdown (texto formateado, no código). |
Y | Convertir la celda a código Python. |
Nota: el atajo más importante con diferencia es Shift+Enter. Con ese solo puedes hacer el 90% del trabajo: escribes, ejecutas, bajas a la siguiente. El resto los aprendes cuando los necesitas.
Flujo de trabajo habitual
Una sesión típica de práctica con JupyterLab sigue más o menos este patrón:
- Arrancas JupyterLab desde la terminal:
~/jupyter-env/bin/jupyter lab - Creas un cuaderno nuevo desde el Launcher (Python 3).
- Escribes algo en la primera celda, por ejemplo una variable.
- Pulsas
Shift+Enter: se ejecuta y bajas a la siguiente celda. - Usas esa variable en la nueva celda, experimentas, ves el resultado.
- Repites. Si algo falla, corriges esa celda y la vuelves a ejecutar.
- Guardas el cuaderno con
Ctrl+Scuando quieras.
Nota: JupyterLab guarda el cuaderno automáticamente cada pocos minutos, así que el Ctrl+S es para guardar al instante pero no es urgente. Aun así, acostúmbrate a pulsarlo después de un cambio importante.
Reiniciar cuando algo va mal
Si las variables se mezclan, una celda da un error que no entiendes o el cuaderno se comporta de forma extraña, la solución más rápida es reiniciar el kernel. Equivale a empezar de cero, como si ejecutaras el código desde el principio:
Menú: Kernel → Restart Kernel and Run All Cells
Esto borra todas las variables de memoria y vuelve a ejecutar todas las celdas en orden, de arriba a abajo. Es la forma de comprobar que tu cuaderno realmente funciona "limpio", no solo gracias a un estado residual de pruebas anteriores.
Celdas de texto con Markdown
Puedes añadir celdas de texto (no de código) para organizarte. En modo comandos pulsa M para convertir una celda a Markdown, escribe un título y ejecuta con Shift+Enter:
# Variables y tipos
## Enteros
Aquí practico cómo funcionan los números enteros en Python.
El resultado es texto formateado, no código ejecutable. Muy útil para separar secciones y dejar notas a tu yo del futuro. Los cuadernos que mejor envejecen son los que alternan código y explicaciones, no los que son solo código.
Buenas costumbres
Algunos hábitos que ahorran disgustos cuando llevas un rato con esto:
- Celdas cortas, una idea por celda. Es tentador escribir mucho código en una sola celda. Mejor no: si algo falla tienes que releerlo todo. Una variable por celda, una función por celda. Más celdas, más control.
- Reinicia el kernel antes de dar algo por bueno. Si tu cuaderno solo funciona porque ejecutaste las celdas en un orden raro, no funciona de verdad. Reinicia y reproduce desde cero antes de compartirlo o usarlo de referencia.
- El cuaderno no es un script. Un cuaderno de Jupyter no es lo mismo que un archivo
.py. Está pensado para explorar e ir paso a paso. Cuando ya tienes el código claro y quieres que sea un programa que se ejecute solo, lo pasas a un.py. Son herramientas distintas para momentos distintos.
Nota: regla útil para aprender: usa JupyterLab para probar, romper cosas, ver qué pasa. Cuando ya tengas algo que funciona y quieras que sea un programa de verdad, mueve el código a un archivo .py.
- Anterior « Manejo de paquetes
- Siguiente Fin del tema »