Cómo instalar e iniciar JupyterLab: La guía completa

Name

Soren Atelier

Updated on 13/2/2026

Configurar un entorno de desarrollo Python para ciencia de datos debería ser sencillo, pero los nuevos usuarios frecuentemente se encuentran con obstáculos: gestores de paquetes en conflicto, variables PATH rotas, errores de permisos y consejos confusos dispersos en publicaciones de foros desactualizadas. Una instalación mal configurada puede hacerte perder horas antes de escribir una sola línea de código.

La frustración se multiplica cuando los comandos de Jupyter fallan silenciosamente, los kernels se niegan a conectar o el navegador nunca se abre. Incluso los desarrolladores experimentados encuentran problemas al cambiar de máquina o configurar servidores remotos. Sin una referencia clara, el proceso de poner JupyterLab en funcionamiento se siente más difícil de lo necesario.

Esta guía resuelve eso. Cubre cómo instalar JupyterLab con pip y conda, cómo iniciar JupyterLab en cada sistema operativo principal y cómo configurarlo para un trabajo productivo. Ya sea que estés abriendo JupyterLab por primera vez o solucionando problemas de una instalación rota, sigue estos pasos y tendrás un entorno funcional en minutos.

¿Qué es JupyterLab?

JupyterLab es el entorno de desarrollo interactivo basado en web de próxima generación del Proyecto Jupyter. Reemplaza la interfaz clásica de Jupyter Notebook con un espacio de trabajo modular y extensible donde puedes editar notebooks, escribir scripts, usar una terminal, explorar archivos y ver resultados de datos, todo en una sola ventana del navegador.

Las características principales de JupyterLab incluyen:

• Diseño multipanel: Abre notebooks, terminales, vistas previas de CSV y documentación lado a lado con disposición de arrastrar y soltar.
• Explorador de archivos integrado: Navega por los directorios del proyecto, crea carpetas, sube archivos y renombra recursos sin salir de la interfaz.
• Terminal integrada: Ejecuta comandos de shell directamente dentro de JupyterLab sin cambiar a una terminal externa.
• Edición de texto enriquecido: Edita archivos Markdown con vista previa en vivo, trabaja con JSON y visualiza imágenes de forma nativa.
• Sistema de extensiones: Añade funcionalidades como integración con Git, formateo de código, soporte para servidores de lenguaje y temas personalizados a través de extensiones instalables con pip.
• Soporte para múltiples kernels: Ejecuta kernels de Python, R, Julia y otros lenguajes en el mismo espacio de trabajo.

JupyterLab es la interfaz predeterminada que se incluye con las instalaciones modernas de Jupyter. Cuando ejecutas jupyter lab, se lanza la interfaz de JupyterLab. Es el entorno recomendado para ciencia de datos, aprendizaje automático, computación científica y desarrollo interactivo de Python en 2026.

JupyterLab vs Jupyter Notebook

Muchos usuarios se preguntan si deberían usar JupyterLab o el clásico Jupyter Notebook. La respuesta corta: JupyterLab es el sucesor moderno. El equipo de Jupyter ha designado a JupyterLab como la interfaz principal de aquí en adelante, y Jupyter Notebook 7 ahora comparte la misma tecnología subyacente (componentes de JupyterLab).

Aquí tienes una comparación directa:

Cuándo elegir JupyterLab: Para cualquier proyecto nuevo. Proporciona todo lo que ofrece Jupyter Notebook más un espacio de trabajo más capaz. Si trabajas con múltiples archivos, necesitas una terminal o quieres extensiones, JupyterLab es la opción clara.

Cuándo quedarse con Notebook: Si estás ejecutando herramientas heredadas que solo soportan la interfaz clásica de Notebook, o si necesitas la interfaz más simple posible para enseñar cursos de programación introductoria.

Cómo instalar JupyterLab

Antes de instalar JupyterLab, necesitas Python 3.8 o posterior y un gestor de paquetes (pip o conda). Las secciones siguientes cubren cada ruta de instalación común.

Instalar JupyterLab con pip (Recomendado)

pip es el gestor de paquetes predeterminado de Python y la forma más rápida de instalar JupyterLab. Abre tu terminal (Símbolo del sistema o PowerShell en Windows, Terminal en macOS/Linux) y ejecuta:

