Uso de Jupyter

Alternar entre comando Python e Markdown

O Jupyter normalmente entra no "modo interpretador Pytohn", tentando excutar comandos Python tão logo seja usada a commbinação de teclas SHIFT + ENTER. Teclar apenas ENTER só muda de linha numa célula do Python.

Para sair deste "modo interpretador Python", e mudar para modo de edição Markdonw, use a combinação de teclas ESC + M. Digite a sentença Markdown e use a combinação SHIFT+ ENTER para que a sentença seja renderizadas. Note que em seguina, o Jupyter volta para o "modo interpretador Python", sem necessidade de alguma outra combinação de teclas.

Métodos para executar comandos do sistema no Jupyter:

É possível executar comandos do sistema diretamente de dentro do Jupyter Notebook, tanto em MacOS quanto em outros sistemas operacionais. Você não precisa sair do Jupyter para instalar bibliotecas ou executar comandos do terminal.

1. Usando ! (exclamação)

Você pode executar qualquer comando do terminal precedendo-o com !. Por exemplo:

!ls -l  # Lista arquivos no diretório atual (MacOS/Linux)
!pwd    # Mostra o diretório atual

Para instalar uma biblioteca Python (como pandas se estiver faltando):

xxxxxxxxxx
!pip install pandas

2. Usando %%bash (para scripts multi-linha)

Se precisar executar vários comandos bash em sequência:

xxxxxxxxxx
%%bash
echo "Hello from bash"
pip install --upgrade numpy
ls

Dica extra:

Se você quer interagir com o terminal por mais tempo (ex: navegar em diretórios), use:

xxxxxxxxxx
%%bash
cd ~/Documents  # Muda o diretório
ls -l  # Lista arquivos
pwd  # Mostra o diretório atual

Mas lembre-se: alterações no terminal (como cd) não afetam o ambiente Python do Jupyter após a execução. Para isso, use os comandos do Python (ex: os.chdir()).

3. Usando os.system (módulo os do Python)

xxxxxxxxxx
import os
os.system("say 'Hello from MacOS'")  # Fará o MacOS falar a frase (se estiver no Mac)

4. Usando subprocess (para controle mais avançado)

xxxxxxxxxx
import subprocess
result = subprocess.run(["ls", "-l"], capture_output=True, text=True)
print(result.stdout)

Exemplo prático para instalar bibliotecas Python:

Se seu código Python gerar um erro como ModuleNotFoundError: No module named 'seaborn', você pode instalar diretamente no notebook:

xxxxxxxxxx
try:
    import seaborn
except ImportError:
    !pip install seaborn
    import seaborn

Observações importantes:

• O Jupyter executa os comandos no ambiente Python em que está rodando. Se você estiver usando um ambiente virtual, os comandos afetarão apenas esse ambiente.
• Para comandos específicos do MacOS (como open, say, brew, etc.), basta usar com !.
• Alguns comandos podem requerer sudo (cuidado ao usar isso em notebooks).

Isso elimina a necessidade de abrir um terminal separado na maioria dos casos!

Verificando pacotes instalados (usando conda)

xxxxxxxxxx
!conda list <nome_do_pacote>

Se o pacote não estiver instalado, o retorno não mostrará nada ou indicará # packages in environment at sem listar o pacote.

É similar ao comando pip list.

Atualizar pacoes (usando conda)

xxxxxxxxxx
!conda update <nome_do_pacote>

Isso atualizará o <nome_do_pacote> para a última versão compatível com ambiente atual de trabalho.

Para descobrir opções para baixar pacote

xxxxxxxxxx
!conda search <nome_do_pacote> --info

Atenção: várias linhas texto podem ser geradas!

Resumo dos comandos úteis (conda & pip)

Significado de [*] no prompt do Jupyter

O símbolo [*] ao lado do número da célula no Jupyter Notebook (ex: In [*]:) indica que a célula está em execução (processamento). Quando o código terminar de rodar, o * será substituído por um número sequencial (ex: In [1]:).

