colapso celular no notebook jupyter

143

Estou usando o notebook ipython Jupyter. Digamos que eu defini uma função que ocupa muito espaço na minha tela. Existe uma maneira de recolher a célula?

Quero que a função permaneça executada e passível de chamada, mas desejo ocultar / contrair a célula para melhor visualizar o notebook. Como posso fazer isso?

aloha
fonte
30
Uau, já é 2017 e não há uma solução simples #
user1700890 12/17/17
31
2019 e ainda contando #
Hardian Lawi 22/03/19
22
2020 ... (primeiro!)
itzy
5
Ah, vou colocar um lembrete para que eu possa ser o primeiro em 2021
novato
6
O JupyterLab tem isso desde 2019. Destaque uma célula e clique na barra azul ao lado dela. Você verá isso representado como três pontos agora. Será respeitado quando você salvar e reabrir mais tarde ou em outro lugar. Existem outros recursos e opções, como View> Collapse All Code, veja aqui e o link aqui .
Wayne

Respostas:

94

O jupyter contrib nbextensionspacote Python contém uma extensão dobrável em código que pode ser ativada no notebook. Siga o link (Github) para obter documentação.

Para instalar usando a linha de comando:

pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user

Para facilitar a vida no gerenciamento deles, eu também recomendaria o jupyter nbextensions configuratorpacote. Isso fornece uma guia extra na interface do Notebook, de onde você pode (des) ativar facilmente todas as extensões instaladas.

Instalação:

pip install jupyter_nbextensions_configurator
jupyter nbextensions_configurator enable --user
Energya
fonte
11
Coisas legais, embora eu deseje que a extensão de código "dobrar" dobre células inteiras, e não apenas blocos de código.
bsmith89
2
Se alguém tiver problemas de instalação com o conda, tente: pip install jupyter_contrib_nbextensionsentão jupyter contrib nbextensions install --sys-prefix --skip-running-check. Eu gostaria que o jupyter tivesse esse pacote por padrão.
user1700890
7
Mais simples caminho de instalação é via própria Conda : conda install -c conda-forge jupyter_contrib_nbextensions.
precisa saber é o seguinte
3
Apenas uma nota rápida para quem usa o JupyterLab mais recente. De acordo com o site GitHub mencionado, essas extensões funcionam no JupyterLab. Eu me perguntei isso, então pensei em avisar os outros. Citando o repo GitHub: Due to major differences between the Jupyter Notebook and JupyterLab, the extensions in this repository will not work in JupyterLab.
NYCeyes
2
Você pode recolher uma célula inteira se colocar um # comentário na parte superior da célula. O Jupyter fornece uma seta suspensa que recolherá a célula inteira.
21819 EatSleepCode
27

Você pode criar uma célula e inserir o seguinte código:

%%html
<style>
div.input {
    display:none;
}
</style>

A execução desta célula ocultará todas as células de entrada. Para mostrá-los de volta, você pode usar o menu para limpar todas as saídas.

Caso contrário, você pode tentar extensões de notebook como abaixo:

https://github.com/ipython-contrib/IPython-notebook-extensions/wiki/Home_3x

Pan Yan
fonte
As extensões de notebook são realmente boas. Há muitas outras coisas também. github.com/ipython-contrib/jupyter_contrib_nbextensions
shahensha
27

O JupyterLab suporta o colapso de células. Clicar na barra de célula azul à esquerda dobrará a célula. insira a descrição da imagem aqui

intsco
fonte
6
não persiste na exportação embora
cosmosa
Existe uma boa solução para isso? Eu quero muito ocultar células recolhidas quando exportar. Eu quero manter algum código e saída, e ocultar outro código e saída, para que eu não possa ocultar todo o código .....
Russell Richie
2
O código e a saída podem ser recolhidos conforme descrito nesta resposta. Além disso, a informação é mantida. Está escrito nos metadados da célula. source_hiddene outputs_hiddenestá definido. nbformat.readthedocs.io/en/latest/...
Gillesb
16

