colapso celular no notebook jupyter

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?

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

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

O JupyterLab suporta o colapso de células. Clicar na barra de célula azul à esquerda dobrará a célula.

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:

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

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

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 []).

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.

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!

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".

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!

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

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

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

http://localhost:8888/nbextensions

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

2. Adicione o seguinte na primeira célula do seu notebook

from toggle_cell import toggle_code as hide_sloution

3. Qualquer célula que você precise adicionar o botão de alternância para simplesmente chamar hide_sloution()