pip install jupyterlab

Este comando descarga e instala la última versión estable de JupyterLab junto con todas las dependencias requeridas. Para verificar la instalación:

jupyter lab --version

Deberías ver una salida de versión como 4.3.x o superior. Si pip no es reconocido, puede que necesites usar pip3 en su lugar:

pip3 install jupyterlab

Para actualizar una instalación existente de JupyterLab a la última versión:

pip install --upgrade jupyterlab

Instalar JupyterLab con Conda (Anaconda/Miniconda)

Si usas Anaconda o Miniconda para la gestión de paquetes, instala JupyterLab desde el canal conda-forge:

conda install -c conda-forge jupyterlab

Este enfoque es popular entre los científicos de datos porque conda gestiona tanto paquetes de Python como dependencias que no son de Python (como bibliotecas C) que algunos paquetes científicos requieren.

Para instalar JupyterLab en un entorno conda dedicado:

conda create --name jupyter-env python=3.12
conda activate jupyter-env
conda install -c conda-forge jupyterlab

Verifica la instalación:

jupyter lab --version

Instalación paso a paso en Windows

Sigue estos pasos para instalar JupyterLab en Windows desde cero:

Paso 1: Instalar Python

Descarga el instalador más reciente de Python desde python.org/downloads (opens in a new tab). Durante la instalación, marca la casilla que dice "Add Python to PATH" -- esto es fundamental. Sin esto, los comandos python y pip no funcionarán en tu terminal.

Paso 2: Abrir una terminal

Presiona Win + R, escribe cmd y presiona Enter. Alternativamente, busca "PowerShell" en el menú Inicio.

Paso 3: Verificar Python y pip

python --version
pip --version

Ambos comandos deberían devolver números de versión. Si python no es reconocido, reinstala Python con la opción de PATH habilitada.

Paso 4: Instalar JupyterLab

pip install jupyterlab

Paso 5: Iniciar JupyterLab

jupyter lab

Tu navegador web predeterminado se abre automáticamente con la interfaz de JupyterLab.

Instalación en macOS

macOS incluye Python en la mayoría de las versiones, pero el Python del sistema suele estar desactualizado. Usa Homebrew o pyenv para una configuración limpia.

Opción A: Usando Homebrew

brew install python
pip3 install jupyterlab

Opción B: Usando el instalador oficial

Descarga Python desde python.org/downloads (opens in a new tab) y ejecuta el instalador .pkg. Luego:

pip3 install jupyterlab

Opción C: Usando pyenv

brew install pyenv
pyenv install 3.12
pyenv global 3.12
pip install jupyterlab

Iniciar JupyterLab:

jupyter lab

Instalación en Linux (Ubuntu/Debian)

La mayoría de las distribuciones de Linux incluyen Python 3 por defecto. Instala pip y JupyterLab:

sudo apt update
sudo apt install python3 python3-pip python3-venv
pip3 install jupyterlab

En Fedora/RHEL:

sudo dnf install python3 python3-pip
pip3 install jupyterlab

En Arch Linux:

sudo pacman -S python python-pip
pip install jupyterlab

Si tu distribución restringe las instalaciones de pip a nivel del sistema (PEP 668), crea un entorno virtual primero:

python3 -m venv ~/jupyter-env
source ~/jupyter-env/bin/activate
pip install jupyterlab
jupyter lab

Cómo iniciar JupyterLab

Una vez que JupyterLab está instalado, iniciarlo requiere un solo comando. Esta sección cubre todas las formas de iniciar y configurar JupyterLab.

Inicio básico

Abre tu terminal y ejecuta:

jupyter lab

JupyterLab inicia un servidor web local (típicamente en el puerto 8888) y abre la interfaz en tu navegador predeterminado. La terminal muestra una URL con un token de autenticación:

http://localhost:8888/lab?token=abc123...

Mantén la terminal abierta mientras trabajas. Cerrarla apaga el servidor de JupyterLab.

Iniciar JupyterLab en un directorio específico

Por defecto, JupyterLab se abre en el directorio donde ejecutaste el comando. Para iniciarlo en una carpeta de proyecto específica:

jupyter lab --notebook-dir=/path/to/your/project

En Windows:

