Jupyter Notebook: O que É e Como Funciona | Python Brasil | Python Brasil

Q: O que é Jupyter Notebook?

Guia completo sobre Jupyter Notebook: tipos de células, atalhos, magic commands, nbconvert, JupyterHub, widgets, Papermill e Google Colab.

O que é Jupyter Notebook?

O Jupyter Notebook é um ambiente interativo baseado em navegador que permite criar documentos que combinam código executável, visualizações, texto formatado em Markdown e equações matemáticas — tudo em um único arquivo com extensão .ipynb (IPython Notebook).

O nome “Jupyter” é uma homenagem às três linguagens que o projeto suportou originalmente: Julia, Python e R. Atualmente, o Jupyter suporta mais de 40 kernels para diferentes linguagens.

Criado por Fernando Pérez como IPython Notebook em 2011 e renomeado para Jupyter em 2014, tornou-se a ferramenta padrão para ciência de dados, análise exploratória, ensino e pesquisa científica em todo o mundo.

Instalação e inicialização

# Instalar Jupyter Notebook clássico
pip install jupyter

# Iniciar o servidor (abre no navegador)
jupyter notebook

# Instalar JupyterLab (interface moderna — recomendado)
pip install jupyterlab

# Iniciar JupyterLab
jupyter lab

# Instalar no ambiente conda
conda install -c conda-forge jupyterlab

O servidor Jupyter roda localmente em http://localhost:8888 por padrão. Um token de segurança é gerado automaticamente para autenticação.

Tipos de células em detalhe

O Jupyter trabalha com três tipos principais de células:

Células de Código: executam código Python (ou outra linguagem configurada) e exibem o resultado diretamente abaixo:

# Célula de código — análise de dados completa
import pandas as pd
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "mes": ["Jan", "Fev", "Mar", "Abr", "Mai"],
    "vendas": [15000, 18000, 14000, 22000, 19000],
    "custos": [8000, 9500, 7500, 11000, 9800],
})

df["lucro"] = df["vendas"] - df["custos"]
df["margem"] = (df["lucro"] / df["vendas"] * 100).round(1)

print(df.to_string(index=False))
df.plot(x="mes", y=["vendas", "custos", "lucro"], kind="bar", figsize=(10, 5))
plt.title("Análise Financeira Mensal")
plt.ylabel("Valor (R$)")
plt.tight_layout()
plt.show()

Células Markdown: texto formatado, títulos, listas, links e imagens. Ideal para documentar o raciocínio entre blocos de código:

## Análise de Vendas Q1 2024

Os dados mostram uma **queda de 22% em março**, possivelmente relacionada
ao período de Carnaval. Pontos relevantes:

- Abril apresentou o **melhor resultado** do período
- A margem média ficou em **40,3%**

> **Fonte:** Sistema ERP — exportação em 15/03/2024

Células Raw: conteúdo não processado, usado principalmente para metadados de conversão com nbconvert (como texto rst ou LaTeX).

Atalhos de teclado essenciais

O Jupyter tem dois modos: modo de edição (cursor ativo na célula) e modo de comando (célula selecionada, sem cursor). Pressione Esc para modo de comando e Enter para modo de edição.

Modo de Comando:

Atalho	Ação
`A`	Inserir célula acima
`B`	Inserir célula abaixo
`D D`	Deletar célula
`M`	Converter para Markdown
`Y`	Converter para código
`Z`	Desfazer deletar célula
`Shift+J` / `Shift+K`	Selecionar múltiplas células
`Shift+M`	Mesclar células selecionadas

Modo de Edição e Execução:

Atalho	Ação
`Ctrl+Enter`	Executar célula atual
`Shift+Enter`	Executar e avançar para próxima
`Alt+Enter`	Executar e inserir nova abaixo
`Tab`	Autocompletar
`Shift+Tab`	Mostrar documentação
`Ctrl+Z`	Desfazer
`Ctrl+/`	Comentar/descomentar

Magic commands: superpoderes do Jupyter

Os magic commands são comandos especiais com prefixo % (linha única) ou %% (célula inteira) que estendem as capacidades do Jupyter:

# %timeit — medir tempo de execução (executa múltiplas vezes)
%timeit [x**2 for x in range(10000)]
# 1.23 ms ± 12.3 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

# %%timeit — medir tempo de toda a célula
%%timeit
total = 0
for i in range(10000):
    total += i**2

# %matplotlib — configurar backend de gráficos
%matplotlib inline         # gráficos embutidos no notebook
%matplotlib notebook       # gráficos interativos (zoom, pan)

# %%bash — executar bash na célula inteira
%%bash
ls -la
pwd
echo "Olá do bash!"

# %run — executar um script Python externo
%run script_analise.py

# %load — carregar conteúdo de arquivo na célula
%load utils.py

# %who / %whos — listar variáveis no namespace
%who
%whos   # com tipos e tamanhos

# %history — histórico de comandos
%history

# %reset — limpar namespace (variáveis)
%reset -f

# %env — variáveis de ambiente
%env HOME
%env MINHA_VAR = valor

# %%writefile — salvar conteúdo da célula em arquivo
%%writefile meu_script.py
def hello():
    print("Salvo pelo Jupyter!")

# %prun — profiling de desempenho
%prun funcao_lenta()

# %debug — debugger interativo após erro
%debug

nbconvert: exportando notebooks

O nbconvert converte notebooks .ipynb para diferentes formatos:

# Exportar para HTML (ótimo para compartilhar)
jupyter nbconvert --to html analise.ipynb
# gera analise.html

