Comment importer NoteBook en tant que module dans Jupyter (IPython)

Si vous utilisez Jupyter, vous souhaiterez réutiliser les fonctions et les résultats d'un autre notebook (fichier ipynb). Il y avait un moyen officiel de l'importer en tant que module python, je vais donc le présenter. (Je vais l'utiliser plusieurs fois dans le futur, alors incluez la signification de mon mémorandum)

Exemple de site officiel: http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Importing%20Notebooks.html

Pour ce faire, exécutez notebook, enregistrez le résultat en tant que module et utilisez sys.meta_path pour raccorder et appeler import. Le notebook s'exécutera lorsque l'importation sera appelée, mais soyez assuré qu'il ne changera pas son état d'origine.

Ci-dessous le code.

import io, os, sys, types
from IPython import get_ipython
from nbformat import read
from IPython.core.interactiveshell import InteractiveShell

def find_notebook(fullname, path=None):
    name = fullname.rsplit('.', 1)[-1]
    if not path:
        path = ['']
    for d in path:
        nb_path = os.path.join(d, name + ".ipynb")
        if os.path.isfile(nb_path):
            return nb_path
        nb_path = nb_path.replace("_", " ")
        if os.path.isfile(nb_path):
            return nb_path

class NotebookLoader(object):
    def __init__(self, path=None):
        self.shell = InteractiveShell.instance()
        self.path = path

    def load_module(self, fullname):
        path = find_notebook(fullname, self.path)
        with io.open(path, 'r', encoding='utf-8') as f:
            nb = read(f, 4)
        mod = types.ModuleType(fullname)
        mod.__file__ = path
        mod.__loader__ = self
        mod.__dict__['get_ipython'] = get_ipython
        sys.modules[fullname] = mod
        save_user_ns = self.shell.user_ns
        self.shell.user_ns = mod.__dict__
        try:
          for cell in nb.cells:
            if cell.cell_type == 'code':
                code = self.shell.input_transformer_manager.transform_cell(cell.source)
                exec(code, mod.__dict__)
        finally:
            self.shell.user_ns = save_user_ns
        return mod

class NotebookFinder(object):
    def __init__(self):
        self.loaders = {}

    def find_module(self, fullname, path=None):
        nb_path = find_notebook(fullname, path)
        if not nb_path:
            return
        key = path
        if path:
            key = os.path.sep.join(path)
        if key not in self.loaders:
            self.loaders[key] = NotebookLoader(path)
        return self.loaders[key]

Enregistrez-le sous notebookutil.py etc. Lors de l'utilisation

import sys
import notebookutil as nbu
sys.meta_path.append(nbu.NotebookFinder())

Ensuite, vous pouvez importer le notebook.

import mynotebook

Bien sûr, vous pouvez utiliser des fonctions et des classes, mais comme vous exécutez réellement notebook, vous pouvez importer des variables avec les valeurs au moment de l'exécution. Super pratique! !!

De plus, comme il est en cours d'exécution, print, plt.show, etc. sont affichés, mais si vous exécutez à nouveau la cellule qui importe le notebook, il disparaîtra.

Cela vous donnera une vie Jupyter plus confortable.