jupyter lab --notebook-dir=C:\Users\YourName\Projects\data-analysis

Esto es útil cuando quieres mantener el explorador de archivos de JupyterLab enfocado en un proyecto particular.

Usar un puerto personalizado

Si el puerto 8888 ya está en uso, especifica un puerto diferente:

jupyter lab --port=9999

JupyterLab estará disponible en http://localhost:9999/lab.

Iniciar sin abrir el navegador

Para iniciar el servidor sin abrir automáticamente una ventana del navegador:

jupyter lab --no-browser

Esto es útil en servidores remotos o cuando prefieres navegar manualmente a la URL. Copia la URL de la salida de la terminal y pégala en cualquier navegador.

Abrir JupyterLab en un navegador específico

Para forzar que JupyterLab se abra en un navegador específico:

jupyter lab --browser=firefox

o

jupyter lab --browser=chrome

Iniciar JupyterLab en todas las interfaces de red

Para acceder a JupyterLab desde otros dispositivos en la misma red (por ejemplo, un servidor remoto):

jupyter lab --ip=0.0.0.0 --port=8888 --no-browser

Luego conéctate desde otra máquina usando la dirección IP del servidor.

Resumen de inicio

Cómo usar JupyterLab

Después de abrir JupyterLab, la interfaz presenta una pestaña de inicio con opciones para crear nuevos notebooks, abrir una consola, iniciar una terminal o crear archivos de texto. Esta sección cubre los flujos de trabajo esenciales.

Crear y ejecutar notebooks

1. Haz clic en Python 3 en la sección "Notebook" del Lanzador, o ve a File > New > Notebook.
2. Selecciona un kernel cuando se te solicite (generalmente "Python 3").
3. Se abre un nuevo notebook .ipynb con una celda de código vacía.

Escribe código Python en la celda y presiona Shift + Enter para ejecutarlo. La salida aparece directamente debajo de la celda.

import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Score': [85, 92, 78]
})
df

Trabajar con celdas

Los notebooks de JupyterLab usan dos tipos principales de celdas:

Celdas de código: Ejecutan código Python (u otro lenguaje del kernel). Los resultados se muestran en línea.

Celdas Markdown: Escriben texto formateado usando sintaxis Markdown. Cambia el tipo de celda usando el menú desplegable en la barra de herramientas o presiona M en modo comando.

Para añadir una nueva celda, haz clic en el botón + de la barra de herramientas o presiona B (debajo) o A (arriba) en modo comando. Elimina una celda presionando D dos veces en modo comando.

Atajos de teclado

JupyterLab tiene dos modos: Modo comando (presiona Escape, borde de celda azul) y Modo edición (presiona Enter, borde de celda verde). Aquí están los atajos de teclado más útiles:

Puedes personalizar los atajos de teclado a través de Settings > Advanced Settings Editor > Keyboard Shortcuts.

Usar el explorador de archivos

La barra lateral izquierda contiene un explorador de archivos que muestra el contenido del directorio donde se inició JupyterLab. Puedes:

• Navegar carpetas haciendo clic
• Crear nuevos archivos y carpetas con el menú contextual del clic derecho
• Subir archivos arrastrándolos al explorador
• Renombrar archivos con clic derecho > Rename
• Eliminar archivos con clic derecho > Delete

Terminal integrada

Para abrir una terminal dentro de JupyterLab, ve a File > New > Terminal o haz clic en Terminal en el Lanzador. Esto te da un shell completo (bash, zsh o PowerShell dependiendo de tu sistema operativo) sin salir de la interfaz de JupyterLab.

La terminal integrada es útil para:

• Instalar paquetes con pip o conda
• Ejecutar scripts
• Usar comandos de Git
• Gestionar archivos

Paneles múltiples y vista dividida

JupyterLab soporta flujos de trabajo con pantalla dividida. Arrastra cualquier pestaña (notebook, terminal, archivo) al borde del espacio de trabajo para crear un diseño lado a lado. Puedes organizar paneles horizontal o verticalmente.

Configuraciones comunes de vista dividida:

• Notebook + Terminal: Escribe código en un notebook mientras ejecutas comandos en una terminal
• Dos Notebooks: Compara resultados lado a lado
• Notebook + Vista previa de CSV: Visualiza archivos de datos mientras programas
• Notebook + Vista previa de Markdown: Escribe documentación con vista previa en vivo

