Como Instalar e Iniciar o JupyterLab: O Guia Completo

Name

Soren Atelier

Updated on 13/02/2026

Configurar um ambiente de desenvolvimento Python para ciência de dados deveria ser simples, mas novos usuários frequentemente encontram obstáculos: gerenciadores de pacotes conflitantes, variáveis PATH quebradas, erros de permissão e conselhos confusos espalhados por posts desatualizados em fóruns. Uma instalação mal configurada pode desperdiçar horas antes de você escrever uma única linha de código.

A frustração se acumula quando comandos do Jupyter falham silenciosamente, kernels se recusam a conectar ou o navegador nunca abre. Até desenvolvedores experientes enfrentam problemas ao trocar de máquina ou configurar servidores remotos. Sem uma referência clara, o processo de colocar o JupyterLab em funcionamento parece mais difícil do que deveria ser.

Este guia resolve isso. Ele abrange como instalar o JupyterLab com pip e conda, como iniciar o JupyterLab em todos os principais sistemas operacionais e como configurá-lo para um trabalho produtivo. Esteja você abrindo o JupyterLab pela primeira vez ou resolvendo problemas em uma instalação com defeito, siga estes passos e você terá um ambiente funcionando em minutos.

O Que É o JupyterLab?

O JupyterLab é o ambiente de desenvolvimento interativo baseado em web de próxima geração do Projeto Jupyter. Ele substitui a interface clássica do Jupyter Notebook por um espaço de trabalho modular e extensível onde você pode editar notebooks, escrever scripts, usar um terminal, navegar por arquivos e visualizar saídas de dados -- tudo em uma única janela do navegador.

Os principais recursos do JupyterLab incluem:

• Layout com múltiplos painéis: Abra notebooks, terminais, visualizações de CSV e documentação lado a lado com organização por arrastar e soltar.
• Navegador de arquivos integrado: Navegue por diretórios de projetos, crie pastas, faça upload de arquivos e renomeie recursos sem sair da interface.
• Terminal integrado: Execute comandos shell diretamente dentro do JupyterLab sem alternar para um terminal externo.
• Edição de texto rico: Edite arquivos Markdown com visualização ao vivo, trabalhe com JSON e visualize imagens nativamente.
• Sistema de extensões: Adicione funcionalidades como integração com Git, formatação de código, suporte a Language Server e temas personalizados através de extensões instaláveis via pip.
• Suporte a múltiplos kernels: Execute kernels de Python, R, Julia e outras linguagens no mesmo espaço de trabalho.

O JupyterLab é a interface padrão distribuída com instalações modernas do Jupyter. Quando você executa jupyter lab, ele inicia a interface do JupyterLab. É o ambiente recomendado para ciência de dados, aprendizado de máquina, computação científica e desenvolvimento interativo em Python em 2026.

JupyterLab vs Jupyter Notebook

Muitos usuários se perguntam se devem usar o JupyterLab ou o Jupyter Notebook clássico. A resposta curta: o JupyterLab é o sucessor moderno. A equipe do Jupyter designou o JupyterLab como a interface principal daqui em diante, e o Jupyter Notebook 7 agora compartilha a mesma tecnologia subjacente (componentes do JupyterLab).

Aqui está uma comparação direta:

Quando escolher o JupyterLab: Para qualquer projeto novo. Ele oferece tudo que o Jupyter Notebook oferece, além de um espaço de trabalho mais capaz. Se você trabalha com múltiplos arquivos, precisa de um terminal ou deseja extensões, o JupyterLab é a escolha clara.

Quando ficar com o Notebook: Se você está executando ferramentas legadas que suportam apenas a interface clássica do Notebook, ou se precisa da UI mais simples possível para ensinar cursos introdutórios de programação.

Como Instalar o JupyterLab

Antes de instalar o JupyterLab, você precisa do Python 3.8 ou superior e de um gerenciador de pacotes (pip ou conda). As seções abaixo cobrem todos os caminhos de instalação comuns.

Instalar o JupyterLab com pip (Recomendado)

O pip é o gerenciador de pacotes padrão do Python e a forma mais rápida de instalar o JupyterLab. Abra seu terminal (Prompt de Comando ou PowerShell no Windows, Terminal no macOS/Linux) e execute:

pip install jupyterlab

Este comando baixa e instala a versão estável mais recente do JupyterLab junto com todas as dependências necessárias. Para verificar a instalação:

jupyter lab --version

