将 Jupyter 笔记本导入为模块

人们希望从 Jupyter 笔记本导入代码是一个常见问题。由于笔记本不是纯 Python 文件，因此无法通过常规 Python 机制导入，这使得导入变得困难。

幸运的是，Python 提供了一些相当复杂的 钩子 到导入机制中，因此我们实际上可以使 Jupyter 笔记本可导入，而无需太多困难，并且仅使用公共 API。

import io, os, sys, types

from IPython import get_ipython
from nbformat import read
from IPython.core.interactiveshell import InteractiveShell

导入钩子通常采用两个对象的形式

1. 一个模块 **加载器**，它接受一个模块名称（例如 'IPython.display'），并返回一个模块

2. 一个模块 **查找器**，它确定模块是否存在，并告诉 Python 使用哪个 **加载器**

def find_notebook(fullname, path=None):
    """find a notebook, given its fully qualified name and an optional path

    This turns "foo.bar" into "foo/bar.ipynb"
    and tries turning "Foo_Bar" into "Foo Bar" if Foo_Bar
    does not exist.
    """
    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
        # let import Notebook_Name find "Notebook Name.ipynb"
        nb_path = nb_path.replace("_", " ")
        if os.path.isfile(nb_path):
            return nb_path

Notebook 加载器

这里我们有我们的 Notebook 加载器。它实际上非常简单 - 一旦我们确定了模块的文件名，它所做的就是

1. 将笔记本文档加载到内存中

2. 创建一个空模块

3. 在模块命名空间中执行每个单元格

由于 IPython 单元格可以具有扩展语法，因此 IPython 转换将应用于将这些单元格中的每一个转换为它们的纯 Python 对应项，然后再执行它们。如果您的所有笔记本单元格都是纯 Python，则此步骤是不必要的。

class NotebookLoader(object):
    """Module Loader for Jupyter Notebooks"""

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

    def load_module(self, fullname):
        """import a notebook as a module"""
        path = find_notebook(fullname, self.path)

        print("importing Jupyter notebook from %s" % path)

        # load the notebook object
        with io.open(path, 'r', encoding='utf-8') as f:
            nb = read(f, 4)

        # create the module and add it to sys.modules
        # if name in sys.modules:
        #    return sys.modules[name]
        mod = types.ModuleType(fullname)
        mod.__file__ = path
        mod.__loader__ = self
        mod.__dict__['get_ipython'] = get_ipython
        sys.modules[fullname] = mod

        # extra work to ensure that magics that would affect the user_ns
        # actually affect the notebook module's ns
        save_user_ns = self.shell.user_ns
        self.shell.user_ns = mod.__dict__

        try:
            for cell in nb.cells:
                if cell.cell_type == 'code':
                    # transform the input to executable Python
                    code = self.shell.input_transformer_manager.transform_cell(cell.source)
                    # run the code in themodule
                    exec(code, mod.__dict__)
        finally:
            self.shell.user_ns = save_user_ns
        return mod

模块查找器

查找器是一个简单的对象，它告诉您是否可以导入名称，并返回相应的加载器。它所做的就是检查，当你执行

import mynotebook

它检查 mynotebook.ipynb 是否存在。如果找到笔记本，则它将返回 NotebookLoader。

任何额外的逻辑只是为了解析包中的路径。

class NotebookFinder(object):
    """Module finder that locates Jupyter Notebooks"""

    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:
            # lists aren't hashable
            key = os.path.sep.join(path)

        if key not in self.loaders:
            self.loaders[key] = NotebookLoader(path)
        return self.loaders[key]

注册钩子

现在我们将 NotebookFinder 注册到 sys.meta_path 中

sys.meta_path.append(NotebookFinder())

从这一点开始，我的笔记本应该可以导入。

让我们看看 CWD 中有什么

ls nbpackage

所以，我应该能够使用 import nbpackage.mynotebook 来导入。

import nbpackage.mynotebook

旁注：显示笔记本

这里有一些简单的代码可以显示笔记本的内容，包括语法高亮等。

from pygments import highlight
from pygments.lexers import PythonLexer
from pygments.formatters import HtmlFormatter

from IPython.display import display, HTML

formatter = HtmlFormatter()
lexer = PythonLexer()

# publish the CSS for pygments highlighting
display(
    HTML(
        """
<style type='text/css'>
%s
</style>
"""
        % formatter.get_style_defs()
    )
)

def show_notebook(fname):
    """display a short summary of the cells of a notebook"""
    with io.open(fname, 'r', encoding='utf-8') as f:
        nb = read(f, 4)
    html = []
    for cell in nb.cells:
        html.append("<h4>%s cell</h4>" % cell.cell_type)
        if cell.cell_type == 'code':
            html.append(highlight(cell.source, lexer, formatter))
        else:
            html.append("<pre>%s</pre>" % cell.source)
    display(HTML('\n'.join(html)))


show_notebook(os.path.join("nbpackage", "mynotebook.ipynb"))

我的笔记本中有一些代码单元格，其中一个包含一些 IPython 语法。

让我们看看导入它会发生什么。

from nbpackage import mynotebook

万岁，它导入了！它能工作吗？

mynotebook.foo()

再次万岁！

即使包含 IPython 语法的函数也能正常工作。

mynotebook.has_ip_syntax()

包中的笔记本

我们还在 nb 包中有一个笔记本，所以让我们确保它也能正常工作。

ls nbpackage/nbs

请注意，__init__.py 是必需的，以便 nb 被视为一个包，就像往常一样。

show_notebook(os.path.join("nbpackage", "nbs", "other.ipynb"))

from nbpackage.nbs import other

other.bar(5)

所以现在我们有了可导入的笔记本，既可以从本地目录导入，也可以从包中导入。

我甚至可以将一个笔记本放在 IPython 中，以进一步证明它正常工作。

import shutil
from IPython.paths import get_ipython_package_dir

utils = os.path.join(get_ipython_package_dir(), 'utils')
shutil.copy(
    os.path.join("nbpackage", "mynotebook.ipynb"), os.path.join(utils, "inside_ipython.ipynb")
)

并从 IPython.utils 导入笔记本。

from IPython.utils import inside_ipython

inside_ipython.whatsmyname()

这种方法甚至可以导入使用 %%cython 魔法定义的笔记本中的函数和类。