# Exportar para PDF (requer LaTeX instalado)
jupyter nbconvert --to pdf relatorio.ipynb

# Exportar para script Python
jupyter nbconvert --to script analise.ipynb
# gera analise.py

# Exportar para slides (apresentação reveal.js)
jupyter nbconvert --to slides apresentacao.ipynb --post serve

# Executar o notebook e salvar saída
jupyter nbconvert --to notebook --execute analise.ipynb
# gera analise_executado.ipynb com todas as saídas

# Executar sem gerar arquivo (apenas verifica se roda sem erros)
jupyter nbconvert --to notebook --execute --inplace analise.ipynb

JupyterHub: Jupyter em equipe

O JupyterHub permite que múltiplos usuários acessem ambientes Jupyter individuais em um servidor centralizado — sem precisar instalar nada localmente:

# Instalação básica do JupyterHub
pip install jupyterhub

# Iniciar o servidor (porta 8000 por padrão)
jupyterhub

# Configuração básica
jupyterhub --generate-config
# editar jupyterhub_config.py

O JupyterHub é amplamente usado em:

Laboratórios de pesquisa e universidades
Equipes de ciência de dados em empresas
Cursos online (cada aluno tem seu próprio ambiente)
Plataformas como Binder e MyBinder

Jupyter Widgets: interatividade sem JavaScript

O ipywidgets permite criar interfaces interativas (sliders, dropdowns, botões) diretamente no notebook:

import ipywidgets as widgets
from IPython.display import display
import matplotlib.pyplot as plt
import numpy as np

# Slider simples
slider = widgets.IntSlider(value=50, min=0, max=100, description="Valor:")
display(slider)

# Gráfico interativo com slider
def plotar_senoide(frequencia=1.0, amplitude=1.0):
    x = np.linspace(0, 4 * np.pi, 1000)
    y = amplitude * np.sin(frequencia * x)
    plt.figure(figsize=(10, 4))
    plt.plot(x, y)
    plt.title(f"Senoide: f={frequencia:.1f}Hz, A={amplitude:.1f}")
    plt.ylim(-3, 3)
    plt.grid(True)
    plt.show()

widgets.interact(
    plotar_senoide,
    frequencia=widgets.FloatSlider(min=0.5, max=5.0, step=0.5, value=1.0),
    amplitude=widgets.FloatSlider(min=0.1, max=2.0, step=0.1, value=1.0),
)

# Dropdown para seleção de dataset
dropdown = widgets.Dropdown(
    options=["iris", "titanic", "boston"],
    value="iris",
    description="Dataset:",
)

botao = widgets.Button(description="Carregar", button_style="primary")

def ao_clicar(b):
    print(f"Carregando dataset: {dropdown.value}")

botao.on_click(ao_clicar)
display(widgets.HBox([dropdown, botao]))

Controle de versão com notebooks

Arquivos .ipynb são JSON internamente, o que dificulta o uso com Git (diffs ilegíveis com saídas binárias). Soluções práticas:

# nbstripout — remove saídas antes do commit automaticamente
pip install nbstripout
nbstripout --install  # configura git hook no repositório

# Revisar diferenças com nbdiff (parte do nbformat)
pip install nbdime
nbdime config-git --enable --global
git diff meu_notebook.ipynb  # diff legível

# jupytext — sincroniza notebooks com scripts .py
pip install jupytext
jupytext --to py:percent analise.ipynb   # converte para .py
jupytext --sync analise.ipynb            # sincroniza .ipynb e .py
# Versionar o .py no Git, gerar o .ipynb localmente

Papermill: notebooks como pipelines

O Papermill permite executar notebooks programaticamente com parâmetros, transformando notebooks em pipelines reprodutíveis:

pip install papermill

# Executar notebook com parâmetros
papermill analise_template.ipynb analise_jan.ipynb \
    -p mes "janeiro" \
    -p ano 2024 \
    -p limite_vendas 50000

No notebook template, marque a célula de parâmetros com a tag parameters:

# Célula com tag "parameters"
mes = "dezembro"       # padrão
ano = 2023
limite_vendas = 30000

# Resto do notebook usa as variáveis normalmente
print(f"Análise de {mes}/{ano}")

O Papermill é amplamente usado para gerar relatórios automáticos em diferentes períodos ou segmentos.

Google Colab vs Jupyter local

Google Colab:

Gratuito, sem instalação, acesso direto pelo navegador
GPU e TPU disponíveis gratuitamente (com limitações de tempo)
Integração nativa com Google Drive
Ambiente reiniciado após inatividade — variáveis perdidas
Versões de pacotes podem diferir do ambiente local
Ideal para prototipagem rápida, aprendizado e experimentos com deep learning

Jupyter local:

Controle total sobre versões de pacotes e configuração
Sem limitação de tempo de execução
Dados e arquivos acessíveis localmente sem upload
Funciona offline
Ideal para produção, análises com dados sensíveis e projetos de longo prazo

# Detectar se está rodando no Colab
try:
    import google.colab
    NO_COLAB = False
    print("Executando no Google Colab")
    # Montar Google Drive se necessário
    from google.colab import drive
    drive.mount("/content/drive")
except ImportError:
    NO_COLAB = True
    print("Executando localmente")

Termos Relacionados

Pandas - Biblioteca de análise de dados
NumPy - Computação numérica
Anaconda - Distribuição que inclui Jupyter
Machine Learning - Prototipagem de modelos

Jupyter Notebook: O que É e Como Funciona | Python Brasil