Você deve ver a saída da versão como 4.3.x ou superior. Se o pip não for reconhecido, pode ser necessário usar pip3:

pip3 install jupyterlab

Para atualizar uma instalação existente do JupyterLab para a versão mais recente:

pip install --upgrade jupyterlab

Instalar o JupyterLab com Conda (Anaconda/Miniconda)

Se você usa Anaconda ou Miniconda para gerenciamento de pacotes, instale o JupyterLab pelo canal conda-forge:

conda install -c conda-forge jupyterlab

Esta abordagem é popular entre cientistas de dados porque o conda gerencia tanto pacotes Python quanto dependências não-Python (como bibliotecas C) que alguns pacotes científicos requerem.

Para instalar o JupyterLab em um ambiente conda dedicado:

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

Verifique a instalação:

jupyter lab --version

Instalação no Windows Passo a Passo

Siga estes passos para instalar o JupyterLab no Windows do zero:

Passo 1: Instale o Python

Baixe o instalador mais recente do Python em python.org/downloads (opens in a new tab). Durante a instalação, marque a caixa que diz "Add Python to PATH" -- isso é fundamental. Sem isso, os comandos python e pip não funcionarão no seu terminal.

Passo 2: Abra um terminal

Pressione Win + R, digite cmd e pressione Enter. Alternativamente, pesquise por "PowerShell" no menu Iniciar.

Passo 3: Verifique o Python e o pip

python --version
pip --version

Ambos os comandos devem retornar números de versão. Se o python não for reconhecido, reinstale o Python com a opção PATH habilitada.

Passo 4: Instale o JupyterLab

pip install jupyterlab

Passo 5: Inicie o JupyterLab

jupyter lab

Seu navegador padrão abre automaticamente com a interface do JupyterLab.

Instalação no macOS

O macOS vem com Python na maioria das versões, mas o Python do sistema geralmente está desatualizado. Use Homebrew ou pyenv para uma configuração limpa.

Opção A: Usando Homebrew

brew install python
pip3 install jupyterlab

Opção B: Usando o instalador oficial

Baixe o Python em python.org/downloads (opens in a new tab) e execute o instalador .pkg. Em seguida:

pip3 install jupyterlab

Opção C: Usando pyenv

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

Inicie o JupyterLab:

jupyter lab

Instalação no Linux (Ubuntu/Debian)

A maioria das distribuições Linux inclui o Python 3 por padrão. Instale o pip e o JupyterLab:

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

No Fedora/RHEL:

sudo dnf install python3 python3-pip
pip3 install jupyterlab

No Arch Linux:

sudo pacman -S python python-pip
pip install jupyterlab

Se sua distribuição restringe instalações via pip no nível do sistema (PEP 668), crie um ambiente virtual primeiro:

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

Como Iniciar o JupyterLab

Uma vez que o JupyterLab está instalado, iniciá-lo requer um único comando. Esta seção cobre todas as formas de iniciar e configurar o JupyterLab.

Inicialização Básica

Abra seu terminal e execute:

jupyter lab

O JupyterLab inicia um servidor web local (normalmente na porta 8888) e abre a interface no seu navegador padrão. O terminal exibe uma URL com um token de autenticação:

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

Mantenha o terminal aberto enquanto trabalha. Fechá-lo desliga o servidor do JupyterLab.

Iniciar o JupyterLab em um Diretório Específico

Por padrão, o JupyterLab abre no diretório onde você executou o comando. Para iniciá-lo em uma pasta de projeto específica:

jupyter lab --notebook-dir=/caminho/para/seu/projeto

No Windows:

jupyter lab --notebook-dir=C:\Users\SeuNome\Projetos\analise-dados

Isso é útil quando você deseja manter o navegador de arquivos do JupyterLab focado em um projeto específico.

Usar uma Porta Personalizada

Se a porta 8888 já estiver em uso, especifique uma porta diferente:

jupyter lab --port=9999

O JupyterLab estará então disponível em http://localhost:9999/lab.

Iniciar Sem Abrir o Navegador

Para iniciar o servidor sem abrir automaticamente uma janela do navegador:

jupyter lab --no-browser

Isso é útil em servidores remotos ou quando você prefere navegar manualmente até a URL. Copie a URL da saída do terminal e cole-a em qualquer navegador.

Abrir o JupyterLab em um Navegador Específico

Para forçar o JupyterLab a abrir em um navegador específico:

jupyter lab --browser=firefox

ou

jupyter lab --browser=chrome