Solución de problemas de JupyterLab

Estos son los problemas más comunes que los usuarios encuentran al intentar ejecutar JupyterLab, junto con sus soluciones.

"jupyter: command not found"

Esto significa que el ejecutable jupyter no está en el PATH de tu sistema. Soluciones comunes:

Verificar si JupyterLab está instalado:

pip show jupyterlab

Si no aparece nada, instálalo:

pip install jupyterlab

Usar la ruta completa del módulo Python:

python -m jupyter lab

Añadir el directorio de scripts de pip al PATH (común en Linux/macOS):

export PATH="$HOME/.local/bin:$PATH"

Añade esta línea a tu ~/.bashrc o ~/.zshrc para hacerlo permanente.

Windows: Si instalaste Python sin marcar "Add to PATH", reinstala Python con esa opción habilitada, o añade manualmente C:\Users\TuNombre\AppData\Local\Programs\Python\Python312\Scripts al PATH de tu sistema.

Puerto ya en uso

Si ves "OSError: [Errno 98] Address already in use":

jupyter lab --port=8889

O encuentra y detén el proceso Jupyter existente:

jupyter lab list
jupyter lab stop 8888

En Linux/macOS, también puedes encontrar el proceso que usa el puerto:

lsof -i :8888
kill -9 <PID>

Errores de permisos

Si la instalación con pip falla con errores de permisos, evita usar sudo pip install. En su lugar, usa la bandera --user:

pip install --user jupyterlab

O mejor aún, usa un entorno virtual (cubierto más abajo).

Kernel no encontrado

Si tu notebook dice "Kernel not found" o falta el kernel de Python:

pip install ipykernel
python -m ipykernel install --user

Para un kernel de entorno virtual:

python -m ipykernel install --user --name=myenv --display-name="Python (myenv)"

JupyterLab no se abre en el navegador

Si el servidor se inicia pero no aparece ninguna ventana del navegador:

1. Copia la URL de la salida de la terminal (incluyendo el token).
2. Pégala directamente en tu navegador.
3. Si estás ejecutando en un servidor remoto, usa reenvío de puertos SSH:

ssh -L 8888:localhost:8888 user@remote-server

Luego abre http://localhost:8888/lab en tu máquina local.

JupyterLab muestra una página en blanco

Limpia la caché de tu navegador o prueba con un navegador diferente. También puedes restablecer el espacio de trabajo de JupyterLab:

jupyter lab --LabApp.default_url='/lab?reset'

Extensiones de JupyterLab

JupyterLab 4.x usa un sistema de extensiones simplificado donde la mayoría de las extensiones se instalan vía pip sin necesidad de Node.js. Aquí están las extensiones más útiles para trabajo en ciencia de datos.

jupyterlab-git

Integración completa de Git dentro de JupyterLab. Visualiza diferencias, prepara cambios, confirma, envía y recibe sin salir de la interfaz.

pip install jupyterlab-git

Después de la instalación, aparece una pestaña de Git en la barra lateral izquierda.

jupyterlab-lsp

Soporte del Protocolo de Servidor de Lenguaje que añade autocompletado, documentación al pasar el cursor, ir a definición y análisis de código para Python y otros lenguajes.

pip install jupyterlab-lsp python-lsp-server[all]

jupyterlab_code_formatter

Formatea automáticamente las celdas de código usando formateadores como black o isort.

pip install jupyterlab-code-formatter black isort

Después de la instalación, formatea celdas mediante el botón de la barra de herramientas o un atajo de teclado.

Extensiones de temas

Personaliza la apariencia de JupyterLab:

pip install jupyterlab_darkside_ui    # Tema oscuro
pip install jupyterlab-night          # Tema nocturno

Cambia de tema vía Settings > Theme.

Gestionar extensiones

Listar todas las extensiones instaladas:

jupyter labextension list

Desinstalar una extensión:

pip uninstall jupyterlab-git

Potencia tu visualización de datos: PyGWalker

JupyterLab es un entorno poderoso para escribir y ejecutar código, pero la visualización interactiva de datos a menudo requiere escribir código de gráficos repetitivo. PyGWalker es una biblioteca Python de código abierto que convierte cualquier DataFrame de pandas o polars en una interfaz de visualización interactiva similar a Tableau directamente dentro de JupyterLab.

