Réduire la cellule dans le bloc-notes Jupyter

J'utilise le notebook ipython Jupyter. Disons que j'ai défini une fonction qui occupe beaucoup d'espace sur mon écran. Existe-t-il un moyen de réduire la cellule?

Je veux que la fonction reste exécutée et appelable, mais je veux masquer / réduire la cellule afin de mieux visualiser le cahier. Comment puis-je faire ceci?

le jupyter contrib nbextensions package Python contient une extension de pliage de code qui peut être activée dans le bloc-notes. Suivez le lien (Github) pour la documentation.

Pour installer en utilisant la ligne de commande:

pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user

Pour faciliter leur gestion, je recommande également le jupyter nbextensions configurator package. Cela fournit un onglet supplémentaire dans l'interface de votre ordinateur portable à partir duquel vous pouvez facilement (dés) activer toutes les extensions installées.

Installation:

pip install jupyter_nbextensions_configurator
jupyter nbextensions_configurator enable --user

JupyterLab prend en charge la réduction des cellules. Cliquer sur la barre de cellule bleue à gauche pliera la cellule.

Vous pouvez créer une cellule et y mettre le code suivant:

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

L'exécution de cette cellule masquera toutes les cellules d'entrée. Pour les afficher, vous pouvez utiliser le menu pour effacer toutes les sorties.

Sinon, vous pouvez essayer les extensions de notebook comme ci-dessous:

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

J'ai eu un problème similaire et les "nbextensions" signalées par @Energya fonctionnaient très bien et sans effort. Les instructions d'installation sont simples (j'ai essayé avec anaconda sous Windows) pour les extensions de notebook et pour leur configurateur .

Cela dit, je voudrais ajouter que les extensions suivantes devraient être intéressantes.

• Masquer l'entrée | Cette extension permet de cacher un codecell individuel dans un notebook. Ceci peut être réalisé en cliquant sur le bouton de la barre d'outils:

• En-têtes réductibles | Permet au notebook d'avoir des sections réductibles, séparées par des en-têtes

• Codefolding | Cela a été mentionné mais je l'ajoute par souci d'exhaustivité

Créez un fichier custom.js dans ~ / .jupyter / custom / avec le contenu suivant:

$("<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');
    }
});

Après l'enregistrement, redémarrez le serveur et actualisez le notebook. Vous pouvez réduire n'importe quelle cellule en cliquant sur l'étiquette d'entrée (Dans []).

L'extension hide_code vous permet de masquer des cellules individuelles et / ou les invites à côté d'elles. Installer en tant que

pip3 install hide_code

Visitez https://github.com/kirbs-/hide_code/ pour plus d'informations sur cette extension.

Tout d'abord, suivez les instructions d'Energya:

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

La deuxième est la clé: après avoir ouvert le notebook Jupiter, cliquez sur l'onglet Nbextension. Maintenant, recherchez "colla" à partir de l'outil de recherche fourni par Nbextension (et non par le navigateur Web) , puis vous trouverez quelque chose appelé "En-têtes réductibles"

Voici ce que tu veux!

Comme d'autres l'ont mentionné, vous pouvez le faire via nbextensions. Je voulais donner une brève explication de ce que j'ai fait, ce qui a été rapide et facile:

Pour activer les en-têtes réductibles: Dans votre terminal, activez / installez les extensions Jupyter Notebook en saisissant d'abord:

pip install jupyter_contrib_nbextensions

Ensuite, entrez:

jupyter contrib nbextension install

Rouvrez Jupyter Notebook. Allez dans l'onglet "Edition" et sélectionnez "nbextensions config". Décochez la case directement sous le titre "nbextensions configurables", puis sélectionnez "en-têtes réductibles".

Il y a beaucoup de réponses à cette question, qui ne me semblent pas satisfaisantes (certaines plus que d'autres), des nombreuses extensions - pliage de code, pliage par en-têtes, etc. Aucune ne fait ce que je veux de manière simple et efficace. Je suis littéralement étonné qu'une solution n'ait pas été mise en œuvre (comme pour Jupyter Lab).

En fait, j'étais tellement insatisfait que j'ai développé une extension de notebook très simple qui peut développer / réduire le code dans une cellule de notebook, tout en le gardant exécutable.

Le référentiel GitHub: https://github.com/BenedictWilkinsAI/cellfolding

Voici une petite démonstration de ce que fait l'extension:

Il suffit de double-cliquer à gauche de la cellule de code pour la réduire en une seule ligne:

Double-cliquez à nouveau pour agrandir la cellule.

L'extension peut être installée facilement avec pip:

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

et est également compatible avec le configurateur nbextension . J'espère que les gens trouveront cela utile!

Il existe également une version améliorée de la suggestion Pan Yan. Il ajoute le bouton qui affiche les cellules de code:

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

Vous n'avez pas besoin de faire grand chose sauf pour activer les extensions:

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

Très probablement, vous trouverez toutes vos extensions ici:

http://localhost:8888/nbextensions

Ce que j'utilise pour obtenir le résultat souhaité est:

1. Enregistrez le bloc de code ci-dessous dans un fichier nommé toggle_cell.pydans le même répertoire que celui de votre 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. Ajoutez ce qui suit dans la première cellule de votre bloc-notes

from toggle_cell import toggle_code as hide_sloution

3. Toute cellule dont vous avez besoin pour ajouter le bouton bascule pour appeler simplement hide_sloution()