Iniciar o JupyterLab em Todas as Interfaces de Rede

Para acessar o JupyterLab a partir de outros dispositivos na mesma rede (por exemplo, um servidor remoto):

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

Em seguida, conecte-se de outra máquina usando o endereço IP do servidor.

Resumo de Inicialização

Como Usar o JupyterLab

Após abrir o JupyterLab, a interface apresenta uma aba de lançamento com opções para criar novos notebooks, abrir um console, iniciar um terminal ou criar arquivos de texto. Esta seção cobre os fluxos de trabalho essenciais.

Criando e Executando Notebooks

1. Clique em Python 3 na seção "Notebook" no Lançador, ou vá em File > New > Notebook.
2. Selecione um kernel quando solicitado (geralmente "Python 3").
3. Um novo notebook .ipynb abre com uma célula de código vazia.

Digite código Python na célula e pressione Shift + Enter para executá-lo. A saída aparece diretamente abaixo da célula.

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

Trabalhando com Células

Os notebooks do JupyterLab usam dois tipos principais de células:

Células de código: Executam código Python (ou outra linguagem do kernel). Os resultados são exibidos inline.

Células Markdown: Escrevem texto formatado usando sintaxe Markdown. Altere o tipo de célula usando o dropdown na barra de ferramentas ou pressione M no modo de comando.

Para adicionar uma nova célula, clique no botão + na barra de ferramentas ou pressione B (abaixo) ou A (acima) no modo de comando. Delete uma célula pressionando D duas vezes no modo de comando.

Atalhos de Teclado

O JupyterLab possui dois modos: Modo de comando (pressione Escape, borda da célula azul) e Modo de edição (pressione Enter, borda da célula verde). Aqui estão os atalhos de teclado mais úteis:

Você pode personalizar atalhos de teclado em Settings > Advanced Settings Editor > Keyboard Shortcuts.

Usando o Navegador de Arquivos

A barra lateral esquerda contém um navegador de arquivos que mostra o conteúdo do diretório onde o JupyterLab foi iniciado. Você pode:

• Navegar por pastas clicando
• Criar novos arquivos e pastas com o menu de contexto do botão direito
• Fazer upload de arquivos arrastando-os para o navegador
• Renomear arquivos com botão direito > Rename
• Deletar arquivos com botão direito > Delete

Terminal Integrado

Para abrir um terminal dentro do JupyterLab, vá em File > New > Terminal ou clique em Terminal no Lançador. Isso fornece um shell completo (bash, zsh ou PowerShell dependendo do seu SO) sem sair da interface do JupyterLab.

O terminal integrado é útil para:

• Instalar pacotes com pip ou conda
• Executar scripts
• Usar comandos Git
• Gerenciar arquivos

Múltiplos Painéis e Visualização Dividida

O JupyterLab suporta fluxos de trabalho em tela dividida. Arraste qualquer aba (notebook, terminal, arquivo) para a borda do espaço de trabalho para criar um layout lado a lado. Você pode organizar painéis horizontalmente ou verticalmente.

Configurações comuns de visualização dividida:

• Notebook + Terminal: Escreva código em um notebook enquanto executa comandos em um terminal
• Dois Notebooks: Compare resultados lado a lado
• Notebook + Visualização de CSV: Visualize arquivos de dados enquanto codifica
• Notebook + Visualização de Markdown: Escreva documentação com pré-visualização ao vivo

Solução de Problemas do JupyterLab

Estes são os problemas mais comuns que os usuários encontram ao tentar executar o JupyterLab, junto com suas soluções.

"jupyter: command not found"

Isso significa que o executável jupyter não está no PATH do seu sistema. Correções comuns:

Verifique se o JupyterLab está instalado:

pip show jupyterlab

Se nada aparecer, instale-o:

pip install jupyterlab

Use o caminho completo do módulo Python:

python -m jupyter lab

Adicione o diretório de scripts do pip ao PATH (comum no Linux/macOS):

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

Adicione esta linha ao seu ~/.bashrc ou ~/.zshrc para torná-la permanente.

Windows: Se você instalou o Python sem marcar "Add to PATH", reinstale o Python com essa opção habilitada, ou adicione manualmente C:\Users\SeuNome\AppData\Local\Programs\Python\Python312\Scripts ao PATH do sistema.

Porta Já em Uso

Se você ver "OSError: [Errno 98] Address already in use":

jupyter lab --port=8889

Ou encontre e pare o processo Jupyter existente:

jupyter lab list
jupyter lab stop 8888

No Linux/macOS, você também pode encontrar o processo usando a porta:

lsof -i :8888
kill -9 <PID>

Erros de Permissão

Se a instalação via pip falhar com erros de permissão, evite usar sudo pip install. Em vez disso, use a flag --user:

pip install --user jupyterlab

Ou melhor, use um ambiente virtual (abordado abaixo).

Kernel Não Encontrado

Se seu notebook disser "Kernel not found" ou o kernel Python estiver faltando:

pip install ipykernel
python -m ipykernel install --user

Para um kernel de ambiente virtual:

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

O JupyterLab Não Abre no Navegador

Se o servidor iniciar mas nenhuma janela do navegador aparecer:

1. Copie a URL da saída do terminal (incluindo o token).
2. Cole-a diretamente no seu navegador.
3. Se estiver rodando em um servidor remoto, use encaminhamento de porta SSH:

ssh -L 8888:localhost:8888 user@servidor-remoto

Em seguida, abra http://localhost:8888/lab na sua máquina local.

O JupyterLab Mostra uma Página em Branco

Limpe o cache do seu navegador ou tente um navegador diferente. Você também pode redefinir o espaço de trabalho do JupyterLab:

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

Extensões do JupyterLab

O JupyterLab 4.x usa um sistema de extensões simplificado onde a maioria das extensões é instalada via pip sem necessidade de Node.js. Aqui estão as extensões mais úteis para trabalho com ciência de dados.

jupyterlab-git

Integração completa com Git dentro do JupyterLab. Visualize diffs, faça staging de alterações, commit, push e pull sem sair da interface.

pip install jupyterlab-git

Após a instalação, uma aba Git aparece na barra lateral esquerda.

jupyterlab-lsp

Suporte ao Language Server Protocol que adiciona autocompletar, documentação ao passar o mouse, ir para definição e linting para Python e outras linguagens.

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

jupyterlab_code_formatter

Formata automaticamente células de código usando formatadores como black ou isort.

pip install jupyterlab-code-formatter black isort

Após a instalação, formate células pelo botão na barra de ferramentas ou por um atalho de teclado.

Extensões de Tema

Personalize a aparência do JupyterLab:

pip install jupyterlab_darkside_ui    # Tema escuro
pip install jupyterlab-night          # Tema noturno

Troque de temas via Settings > Theme.

Gerenciando Extensões

Liste todas as extensões instaladas:

jupyter labextension list

Desinstale uma extensão:

pip uninstall jupyterlab-git

Potencialize Sua Visualização de Dados: PyGWalker

O JupyterLab é um ambiente poderoso para escrever e executar código, mas a visualização interativa de dados frequentemente requer escrever código de plotagem repetitivo. PyGWalker é uma biblioteca Python de código aberto que transforma qualquer DataFrame pandas ou polars em uma interface de visualização interativa estilo Tableau diretamente dentro do JupyterLab.

Em vez de escrever código matplotlib ou seaborn para cada gráfico, você pode explorar seus dados visualmente com arrastar e 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 uma UI interativa onde você pode criar gráficos de barras, gráficos de dispersão, histogramas, mapas de calor e muito mais sem escrever código de plotagem. Suporta filtragem, agregação e múltiplos tipos de gráficos -- ideal para análise exploratória de dados no JupyterLab.

Saiba mais em github.com/Kanaries/pygwalker (opens in a new tab).

Se você quiser ir além com automação alimentada por IA no Jupyter, confira o RunCell (www.runcell.dev (opens in a new tab)) -- um agente de IA que roda dentro do Jupyter e automatiza tarefas repetitivas de notebook como limpeza de dados, engenharia de features e visualização. Ele entende o contexto dos seus dados e gera células de código para você.

Configurando o JupyterLab em um Ambiente Virtual

Executar o JupyterLab dentro de um ambiente virtual é a prática recomendada. Isso mantém as dependências do seu projeto isoladas e evita conflitos com outras instalações do 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

Quando terminar de trabalhar, desative o ambiente:

deactivate

Usando virtualenv

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

Usando Ambientes Conda

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

Tornando um Ambiente Virtual Disponível como Kernel

Se você tem o JupyterLab instalado globalmente mas deseja usar pacotes de um ambiente virtual, registre o ambiente como um kernel:

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

Agora, quando você criar um novo notebook no JupyterLab, pode selecionar "Python (jupyter-env)" como o kernel.