Possíveis significados:

• In [*]: → Célula rodando no momento.

• In [1]:, In [2]:, etc. → Célula já executada (o número indica a ordem de execução).

• Se ficar travado em [*] por muito tempo, pode ser que:

  • O código está demorando (ex: um loop infinito!?).
  • O kernel travou (nesse caso, reinicie-o em Kernel > Restart). Antenção: no caso de Restart do Kernel, os comandos/ações anteriores já realizadas, são todas perdidas!

Como sair do "modo execução de comandos do sistema" após usar !?

Quando você executa um comando do sistema com ! (ex: !ls), o Jupyter não entra em um "modo terminal" permanente—ele apenas roda aquele comando específico e volta para o ambiente Python imediatamente.

Outras opções: cancelar comando, retornar ao prompt, restart

• Cancelar um comando em execução:

  • Use o botão ■ (Interrupt Kernel) na barra de ferramentas do Jupyter.
  • Ou pressione I duas vezes seguidas no teclado (modo de comando do Jupyter).

• Voltar ao prompt normal do Python:

  • Após executar !comando, o Jupyter já retorna automaticamente ao modo Python. Basta digitar código Python na próxima célula.

• Se o kernel travou:

  • Reinicie-o em Kernel > Restart.

Exportando conteúdo à partir do Jupyter Notebook

Existem várias maneiras de exportar o conteúdo do Jupyter Notebook, filtrando apenas as partes relevantes (código executado com sucesso, saídas, comentários, etc.) para um script Python limpo. Aqui estão os métodos mais eficientes:

1. Exportar apenas o código executado (sem células incompletas/erros)

Opção A: Usando nbconvert (via linha de comando ou direto no Jupyter)

• Exporta apenas células executadas com sucesso para um arquivo .py:

  xxxxxxxxxx
  jupyter nbconvert --to script SEU_NOTEBOOK.ipynb --output-dir=SAIDA --TemplateExporter.exclude_markdown=True
  

  • Isso gera um arquivo .py com apenas o código das células que rodaram sem erros.
  • Observação: Se uma célula foi executada parcialmente (ex: erro no meio do código), ela não será incluída.

Opção B: Exportar manualmente pelo Jupyter

1. No Jupyter, vá em File > Download as > Python (.py).

2. Isso gera um arquivo com todo o código (incluindo células não executadas ou com erros).

   • Para filtrar apenas o código válido, abra o arquivo gerado e delete manualmente as partes indesejadas.

2. Filtrar células específicas (incluindo saídas de execução)

Se você quer selecionar apenas células específicas (ex: as que rodaram corretamente) e gerar um script consolidado:

Método 1: Usando %%writefile (dentro do próprio notebook)

• Adicione esta célula no final do notebook para exportar o código filtrado:

  xxxxxxxxxx
  %%writefile script_limpo.py
  # Código válido (copie e cole apenas as células que funcionaram)
  import pandas as pd
  df = pd.read_csv("dados.csv")
  print(df.head())
  

  • Isso criará um arquivo script_limpo.py com o conteúdo selecionado.

Método 2: Extrair células executadas programaticamente

Use este código para exportar apenas células executadas sem erros:

​x
  import nbformat
  from nbformat import v4 as nb
​
  # Carrega o notebook
  notebook = nbformat.read("SEU_NOTEBOOK.ipynb", as_version=4)
​
  # Filtra células executadas sem erros
  codigo_limpo = []
  for cell in notebook.cells:
      if cell.cell_type == "code" and "execution_count" in cell:  # Rodou sem erro?
          codigo_limpo.append(cell.source)
​
  # Salva em um arquivo .py
  with open("codigo_filtrado.py", "w") as f:
      f.write("\n\n".join(codigo_limpo))

3. Juntar células corretas + saídas (para documentação)

Se você quer preservar saídas de execução (ex: resultados de print(), gráficos) em um relatório:

Gerar um HTML/PDF filtrado

