Jupyter Notebook: Como Instalar e Abrir em 2026

Para instalar o Jupyter Notebook, garanta que o Python esteja no PATH, crie um ambiente virtual com python -m venv .venv, ative-o e rode python -m pip install jupyterlab. Em seguida, execute jupyter lab e abra http://localhost:8888/lab. Se ainda não instalou o Python, comece pelo guia de instalação no Windows.

Como instalar o Jupyter Notebook

Resposta curta: use o Python que você já tem, isole o projeto em um ambiente virtual e instale o JupyterLab com python -m pip install jupyterlab. Não existe um instalador oficial separado do Jupyter para Windows, Linux ou macOS: o “download” acontece via pip ou conda.

O Jupyter Notebook é a ferramenta padrão para cientistas de dados, pesquisadores e estudantes de Python. Ele mistura células de código, gráficos e texto em Markdown no mesmo arquivo .ipynb. Neste guia você instala, abre, configura atalhos e roda um exemplo prático — e vê quando preferir JupyterLab, Notebook clássico ou Google Colab.

Jupyter Notebook vs JupyterLab

Ambos compartilham o mesmo formato .ipynb e o mesmo kernel Python. Neste guia usamos o JupyterLab como padrão de instalação; o Notebook clássico continua disponível se você preferir a interface antiga.

Instalação com pip (recomendado)

Linux e macOS

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install jupyterlab

Windows (PowerShell)

python -m venv .venv
.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
python -m pip install jupyterlab

Apenas o Notebook clássico

python -m pip install notebook

Usar python -m pip evita instalar o pacote no interpretador errado quando a máquina tem várias versões do Python.

Instalação com conda ou Anaconda

Se você usa Anaconda ou Miniconda:

conda install -c conda-forge jupyterlab

A distribuição Anaconda já traz JupyterLab, Pandas e NumPy em muitos setups de ciência de dados. Para projetos novos e leves, o caminho com venv + pip costuma ser mais previsível.

Verificando a instalação

jupyter --version
python -c "import sys; print(sys.executable)"

O primeiro comando lista os componentes do Jupyter. O segundo deve apontar para o Python dentro de .venv. Se o caminho for o Python do sistema, o ambiente virtual não está ativo.

Iniciando o JupyterLab

jupyter lab

O navegador abre em http://localhost:8888/lab. Para a interface clássica:

jupyter notebook

Para fixar a pasta de trabalho:

jupyter lab --notebook-dir=/caminho/para/seus/projetos

Entendendo a interface

O JupyterLab abre com um painel de arquivos à esquerda e a área de trabalho à direita. Para criar um novo notebook:

1. Clique em File > New > Notebook
2. Selecione o kernel Python 3
3. Um novo arquivo .ipynb será criado

Tipos de células

• Código: executa Python
• Markdown: documentação e texto formatado

No modo de comando, use Y para código e M para Markdown.

Atalhos essenciais

O Jupyter tem dois modos: comando (borda azul) e edição (borda verde). Pressione Esc para modo de comando e Enter para modo de edição.

Modo de comando

• A: inserir célula acima
• B: inserir célula abaixo
• DD: excluir célula (pressione D duas vezes)
• Z: desfazer exclusão de célula
• M: converter para Markdown
• Y: converter para código
• Shift + Enter: executar célula e ir para a próxima
• Ctrl + Enter: executar célula sem avançar

Modo de edição

• Tab: autocompletar
• Shift + Tab: exibir documentação da função
• Ctrl + Shift + -: dividir célula na posição do cursor

Exemplo prático: análise de dados

Instale as dependências no mesmo ambiente:

python -m pip install pandas matplotlib numpy

Em seguida, execute estas células no notebook:

# Célula 1: Importações
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Célula 2: Criando dados de exemplo
dados = {
    'mes': ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun',
            'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'],
    'vendas': [150, 180, 210, 195, 240, 280,
               310, 290, 260, 300, 350, 400],
    'custos': [100, 120, 130, 125, 150, 170,
               190, 180, 160, 185, 210, 240]
}

df = pd.DataFrame(dados)
df['lucro'] = df['vendas'] - df['custos']
df.head()

# Célula 3: Visualização
fig, ax = plt.subplots(figsize=(10, 5))
ax.bar(df['mes'], df['vendas'], label='Vendas', alpha=0.7)
ax.bar(df['mes'], df['custos'], label='Custos', alpha=0.7)
ax.plot(df['mes'], df['lucro'], color='green', marker='o', label='Lucro')
ax.set_title('Desempenho Mensal')
ax.set_ylabel('Valor (R$)')
ax.legend()
plt.tight_layout()
plt.show()