Eu tive um problema semelhante e as "nbextensions" apontadas pelo @Energya funcionaram muito bem e sem esforço. As instruções de instalação são simples (tentei com o anaconda no Windows) para as extensões de notebook e seu configurador .

Dito isto, gostaria de acrescentar que as seguintes extensões devem ser interessantes.

  • Ocultar entrada | Esta extensão permite ocultar uma célula de código individual em um notebook. Isso é possível clicando no botão da barra de ferramentas: Ocultar entrada

  • Títulos dobráveis ​​| Permite que o notebook tenha seções dobráveis, separadas por títulos Títulos recolhíveis

  • Codefolding | Isso foi mencionado, mas eu o adiciono para completar Codefolding

Atul Singh Arora
fonte
9

Crie o arquivo custom.js dentro de ~ / .jupyter / custom / com o seguinte conteúdo:

$("<style type='text/css'> .cell.code_cell.collapse { max-height:30px; overflow:hidden;} </style>").appendTo("head");
$('.prompt.input_prompt').on('click', function(event) {
    console.log("CLICKED", arguments)   
    var c = $(event.target.closest('.cell.code_cell'))
    if(c.hasClass('collapse')) {
        c.removeClass('collapse');
    } else {
        c.addClass('collapse');
    }
});

Após salvar, reinicie o servidor e atualize o notebook. Você pode recolher qualquer célula clicando no rótulo de entrada (In []).

Sundar
fonte
3
Isso não funcionou para mim, pois a div a ser alterada não é carregada, quando o js personalizado é executado. No entanto, isso pode ser corrigido envolvendo tudo em setTimeout (function () {...}, 3000);
Steohan
2
Isso funcionou para mim depois de alterar a quarta linha para: var c = $(event.target).closest('.cell.code_cell') e seguindo a sugestão de Steohan de agrupar tudo em setTimeout.
Proteome
Você pode simplesmente usar c.toggleClass ('collapse'); em vez da instrução if-else.
gouravkr
9

A extensão hide_code permite ocultar células individuais e / ou as solicitações próximas a elas. Instale como

pip3 install hide_code

Visite https://github.com/kirbs-/hide_code/ para obter mais informações sobre esta extensão.

Linas
fonte
9

Primeiro, siga as instruções da Energya:

pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user
pip install jupyter_nbextensions_configurator
jupyter nbextensions_configurator enable --user

A segunda é a chave: depois de abrir o bloco de notas de Júpiter, clique na guia Nbextension. Agora pesquise "colla" na ferramenta de pesquisa fornecida pelo Nbextension (não pelo navegador da web) , e você encontrará algo chamado "Cabeçalhos recolhíveis"

Isso é o que você quer!

user40780
fonte
2

Como outros já mencionaram, você pode fazer isso via nbextensions. Eu queria dar uma breve explicação do que fiz, que foi rápido e fácil:

Para habilitar cabeçalhos colabíveis: No seu terminal, ative / instale as Extensões de Notebook Jupyter digitando primeiro:

pip install jupyter_contrib_nbextensions

Em seguida, digite:

jupyter contrib nbextension install

Reabra o Jupyter Notebook. Vá para a guia "Editar" e selecione "nbextensions config". Desmarque a caixa diretamente sob o título "Nbextensions configuráveis" e selecione "títulos recolhíveis".

Mame Gannon-Luiz
fonte
Imaginando por que não é possível acessar nbextensions configdiretamente do painel principal e, em vez disso, é necessário abrir um notebook. Como alternativa, como outros já mencionaram, é possível acessá-lo via localhost:8888/nbextensions(ou qualquer porta que esteja na sua configuração)
Antoine
2

Há muitas respostas para essa pergunta, todas as quais considero não satisfatórias (algumas mais que outras), das muitas extensões - dobragem de código, dobragem por títulos etc. etc. Nenhuma faz o que quero de maneira simples e eficaz. Estou literalmente espantado que uma solução não tenha sido implementada (como no Jupyter Lab).