xxxxxxxxxx
  jupyter nbconvert --to html --output relatorio.html SEU_NOTEBOOK.ipynb --TagRemovePreprocessor.remove_cell_tags='{"errors", "incomplete"}'

• Isso remove células com erros ou não executadas do HTML/PDF gerado.

4. Ferramentas avançadas para limpeza automática

• jupyter-clean: Biblioteca para remover células vazias, saídas, etc.

  xxxxxxxxxx
  pip install jupyter-clean
  jupyter-clean SEU_NOTEBOOK.ipynb
  

• VS Code + Extensão Jupyter: Permite selecionar células específicas e exportar como .py.

Resumo das opções:

Dica final:

• Se você quer um script 100% limpo, o melhor fluxo é:

  1. Rodar o notebook inteiro.
  2. Usar nbconvert para extrair apenas o código executado.
  3. Editar manualmente o arquivo .py gerado para remover redundâncias.

Assim, você evita retrabalho e mantém um código funcional!

Se quiser agilizar ainda mais a limpeza de notebooks, experimente o nbstripout (remove saídas e metadados) ou o jupyterlab-code-formatter (para organizar o código automaticamente).

Encerrando operações no Jupyter

Para encerrar operações no Jupyter Notebook sem perder os dados já processados, você pode usar uma das seguintes abordagens, dependendo da situação:

1. Se uma célula está travada (em [*]) e você quer interrompê-la

• Método 1:
  Clique no botão ■ (Interrupt Kernel) na barra de ferramentas do Jupyter.

  • Isso para a execução da célula atual, mas mantém todas as variáveis já calculadas na memória.

• Método 2:
  Pressione I duas vezes (modo de comando do Jupyter) para interromper o kernel.

⚠️ Cuidado:

• Se o kernel estiver completamente travado, talvez seja necessário reiniciá-lo (veja abaixo como fazer isso sem perder dados).

2. Se você quer "parar" o kernel temporariamente (sem fechar o notebook)

• Opção 1:
  Use Kernel > Restart Kernel (reinicia o kernel, mas você perderá variáveis não salvas).

  • Para evitar perda de dados, salve as variáveis em arquivos antes (ex: pd.to_pickle() para DataFrames).

• Opção 2 (recomendada para manter dados):
  Salve o estado do notebook com File > Save and Checkpoint e depois reinicie o kernel.

3. Como reiniciar o kernel sem perder dados

Se você quer recarregar o kernel mas manter as variáveis já calculadas, siga este fluxo:

1. Salve os dados processados em arquivos temporários:

   xxxxxxxxxx
   import pandas as pd
   pd.to_pickle(df, 'temp_data.pkl')  # Para DataFrames
   

   Ou para outras variáveis:

   xxxxxxxxxx
   import pickle
   with open('temp_vars.pkl', 'wb') as f:
       pickle.dump([var1, var2], f)  # Salva múltiplas variáveis
   

2. Reinicie o kernel em Kernel > Restart.

3. Recarregue os dados após a reinicialização:

   xxxxxxxxxx
   df = pd.read_pickle('temp_data.pkl')  # Carrega o DataFrame
   

   Ou:

   xxxxxxxxxx
   with open('temp_vars.pkl', 'rb') as f:
       var1, var2 = pickle.load(f)  # Recupera variáveis
   

4. Se você quer encerrar o Jupyter completamente

• Salve o notebook (Ctrl+S / Cmd+S).
• Feche a aba do navegador (os dados em memória serão perdidos, mas o notebook salvo mantém o código e saídas).
• Para garantir que nada seja perdido, exporte os resultados para um arquivo (ex: CSV, JSON) antes de sair.

Dica extra: Autoreload para evitar perdas

Se você está desenvolvendo código e quer evitar reinicializações frequentes, use o autoreload para recarregar módulos automaticamente:

xxxxxxxxxx
%load_ext autoreload
%autoreload 2  # Recarrega todos os módulos sempre que uma célula é executada

Resumo das opções:

Fernando Passold, 02/04/2025