Explorateur de variables dans Jupyter Notebook

Question

Y a-t-il un explorateur de variables dans Jupyter (IPython) comme dans Spyder ? C'est très inconfortable de devoir imprimer la liste des variables à chaque fois que j'exécute le code de test.

Cette fonctionnalité a-t-elle déjà été mise en œuvre ? Si oui, comment l'activer ?

Answer 1

UPDATE

Faites défiler la page jusqu'à la section intitulée "Mise à jour" pour découvrir une méthode beaucoup moins compliquée.

ANCIENNE RÉPONSE

Voici un carnet de notes sur la façon de faire le vôtre Inspecteur variable . Je pense qu'il a été écrit à l'époque où jupyter notebook s'appelait ipython notebook mais il fonctionne sur la dernière version.

Je vais afficher le code ci-dessous, au cas où le lien ne fonctionnerait pas.

import ipywidgets as widgets # Loads the Widget framework.
from IPython.core.magics.namespace import NamespaceMagics # Used to query namespace.

# For this example, hide these names, just to avoid polluting the namespace further
get_ipython().user_ns_hidden['widgets'] = widgets
get_ipython().user_ns_hidden['NamespaceMagics'] = NamespaceMagics

class VariableInspectorWindow(object):
    instance = None

def __init__(self, ipython):
    """Public constructor."""
    if VariableInspectorWindow.instance is not None:
        raise Exception("""Only one instance of the Variable Inspector can exist at a 
            time.  Call close() on the active instance before creating a new instance.
            If you have lost the handle to the active instance, you can re-obtain it
            via `VariableInspectorWindow.instance`.""")

    VariableInspectorWindow.instance = self
    self.closed = False
    self.namespace = NamespaceMagics()
    self.namespace.shell = ipython.kernel.shell

    self._box = widgets.Box()
    self._box._dom_classes = ['inspector']
    self._box.background_color = '#fff'
    self._box.border_color = '#ccc'
    self._box.border_width = 1
    self._box.border_radius = 5

    self._modal_body = widgets.VBox()
    self._modal_body.overflow_y = 'scroll'

    self._modal_body_label = widgets.HTML(value = 'Not hooked')
    self._modal_body.children = [self._modal_body_label]

    self._box.children = [
        self._modal_body, 
    ]

    self._ipython = ipython
    self._ipython.events.register('post_run_cell', self._fill)

def close(self):
    """Close and remove hooks."""
    if not self.closed:
        self._ipython.events.unregister('post_run_cell', self._fill)
        self._box.close()
        self.closed = True
        VariableInspectorWindow.instance = None

def _fill(self):
    """Fill self with variable information."""
    values = self.namespace.who_ls()
    self._modal_body_label.value = '<table class="table table-bordered table-striped"><tr><th>Name</th><th>Type</th><th>Value</th></tr><tr><td>' + \
        '</td></tr><tr><td>'.join(['{0}</td><td>{1}</td><td>{2}'.format(v, type(eval(v)).__name__, str(eval(v))) for v in values]) + \
        '</td></tr></table>'

def _ipython_display_(self):
    """Called when display() or pyout is used to display the Variable 
    Inspector."""
    self._box._ipython_display_()

Exécuter en ligne avec ce qui suit :

inspector = VariableInspectorWindow(get_ipython())
inspector

Faites-en un pop out en javascript ;

%%javascript
$('div.inspector')
    .detach()
    .prependTo($('body'))
    .css({
        'z-index': 999, 
        position: 'fixed',
        'box-shadow': '5px 5px 12px -3px black',
        opacity: 0.9
    })
    .draggable();

UPDATE

Date : 17 mai 2017

@jfbercher a créé un inspecteur de variables nbextension. Le code source peut être vu ici jupyter_contrib_nbextensions . Pour plus d'informations, voir le docs .

Installer

Utilisateur

pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user

Environnement virtuel

pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --sys-prefix

Activer

jupyter nbextension enable varInspector/main

Voici une capture d'écran ;

Answer 2

Cela pourrait vous aider, bien que ce ne soit pas exactement ce que propose Spyder et que ce soit beaucoup plus simple :

Pour obtenir une liste de toutes les variables actuellement définies, exécutez qui :

In [1]: foo = 'bar'

In [2]: who
foo

Pour plus de détails, exécutez qui est :

In [3]: whos
Variable   Type    Data/Info
----------------------------
foo        str     bar

Pour une liste complète des fonctions intégrées, voir Commandes magiques

Answer 3

Si vous utilisez Jupyter Notebooks au sein de Jupyter Lab il y a eu beaucoup de discussions sur l'implémentation d'un explorateur/inspecteur de variables. Vous pouvez suivre la question ici

Pour l'instant, il existe une extension Jupyter Lab en cours de réalisation qui implémente un explorateur de variables de type Spyder. Elle est basée sur l'extension notebook que James a mentionnée dans sa réponse. Vous pouvez trouver l'extension Lab (avec les instructions d'installation) ici : https://github.com/lckr/jupyterlab-variableInspector

Answer 4

Si vous utilisez Visual Studio Code, il est déjà là :

Answer 5

Une autre solution serait de connecter la console spyder au noyau en cours d'exécution.

Sur n'importe quelle plateforme, il le serait :

1. Dans jupyter : exécutez la commande suivante ( de cette source ) :

   from jupyter_client import find_connection_file print(find_connection_file()) #this will show which json-file is associated to your jupyter

cela devrait vous donner quelque chose comme : ~/.local/share/jupyter/runtime/kernel-<SOME-ID>.json'

2. Dans votre console spyder, faites un clic droit et sélectionnez " Se connecter à un noyau existant ", naviguez jusqu'au fichier que vous avez trouvé précédemment.
   • cochez la case " Sauvegarder les paramètres de connexion "pour faciliter sa recherche la prochaine fois.
   • décocher la case " Ceci est un noyau distant (via SSH) " (sauf si vous savez ce que vous faites)
3. Vous pouvez ensuite parcourir les variables avec spyder qui sont dans votre instance de jupyter.

L'avantage de cette méthode est que vous n'avez pas besoin d'installer un paquet supplémentaire, vous avez juste besoin de spyder et jupyter.

EDIT : J'étais trop optimiste, mais il semble que spyder a aussi un problème Je peux utiliser les variables dans la console, mais elles ne s'affichent pas dans l'interface graphique/navigateur. Je laisse la réponse dans l'espoir que cela soit corrigé à l'avenir. (cela peut aussi fonctionner en fonction de la version que vous avez installée). Peut-être qu'une solution serait de connecter le jupyter à un noyau existant, mais je n'ai pas été capable de le faire fonctionner. Toute aide est la bienvenue !