En lugar de escribir código de matplotlib o seaborn para cada gráfico, puedes explorar tus datos visualmente con arrastrar y soltar:

pip install pygwalker

import pygwalker as pyg
import pandas as pd
 
df = pd.read_csv("your_data.csv")
pyg.walk(df)

Este único comando renderiza una interfaz interactiva donde puedes crear gráficos de barras, diagramas de dispersión, histogramas, mapas de calor y más sin escribir código de gráficos. Soporta filtrado, agregación y múltiples tipos de gráficos -- ideal para análisis exploratorio de datos en JupyterLab.

Aprende más en github.com/Kanaries/pygwalker (opens in a new tab).

Si quieres ir más allá con la automatización potenciada por IA en Jupyter, prueba RunCell (www.runcell.dev (opens in a new tab)) -- un agente de IA que se ejecuta dentro de Jupyter y automatiza tareas repetitivas de notebooks como limpieza de datos, ingeniería de características y visualización. Entiende el contexto de tus datos y genera celdas de código por ti.

Configurar JupyterLab en un entorno virtual

Ejecutar JupyterLab dentro de un entorno virtual es la práctica recomendada. Mantiene las dependencias de tu proyecto aisladas y evita conflictos con otras instalaciones de Python.

Usando Python venv

# Create a virtual environment
python -m venv jupyter-env
 
# Activate it
# macOS/Linux:
source jupyter-env/bin/activate
# Windows:
jupyter-env\Scripts\activate
 
# Install JupyterLab
pip install jupyterlab
 
# Start JupyterLab
jupyter lab

Cuando termines de trabajar, desactiva el entorno:

deactivate

Usando virtualenv

pip install virtualenv
virtualenv jupyter-env
source jupyter-env/bin/activate   # macOS/Linux
pip install jupyterlab
jupyter lab

Usando entornos Conda

conda create --name jupyter-env python=3.12
conda activate jupyter-env
conda install -c conda-forge jupyterlab
jupyter lab

Hacer un entorno virtual disponible como kernel

Si tienes JupyterLab instalado globalmente pero quieres usar paquetes de un entorno virtual, registra el entorno como un kernel:

# Inside the activated virtual environment:
pip install ipykernel
python -m ipykernel install --user --name=jupyter-env --display-name="Python (jupyter-env)"

Ahora cuando crees un nuevo notebook en JupyterLab, puedes seleccionar "Python (jupyter-env)" como kernel.

Ejecutar JupyterLab con Docker

Docker proporciona una forma limpia y reproducible de ejecutar JupyterLab sin instalar nada en tu sistema anfitrión. El proyecto Jupyter mantiene imágenes oficiales de Docker.

Inicio rápido

docker run -p 8888:8888 jupyter/base-notebook

Esto descarga y ejecuta la imagen base de Jupyter. La salida de la terminal contiene una URL con un token. Abre esa URL en tu navegador.

Montar un directorio local

Para acceder a tus archivos locales dentro del contenedor:

docker run -p 8888:8888 -v /path/to/your/project:/home/jovyan/work jupyter/base-notebook

En Windows:

docker run -p 8888:8888 -v C:\Users\YourName\project:/home/jovyan/work jupyter/base-notebook

Imágenes Docker disponibles

Dockerfile personalizado

Crea un Dockerfile para un entorno JupyterLab específico del proyecto:

FROM jupyter/scipy-notebook:latest
 
# Install additional packages
RUN pip install pygwalker seaborn scikit-learn
 
# Set the working directory
WORKDIR /home/jovyan/work
 
# Expose the Jupyter port
EXPOSE 8888
 
CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]

Construir y ejecutar:

docker build -t my-jupyter .
docker run -p 8888:8888 -v $(pwd):/home/jovyan/work my-jupyter

Docker Compose

Para proyectos que combinan JupyterLab con otros servicios (bases de datos, APIs):

version: '3'
services:
  jupyter:
    image: jupyter/scipy-notebook
    ports:
      - "8888:8888"
    volumes:
      - ./notebooks:/home/jovyan/work
    environment:
      - JUPYTER_ENABLE_LAB=yes