# Célula 4: Estatísticas
print(f"Total de vendas: R$ {df['vendas'].sum():,.0f}")
print(f"Média de lucro mensal: R$ {df['lucro'].mean():,.0f}")
print(f"Melhor mês: {df.loc[df['lucro'].idxmax(), 'mes']}")

O gráfico aparece abaixo da célula. Para ir além deste exemplo, veja o guia de análise de dados com Pandas.

Comandos mágicos

O Jupyter aceita comandos prefixados com % (linha) ou %% (célula):

# Medir tempo de execução de uma linha
%timeit sorted(range(1000))

# Medir tempo de uma célula inteira
%%timeit
resultado = []
for i in range(1000):
    resultado.append(i ** 2)

# Listar variáveis definidas
%who

# Ver histórico de comandos
%history

# Executar um script externo
%run meu_script.py

Extensões úteis

Para JupyterLab

python -m pip install jupyterlab-toc
python -m pip install jupyterlab-git
python -m pip install jupyterlab-spellchecker

Para Notebook clássico

python -m pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user

Extensões recomendadas no Notebook clássico:

• Table of Contents: sumário automático
• ExecuteTime: tempo de execução por célula
• Collapsible Headings: seções recolhíveis
• Autopep8: formatação automática

Configurações avançadas

Alterando a pasta padrão

jupyter lab --generate-config

Edite ~/.jupyter/jupyter_lab_config.py (ou o arquivo equivalente do Notebook) e defina:

c.ServerApp.root_dir = '/caminho/para/seus/projetos'

Instalando kernels adicionais

# Instalar kernel de outro ambiente virtual
/caminho/para/outro/.venv/bin/python -m pip install ipykernel
/caminho/para/outro/.venv/bin/python -m ipykernel install --user --name=meu-projeto

Exportando notebooks

# Para HTML
jupyter nbconvert --to html meu_notebook.ipynb

# Para PDF (requer LaTeX)
jupyter nbconvert --to pdf meu_notebook.ipynb

# Para script Python
jupyter nbconvert --to script meu_notebook.ipynb

Boas práticas

• Reinicie o kernel e execute todas as células antes de compartilhar (Kernel > Restart & Run All)
• Use Markdown para documentar cada etapa da análise
• Mantenha as células curtas e focadas em uma tarefa
• Nomeie notebooks de forma descritiva: analise-vendas-2026.ipynb em vez de Untitled.ipynb
• Adicione .ipynb_checkpoints/ e .venv/ ao .gitignore
• Prefira python -m pip dentro do ambiente virtual ativo

Perguntas frequentes

Como instalar o Jupyter Notebook no Python?

Crie um venv, ative-o e rode python -m pip install jupyterlab. Depois execute jupyter lab. Se ainda não tiver o interpretador, siga a instalação do Python no Windows ou o guia equivalente do seu sistema.

Jupyter Notebook e JupyterLab são a mesma coisa?

Não. Os dois abrem .ipynb, mas o Lab é o ambiente moderno com abas, terminal e arquivos. Para um comparativo completo com Colab, veja Jupyter Notebook vs JupyterLab vs Google Colab.

Preciso baixar um instalador separado?

Não. O Jupyter é instalado como pacote Python. O “download” é o próprio pip install ou o conda install. Anaconda também entrega JupyterLab pronto.

Como abrir o Jupyter depois de instalar?

Com o ambiente ativo, rode jupyter lab ou jupyter notebook. Se o navegador não abrir sozinho, acesse http://localhost:8888/lab.

Qual a diferença entre Jupyter local e Google Colab?

Jupyter local funciona offline e controla versões e arquivos na sua máquina. Colab dispensa instalação e facilita compartilhar aulas, mas depende da internet e da infraestrutura do Google.

Próximos passos

Com o Jupyter instalado, avance para:

1. Ambiente virtual Python com venv — isole cada projeto corretamente.
2. Análise de dados com Pandas — o próximo passo natural dentro do notebook.
3. Jupyter Notebook vs JupyterLab vs Colab — escolha o ambiente certo para cada tarefa.
4. Marimo como alternativa reativa ao Jupyter — útil quando você quer arquivos .py fáceis de versionar.

Se você também trabalha com linguagens compiladas, saiba que Go pode ser usado em notebooks interativos com ferramentas como GoNB, e Rust tem suporte experimental ao Jupyter via evcxr.