---
title: "Jupyter Notebook: Configuração Completa"
url: "https://python.dev.br/guias/configurando-jupyter-notebook/"
markdown_url: "https://python.dev.br/guias/configurando-jupyter-notebook.MD"
description: "Aprenda a instalar e configurar o Jupyter Notebook para ciência de dados com Python. JupyterLab, extensões, atalhos e dicas práticas"
date: "2025-11-16"
author: ""
---

# Jupyter Notebook: Configuração Completa

Aprenda a instalar e configurar o Jupyter Notebook para ciência de dados com Python. JupyterLab, extensões, atalhos e dicas práticas


## Introdução

O Jupyter Notebook é uma ferramenta essencial para cientistas de dados, pesquisadores e estudantes de Python. Ele permite escrever código, visualizar gráficos e documentar análises em um único documento interativo que mistura células de código com texto formatado em Markdown.

Neste guia, vamos instalar o Jupyter Notebook, configurar o JupyterLab (sua versão mais moderna), aprender atalhos e explorar extensões que aumentam a produtividade.

## Jupyter Notebook vs JupyterLab

O **Jupyter Notebook** é a interface clássica, focada em um único documento por vez. O **JupyterLab** é a evolução, oferecendo uma interface completa com múltiplas abas, terminal integrado, visualizador de arquivos e muito mais.

Ambos são instalados pelo mesmo pacote. Neste guia, usaremos o JupyterLab como padrão, mas tudo funciona da mesma forma no Notebook clássico.

## Instalação

### Com pip

Crie um ambiente virtual e instale:

```bash
python3 -m venv venv-jupyter
source venv-jupyter/bin/activate
pip install jupyterlab
```

Para instalar apenas o notebook clássico:

```bash
pip install notebook
```

### Com conda

Se você usa Anaconda ou Miniconda:

```bash
conda install -c conda-forge jupyterlab
```

### Verificando a instalação

```bash
jupyter --version
```

O comando deve mostrar as versões do Jupyter e seus componentes.

## Iniciando o JupyterLab

Para iniciar o servidor:

```bash
jupyter lab
```

O navegador abrirá automaticamente em `http://localhost:8888/lab`. Se preferir o notebook clássico:

```bash
jupyter notebook
```

## 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 notebook (arquivo `.ipynb`) será criado

### Tipos de células

Cada notebook é composto por células. Existem dois tipos principais:

- **Código**: células que executam Python
- **Markdown**: células para documentação e texto formatado

Para alternar entre tipos, use o dropdown no topo ou os atalhos `Y` (código) e `M` (markdown) no modo de comando.

## 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

Vamos criar um notebook que analisa dados com Pandas e Matplotlib. Primeiro, instale as dependências:

```bash
pip install pandas matplotlib numpy
```

Em seu notebook, execute as seguintes células:

```python
# Celula 1: Importações
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
```

```python
# Celula 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()
```

```python
# Celula 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()
```

```python
# Celula 4: Estatisticas
print(f"Total de vendas: R$ {df['vendas'].sum():,.0f}")
print(f"Media de lucro mensal: R$ {df['lucro'].mean():,.0f}")
print(f"Melhor mes: {df.loc[df['lucro'].idxmax(), 'mes']}")
```

O resultado do gráfico aparece diretamente no notebook, abaixo da célula de código. Isso torna o Jupyter ideal para análise exploratória de dados.

## Comandos mágicos

O Jupyter suporta comandos especiais prefixados com `%` (uma linha) ou `%%` (célula inteira):

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

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

```python
# Listar variaveis definidas
%who

# Ver historico de comandos
%history

# Executar um script externo
%run meu_script.py
```

## Extensões úteis

### Para JupyterLab

Instale extensões pelo gerenciador integrado ou por linha de comando:

```bash
# Sumario de conteudo
pip install jupyterlab-toc

# Suporte a Git
pip install jupyterlab-git

# Verificação de ortografia
pip install jupyterlab-spellchecker
```

### Para Notebook clássico

```bash
pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user
```

Extensões recomendadas para o notebook clássico:

- **Table of Contents**: gera sumário automático
- **ExecuteTime**: mostra o tempo de execução de cada célula
- **Collapsible Headings**: permite colapsar seções
- **Autopep8**: formata o código automaticamente

## Configurações avançadas

### Alterando a pasta padrão

Para mudar o diretório onde o Jupyter abre, gere o arquivo de configuração:

```bash
jupyter notebook --generate-config
```

Edite o arquivo `~/.jupyter/jupyter_notebook_config.py` e defina:

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

### Instalando kernels adicionais

Você pode usar outros interpretadores Python no Jupyter:

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

### Exportando notebooks

Exporte notebooks para outros formatos:

```bash
# 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 seus notebooks de forma descritiva: `analise-vendas-2025.ipynb` em vez de `Untitled.ipynb`
- Adicione o `.ipynb_checkpoints/` ao `.gitignore` do seu repositório

## Conclusão

O Jupyter Notebook e o JupyterLab são ferramentas indispensáveis para quem trabalha com ciência de dados, machine learning ou análise exploratória em Python. A combinação de código, visualizações e documentação em um único documento torna a comunicação de resultados muito mais eficiente. Com os atalhos e extensões apresentados neste guia, você estará pronto para trabalhar de forma produtiva.

Se você também trabalha com linguagens compiladas, saiba que <a href="https://golang.com.br/blog/" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', {source: 'python.dev.br', target: 'golang.com.br', content: 'configurando-jupyter-notebook'})">Go pode ser usado em notebooks interativos</a> com ferramentas como GoNB, e <a href="https://rustlang.com.br/blog/" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', {source: 'python.dev.br', target: 'rustlang.com.br', content: 'configurando-jupyter-notebook'})">Rust tem suporte experimental ao Jupyter</a> via evcxr.