De fato, fiquei tão insatisfeito que desenvolvi uma extensão de notebook muito simples que pode expandir / contrair o código em uma célula de notebook, mantendo-o executável.

O repositório do GitHub: https://github.com/BenedictWilkinsAI/cellfolding

Abaixo está uma pequena demonstração do que a extensão faz:

Basta clicar duas vezes à esquerda da célula de código para recolher uma única linha:

Clicar duas vezes novamente expandirá a célula.

A extensão pode ser instalada facilmente com o pip:

pip install nbextension-cellfolding
jupyter nbextension install --py cellfolding --user
jupyter nbextension enable --py cellfolding --user 

e também é compatível com o configurador nbextension . Espero que as pessoas achem isso útil!

BenedictWilkinsAI
fonte
2
Funcionou como um encanto. Neat
Ayan Mitra
1

Há também uma versão aprimorada da sugestão de Pan Yan. Ele adiciona o botão que mostra as células de código de volta:

%%html
<style id=hide>div.input{display:none;}</style>
<button type="button" 
onclick="var myStyle = document.getElementById('hide').sheet;myStyle.insertRule('div.input{display:inherit !important;}', 0);">
Show inputs</button>

Ou python:

# Run me to hide code cells

from IPython.core.display import display, HTML
display(HTML(r"""<style id=hide>div.input{display:none;}</style><button type="button"onclick="var myStyle = document.getElementById('hide').sheet;myStyle.insertRule('div.input{display:inherit !important;}', 0);">Show inputs</button>"""))
Peter Zagubisalo
fonte
2
Os códigos ocultam TODA a célula de entrada, não uma célula específica.
Jack Fleeting
Exatamente o que eu queria para a saída, mas você pode recolher / ocultar toda a saída, alternando-a no menu Jupyter: Célula> Todas as saídas> Alternar
marcação
Que pena, esta é a única solução que encontrei que oculta o código por padrão e apenas o mostra ao clicar. Infelizmente, isso oculta todas as células e não apenas um alvo.
penelope
@penelope, você pode verificar se células diferentes têm IDs de elementos html diferentes ou classes exclusivas. Se sim, você pode modificar minha resposta de acordo. Minha resposta afeta todas as células porque não diferencia as células.
Peter Zagubisalo
1

Você não precisa fazer muito, exceto para ativar as extensões:

http://localhost:8888/nbextensions?nbextension=collapsible_headings
http://localhost:8888/nbextensions?nbextension=codefolding/main

insira a descrição da imagem aqui

Muito provavelmente você encontrará todas as suas extensões aqui:

http://localhost:8888/nbextensions

insira a descrição da imagem aqui

prosti
fonte
1

O que eu uso para obter o resultado desejado é:

  1. Salve o bloco de código abaixo em um arquivo nomeado toggle_cell.pyno mesmo diretório do seu notebook
from IPython.core.display import display, HTML
toggle_code_str = '''
<form action="javascript:code_toggle()"><input type="submit" id="toggleButton" value="Show Sloution"></form>
'''

toggle_code_prepare_str = '''
    <script>
    function code_toggle() {
        if ($('div.cell.code_cell.rendered.selected div.input').css('display')!='none'){
            $('div.cell.code_cell.rendered.selected div.input').hide();
        } else {
            $('div.cell.code_cell.rendered.selected div.input').show();
        }
    }
    </script>

'''

display(HTML(toggle_code_prepare_str + toggle_code_str))

def hide_sloution():
    display(HTML(toggle_code_str))
  1. Adicione o seguinte na primeira célula do seu notebook
from toggle_cell import toggle_code as hide_sloution
  1. Qualquer célula que você precise adicionar o botão de alternância para simplesmente chamar hide_sloution()
ِ Abdalrahman M. Amer
fonte