Executando o JupyterLab com Docker

O Docker fornece uma maneira limpa e reproduzível de executar o JupyterLab sem instalar nada no seu sistema host. O projeto Jupyter mantém imagens Docker oficiais.

Início Rápido

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

Isso baixa e executa a imagem base do Jupyter. A saída do terminal contém uma URL com um token. Abra essa URL no seu navegador.

Montar um Diretório Local

Para acessar seus arquivos locais dentro do contêiner:

docker run -p 8888:8888 -v /caminho/para/seu/projeto:/home/jovyan/work jupyter/base-notebook

No Windows:

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

Imagens Docker Disponíveis

Dockerfile Personalizado

Crie um Dockerfile para um ambiente JupyterLab específico do projeto:

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"]

Construa e execute:

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

Docker Compose

Para projetos que combinam JupyterLab com outros serviços (bancos de dados, 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

Gerenciando Múltiplos Kernels Python

Ao trabalhar em múltiplos projetos com diferentes versões do Python ou conjuntos de pacotes, você pode registrar cada ambiente como um kernel separado no JupyterLab.

Adicionando um Kernel de um Ambiente 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)"

Adicionando um Kernel de um Ambiente 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)"

Listando Kernels Instalados

jupyter kernelspec list

Removendo um Kernel

jupyter kernelspec remove ml-project

Trocando Kernels em um Notebook

Dentro de um notebook aberto, clique no nome do kernel no canto superior direito (por exemplo, "Python 3") e selecione um kernel diferente no dropdown. Você também pode ir em Kernel > Change Kernel na barra de menus.

FAQ

Como eu inicio o JupyterLab?

Abra um terminal e execute jupyter lab. O servidor do JupyterLab inicia e seu navegador padrão abre automaticamente. Para iniciar em uma pasta específica, use jupyter lab --notebook-dir=/caminho/para/pasta.

Como eu instalo o JupyterLab com pip?

Execute pip install jupyterlab no seu terminal. Use pip3 em sistemas onde pip aponta para o Python 2. Verifique com jupyter lab --version.

Como eu instalo o JupyterLab com conda?

Execute conda install -c conda-forge jupyterlab. Para uma configuração limpa, crie um ambiente conda dedicado primeiro.

Qual é a diferença entre JupyterLab e Jupyter Notebook?

O JupyterLab é a interface de próxima geração com layout de múltiplos painéis, terminal integrado, navegador de arquivos e extensões. O Jupyter Notebook é a interface original de documento único. O JupyterLab é recomendado para novos projetos.

Como eu corrijo "jupyter: command not found"?

Verifique a instalação com pip show jupyterlab. Se estiver instalado, tente python -m jupyter lab. Caso contrário, adicione o diretório de scripts do pip ao PATH do seu sistema.

Como eu executo o JupyterLab em um ambiente virtual?

Crie um venv com python -m venv myenv, ative-o, instale o JupyterLab com pip install jupyterlab e execute jupyter lab.

Como eu executo o JupyterLab com Docker?

Execute docker run -p 8888:8888 jupyter/base-notebook. Monte arquivos locais com a flag -v para armazenamento persistente.

Como eu abro o JupyterLab em uma porta diferente?

Use jupyter lab --port=9999 para iniciar na porta 9999 em vez da porta padrão 8888.

Conclusão

O JupyterLab é o ambiente de desenvolvimento interativo padrão para ciência de dados, aprendizado de máquina e computação científica em Python. Este guia cobriu cada etapa, desde a instalação até a configuração avançada:

• Instale o JupyterLab com pip install jupyterlab ou conda install -c conda-forge jupyterlab
• Inicie o JupyterLab com jupyter lab e personalize a inicialização com flags para porta, diretório e navegador
• Use o JupyterLab de forma eficaz com atalhos de teclado, visualizações divididas e o terminal integrado
• Solucione problemas comuns como comando não encontrado, conflitos de porta e erros de kernel
• Estenda o JupyterLab com integração Git, suporte LSP e formatação de código
• Isole sua configuração com ambientes virtuais e Docker para fluxos de trabalho reproduzíveis

Seja você um usuário Python de primeira viagem ou um cientista de dados experiente configurando uma nova máquina, estes passos fornecem um ambiente JupyterLab totalmente funcional. Para visualização interativa de dados dentro do JupyterLab, experimente o PyGWalker (opens in a new tab) para transformar qualquer DataFrame em uma ferramenta de análise visual com arrastar e soltar.