Python Brasil
Guia

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

5 min de leitura

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:

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

Para instalar apenas o notebook clássico:

pip install notebook

Com conda

Se você usa Anaconda ou Miniconda:

conda install -c conda-forge jupyterlab

Verificando a instalação

jupyter --version

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

Iniciando o JupyterLab

Para iniciar o servidor:

jupyter lab

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

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:

pip install pandas matplotlib numpy

Em seu notebook, execute as seguintes células:

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

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

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

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

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

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

# 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

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:

jupyter notebook --generate-config

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

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

Instalando kernels adicionais

Você pode usar outros interpretadores Python no Jupyter:

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

# 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 Go pode ser usado em notebooks interativos com ferramentas como GoNB, e Rust tem suporte experimental ao Jupyter via evcxr.

Todos os Guias