Kann eine IPython/Jupyter Notebook-Zelle importiert werden, als wäre es ein Modul?

Question

Gibt es eine Möglichkeit in IPython import den Inhalt einer Notebook-Zelle, als ob es ein separates Modul wäre? Oder erhalte alternativ den Inhalt einer Zelle mit einem eigenen Namensraum.

Answer 1

@ Mike, wie im Kommentar erwähnt, um die gut dokumentierten Schritten in dem folgenden Link folgen kann Jupyter Notebook als Modul zu importieren:

Importing Jupyter Notebooks as Modules

Im Link wird sie die Arbeit getan erwähnen in Python, um Benutzern hooks (jetzt ersetzt durch importlib und import system) zu bieten, um eine bessere Anpassung des Importmechanismus zu ermöglichen.

Wie so das Rezept sie vorschlagen, ist das folgende:

• Last des Notebook-Dokument in dem Speicher
• ein leeres Modul erstellen
• jede Zelle im Modul Namespace ausführen

, und sie bieten ihre eigene Implementierung für die Notebook Loader (nicht erforderlich, wenn der Code alle reinen Python ist):

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 

Auch hier ist die Implementierung für die Notebook Finder:

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] 

Und der letzte Schritt ist die registration des neuen Moduls:

sys.meta_path.append(NotebookFinder()) 

All dies ist jedoch ein direktes Zitat aus dem ersten Link in dieser Antwort gegeben. Das Dokument ist gut gebaut und bietet Antworten für andere Dinge wie displaying notebooks oder im Umgang mit packages.