Jupyter: Notebooks e JupyterLab para Data Science

O Jupyter Notebook é a ferramenta preferida de cientistas de dados e pesquisadores em Python. Ele combina código executável, documentação em Markdown, visualizações e resultados textuais em um único documento interativo. O JupyterLab, a interface moderna do Jupyter, amplia essa experiência com um gerenciador de arquivos, um terminal integrado e extensibilidade completa. Este guia mostra como instalar, configurar e dominar o Jupyter para desenvolver e documentar suas análises de dados.

1. Instalação e Configuração

Instalação com pip

# Instalação básica
# pip install jupyter

# Instalação com suporte completo
# pip install jupyterlab

# Verificar a instalação
# jupyter --version
# jupyter kernelspec list

A instalação via pip é recomendada em um ambiente virtual dedicado, para evitar conflitos de dependências.

# Criar um ambiente virtual
# python -m venv env_jupyter
# source env_jupyter/bin/activate  # No Linux/macOS
# env_jupyter\Scripts\activate      # No Windows

# Instalar o Jupyter nesse ambiente
# pip install jupyterlab numpy pandas matplotlib

Ambientes virtuais e Kernels

Cada ambiente Python deve ter seu próprio kernel Jupyter. Um kernel é o processo que executa o código no seu notebook.

# Criar um ambiente para data science
# python -m venv ds_env
# source ds_env/bin/activate
# pip install ipykernel

# Registrar esse kernel no Jupyter
# python -m ipykernel install --user --name ds_env --display-name "Python (DS)"

# Criar outro ambiente para desenvolvimento web
# python -m venv web_env
# source web_env/bin/activate
# pip install ipykernel flask django

# Registrar esse kernel
# python -m ipykernel install --user --name web_env --display-name "Python (Web)"

# Listar todos os kernels disponíveis
# jupyter kernelspec list

Depois de registrados os kernels, você pode alternar entre eles no Jupyter pelo menu “Kernel” ou no canto inferior direito do notebook.

2. Notebook versus JupyterLab

Notebook clássico

O Jupyter Notebook é uma interface minimalista e leve. Ele é iniciado com:

# jupyter notebook
# Este comando abre uma interface web em http://localhost:8888

Vantagens do Notebook clássico:

• Leve, consome poucos recursos
• Simples, com poucas distrações
• Inicialização rápida

JupyterLab

O JupyterLab é a próxima geração do Jupyter, com uma interface modular e extensível.

# jupyter lab
# Este comando abre o JupyterLab em http://localhost:8888

Vantagens do JupyterLab:

• Vários arquivos abertos em abas
• Gerenciador de arquivos integrado à esquerda
• Terminal e console integrados
• Visualizador de imagens nativo
• Extensibilidade via plugins TypeScript/JavaScript
• Barra lateral retrátil

3. Estrutura das Células

Célula de Código

Uma célula de código contém Python executável. Ela é executada pressionando Ctrl+Enter (ou Cmd+Enter no Mac).

# Célula de código

import numpy as np

data = np.array([1, 2, 3, 4, 5])
moyenne = data.mean()

print(f"Moyenne : {moyenne}")
# Saída : Moyenne : 3.0

A ordem de execução é determinada pelo número entre colchetes: [1], [2], etc. Você pode reexecutar uma célula quantas vezes quiser, e a ordem de execução muda.

Célula Markdown

As células Markdown permitem documentar suas análises com texto formatado, títulos, listas e fórmulas matemáticas.

# Titre principal

## Sous-titre

Ceci est un paragraphe contenant du texte en **gras** et en *italique*.

- Élément 1
- Élément 2
- Élément 3

### Formules LaTeX

Voici une formule inline : $y = mx + b$

Et une formule centrée :

$$\sum_{i=1}^{n} x_i = \frac{n(n+1)}{2}$$

Dica: pressione Ctrl+Enter para executar (renderizar) uma célula Markdown, ou Esc e depois M para converter uma célula de código em Markdown.

4. Atalhos de Teclado Essenciais

Atalho	Modo	Ação
Ctrl+Enter	Edição/Comando	Executar a célula
Shift+Enter	Edição	Executar e ir para a próxima célula
Alt+Enter	Edição	Executar e inserir uma nova célula
Esc	Edição	Passar para o modo comando
Enter	Comando	Passar para o modo edição
A	Comando	Inserir uma célula acima
B	Comando	Inserir uma célula abaixo
D D	Comando	Excluir a célula (duas vezes D)
M	Comando	Converter para Markdown
Y	Comando	Converter para Código
Ctrl+Shift+P	Comando	Paleta de comandos
H	Comando	Exibir a ajuda de atalhos

5. Comandos Mágicos

Os comandos mágicos são atalhos especiais prefixados por % (linha) ou %% (célula). Eles facilitam a depuração e a otimização.

%timeit: Medir o tempo de execução

# Medir o tempo de uma linha

%timeit sum(range(100))
# Resultado : 1.25 µs ± 41.2 ns per loop (mean ± std. dev. of 7 runs)

%%time: Medir uma célula inteira

%%time

# Cálculo completo da célula
resultat = sum(range(1_000_000))
print(resultat)
# CPU times: user 23.4 ms, sys: 1.23 ms, total: 24.6 ms
# Wall time: 25.1 ms

%matplotlib inline

Para exibir os gráficos do Matplotlib diretamente no notebook (obrigatório antes de qualquer uso do Matplotlib).

%matplotlib inline

import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y = [1, 4, 9, 16]

plt.plot(x, y)
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Courbe simple")
plt.show()
# O gráfico é exibido diretamente abaixo da célula

%run: Executar um arquivo Python externo

# Suponha que você tenha um arquivo helper.py
# contendo funções reutilizáveis

%run helper.py