docker compose up

Gestionar múltiples kernels de Python

Cuando trabajas en múltiples proyectos con diferentes versiones de Python o conjuntos de paquetes, puedes registrar cada entorno como un kernel separado en JupyterLab.

Añadir un kernel desde un entorno virtual

# Create and activate a new environment
python -m venv ml-project
source ml-project/bin/activate    # macOS/Linux
ml-project\Scripts\activate       # Windows
 
# Install the required packages
pip install ipykernel numpy pandas scikit-learn
 
# Register this environment as a Jupyter kernel
python -m ipykernel install --user --name=ml-project --display-name="Python (ML Project)"

Añadir un kernel desde un entorno Conda

conda create --name data-analysis python=3.11 pandas matplotlib
conda activate data-analysis
conda install ipykernel
python -m ipykernel install --user --name=data-analysis --display-name="Python (Data Analysis)"

Listar kernels instalados

jupyter kernelspec list

Eliminar un kernel

jupyter kernelspec remove ml-project

Cambiar kernels en un notebook

Dentro de un notebook abierto, haz clic en el nombre del kernel en la esquina superior derecha (por ejemplo, "Python 3") y selecciona un kernel diferente del menú desplegable. También puedes ir a Kernel > Change Kernel en la barra de menú.

Preguntas frecuentes

¿Cómo inicio JupyterLab?

Abre una terminal y ejecuta jupyter lab. El servidor de JupyterLab se inicia y tu navegador predeterminado se abre automáticamente. Para iniciar en una carpeta específica, usa jupyter lab --notebook-dir=/ruta/a/la/carpeta.

¿Cómo instalo JupyterLab con pip?

Ejecuta pip install jupyterlab en tu terminal. Usa pip3 en sistemas donde pip apunta a Python 2. Verifica con jupyter lab --version.

¿Cómo instalo JupyterLab con conda?

Ejecuta conda install -c conda-forge jupyterlab. Para una configuración limpia, crea un entorno conda dedicado primero.

¿Cuál es la diferencia entre JupyterLab y Jupyter Notebook?

JupyterLab es la interfaz de próxima generación con diseño multipanel, terminal integrada, explorador de archivos y extensiones. Jupyter Notebook es la interfaz original de documento único. JupyterLab es recomendado para proyectos nuevos.

¿Cómo soluciono "jupyter: command not found"?

Verifica la instalación con pip show jupyterlab. Si está instalado, intenta python -m jupyter lab. De lo contrario, añade el directorio de scripts de pip al PATH de tu sistema.

¿Cómo ejecuto JupyterLab en un entorno virtual?

Crea un venv con python -m venv myenv, actívalo, instala JupyterLab con pip install jupyterlab y ejecuta jupyter lab.

¿Cómo ejecuto JupyterLab con Docker?

Ejecuta docker run -p 8888:8888 jupyter/base-notebook. Monta archivos locales con la bandera -v para almacenamiento persistente.

¿Cómo abro JupyterLab en un puerto diferente?

Usa jupyter lab --port=9999 para iniciar en el puerto 9999 en lugar del predeterminado 8888.

Conclusión

JupyterLab es el entorno de desarrollo interactivo estándar para ciencia de datos con Python, aprendizaje automático y computación científica. Esta guía cubrió cada paso desde la instalación hasta la configuración avanzada:

• Instalar JupyterLab con pip install jupyterlab o conda install -c conda-forge jupyterlab
• Iniciar JupyterLab con jupyter lab y personalizar el inicio con banderas para puerto, directorio y navegador
• Usar JupyterLab eficazmente con atajos de teclado, vistas divididas y la terminal integrada
• Solucionar problemas comunes como comando no encontrado, conflictos de puertos y errores de kernel
• Extender JupyterLab con integración de Git, soporte LSP y formateo de código
• Aislar tu configuración con entornos virtuales y Docker para flujos de trabajo reproducibles

Ya seas un usuario de Python por primera vez o un científico de datos experimentado configurando una nueva máquina, estos pasos te dan un entorno JupyterLab completamente funcional. Para visualización interactiva de datos dentro de JupyterLab, prueba PyGWalker (opens in a new tab) para convertir cualquier DataFrame en una herramienta de análisis visual de arrastrar y soltar.