# As funções e variáveis do arquivo agora estão disponíveis
print(ma_fonction(5))

%pip: Instalar pacotes diretamente no notebook

# Instalar uma biblioteca sem sair do notebook
%pip install requests

import requests
# Usar a biblioteca imediatamente

%pwd e %cd: Navegação no sistema de arquivos

%pwd
# Exibe o diretório atual
# /Users/utilisateur/projects/analysis

%cd ../data
# Altera o diretório atual

%ls
# Lista os arquivos do diretório atual

6. Exibição Rica e Saídas

O Jupyter pode exibir muito mais do que texto: imagens, DataFrames formatados, HTML, LaTeX etc.

from IPython.display import display, HTML, Image, DataFrame
import pandas as pd

# Exibir HTML
display(HTML("<h3 style='color:red;'>Attention!</h3>"))
# Resultado : Attention! (em vermelho e grande)

# Exibir uma imagem a partir de uma URL
display(Image(url="https://example.com/image.png"))

# DataFrame do Pandas com formatação automática
df = pd.DataFrame({
    'Nom': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Ville': ['Paris', 'Lyon', 'Marseille']
})

display(df)
# Exibe uma tabela formatada e interativa

7. Extensões e Plugins Úteis

O JupyterLab conta com um rico ecossistema de extensões para aprimorar a experiência.

Gerenciar extensões

# Listar as extensões instaladas
# jupyter labextension list

# Instalar uma extensão
# jupyter labextension install @jupyter-widgets/jupyterlab-manager

# Verificar as extensões pela linha de comando
# pip install jupyterlab_execute_time
# pip install jupyterlab-code-formatter
# pip install jupyterlab-lsp

Extensões populares

Extensão	Utilidade
jupyterlab-execute-time	Exibe o tempo de execução de cada célula
jupyterlab-code-formatter	Formata o código Python (Black, Autopep8 etc.)
jupyterlab-lsp	Suporte a servidores Language Server Protocol (autocompletar avançado)
ipywidgets	Widgets interativos (sliders, botões etc.)
jupyterlab-git	Integração com Git diretamente no JupyterLab

8. Exportação e Conversão com nbconvert

Um notebook .ipynb nada mais é do que um arquivo JSON. Você pode exportar seu trabalho para outros formatos.

# Exportar para PDF (requer pandoc e LaTeX)
# jupyter nbconvert --to pdf notebook.ipynb

# Exportar para HTML estático
# jupyter nbconvert --to html notebook.ipynb
# Resultado : notebook.html

# Exportar para Python puro (apenas células de código)
# jupyter nbconvert --to python notebook.ipynb
# Resultado : notebook.py

# Exportar para Markdown
# jupyter nbconvert --to markdown notebook.ipynb

# Exportar para slides (reveal.js)
# jupyter nbconvert --to slides notebook.ipynb --post serve

9. Versionar Notebooks com Git

Os arquivos .ipynb são complexos de versionar com Git. Existem várias estratégias:

Problema nativo

// notebook.ipynb é um JSON com saídas, metadados etc.
{
  "cells": [...],
  "metadata": {...},
  "nbformat": 4,
  "nbformat_minor": 5
}
// Os diffs são ilegíveis, as mesclagens são impossíveis

Solução 1: Limpar as saídas antes de fazer commit

# nbstripout : remove as saídas e metadados supérfluos
# pip install nbstripout

# git config filter.strip-notebook.clean "nbstripout"
# Adicionar ao .gitattributes :
# *.ipynb filter=strip-notebook

Solução 2: Manter o código Python ao lado

# Exportar regularmente para Python
# jupyter nbconvert --to python notebook.ipynb

# Versionar notebook.py em vez de notebook.ipynb
# Os diffs são claros e as mesclagens são fáceis

Solução 3: Usar Jupyter Book ou Quarto

Para um projeto sério, migre para o Jupyter Book (.md + código) ou o Quarto (formato universal), que são mais adequados ao controle de versão.

10. Boas Práticas

• Uma seção = um notebook: mantenha um notebook por tema de análise. Notebooks muito longos se tornam difíceis de navegar.
• Células curtas e focadas: cada célula deve fazer uma única coisa. Isso facilita a depuração e a reutilização.
• Documente com Markdown: não hesite em escrever células Markdown explicando suas etapas. Os notebooks também servem para contar uma história.
• Limpe antes de compartilhar: remova as células de teste, as variáveis temporárias e as saídas antigas. Exporte ou reexecute tudo do zero antes de entregar.
• Use variáveis com nomes explícitos: df_sales_2024 em vez de df1.
• Salve regularmente: o Jupyter salva automaticamente, mas um salvamento manual (Ctrl+S) não faz mal.
• Reinicie o kernel antes de compartilhar: menu “Kernel” → “Restart & Run All” para verificar que tudo é executado em ordem.

11. Alternativas e Complementos

Ferramenta	Caso de uso
VS Code + Jupyter	Se você prefere o VS Code a uma interface web
Google Colab	Notebooks gratuitos na nuvem, GPUs/TPUs gratuitas
Kaggle Notebooks	Competições de data science e notebooks colaborativos
Pluto.jl	Notebooks reativos para Julia (conceito similar)
Observable	Notebooks JavaScript para visualização web

Conclusão

O Jupyter Notebook e o JupyterLab tornaram-se indispensáveis no ecossistema Python para data science, machine learning e pesquisa. A combinação de código executável, documentação e visualização interativa faz deles o ambiente ideal para explorar dados, prototipar modelos e comunicar seus resultados. Dominando os comandos mágicos, os atalhos de teclado e as extensões, você ganhará muito em produtividade. Lembre-se de que o Jupyter não é uma ferramenta de produção: para pipelines de análise robustos, prefira scripts Python organizados, testados e versionados corretamente.