web-dev-qa-db-fra.com

ipynb importer un autre fichier ipynb

Interactive Python (ipython) est tout simplement incroyable, surtout que vous assemblez des objets à la volée ... et que vous le faites de manière à ce qu'il soit facile de revenir en arrière.

Cependant, ce qui semble intéressant, c’est le cas d’utilisation de plusieurs cahiers ipython (fichiers ipynb). Apparemment, il semble qu'un ordinateur portable N'EST PAS censé entretenir une relation avec d'autres ordinateurs portables, ce qui est logique, sauf que j'aimerais importer d'autres fichiers ipynb.

La seule solution que je vois est la conversion de mes fichiers * .ipynb en fichiers * .py, qui peuvent ensuite être importés dans mon bloc-notes. Avoir un fichier contenant tout dans un projet est un peu bizarre, surtout si je veux vraiment encourager la réutilisation du code (n'est-ce pas un principe fondamental de python?).

Est-ce que je manque quelque chose? N’est-ce pas un cas d’utilisation pris en charge des ordinateurs portables ipython? Existe-t-il une autre solution que je peux utiliser pour importer un fichier ipynb dans un autre ordinateur portable? J'adorerais continuer à utiliser ipynb, mais cela me gêne vraiment dans mon flux de travail en ce moment :(

pythonimportworkflowipython
39
Andrew Harris

C'est très simple dans Jupyter plus récent:

%run MyOtherNotebook.ipynb
65
johndodo

Courir

!pip install ipynb

puis importez l'autre cahier sous le nom

from ipynb.fs.full.<notebook_name> import *

ou

from ipynb.fs.full.<notebook_name> import <function_name>

Assurez-vous que tous les cahiers sont dans le même répertoire.

1
Malgo

Le problème est qu'un cahier n'est pas un simple fichier python. Les étapes pour importer le fichier .ipynb sont décrites dans les sections suivantes: Importation du bloc-notes

Je colle le code, donc si vous en avez besoin ... vous pouvez simplement faire un copier-coller rapide. Notez qu'à la fin, j'ai l'instruction import primes. Vous devrez changer cela bien sûr. Le nom de mon fichier est primes.ipynb. À partir de ce moment, vous pouvez utiliser le contenu de ce fichier comme vous le feriez régulièrement.

J'aurais bien aimé avoir une méthode plus simple, mais celle-ci provient directement de la documentation.
Note: J'utilise jupyter pas ipython.

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


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


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 = current.read(f, 'json')


        # 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.worksheets[0].cells:
            if cell.cell_type == 'code' and cell.language == 'python':
                # transform the input to executable Python
                code = self.Shell.input_transformer_manager.transform_cell(cell.input)
                # run the code in themodule
                exec(code, mod.__dict__)
        finally:
            self.Shell.user_ns = save_user_ns
        return mod


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]

sys.meta_path.append(NotebookFinder())

import primes
0
germ13

Les commentaires mentionnés ci-dessus sont très utiles mais ils sont un peu difficiles à mettre en œuvre. Vous pouvez essayer ci-dessous les étapes, j'ai également essayé et cela a fonctionné: 

  1. Téléchargez ce fichier à partir de votre ordinateur portable au format de fichier PY (vous pouvez trouver cette option dans l'onglet Fichier).
  2. Maintenant, copiez ce fichier téléchargé dans le répertoire de travail de Jupyter Notebook
  3. Vous êtes maintenant prêt à l'utiliser. Il suffit d'importer le fichier .PY dans le fichier ipynb 
0
Yash Bansal

Assurez-vous également que vous ajoutez également un fichier __init__.py dans le package contenant tous vos autres fichiers .ipynb.

Cela s'ajoute au lien nbviewer que minrk et syi fourni ci-dessus.

J'ai également eu un problème similaire, puis j'ai écrit la solution ainsi qu'un lien vers mon dossier public google drive qui contient un exemple de travail :)

Mon post Stackoverflow avec une expérimentation et une solution étape par étape:

Jupyter Notebook: Importer un fichier .ipynb et accéder à sa méthode dans un autre fichier .ipynb en donnant une erreur

J'espère que cela aidera les autres aussi . Merci à tous!

0
anugrah

Il n’ya aucun problème à utiliser Jupyter avec les modules Python .py existants ou nouveaux. Avec Jupyter en marche, lancez simplement Spyder (ou n’importe quel éditeur de votre choix) pour construire/modifier vos définitions de classes de modules dans un fichier .py, puis importez simplement les modules nécessaires dans Jupyter.

L’utilisation de l’extension Magic à chargement automatique est une des choses qui rend cette opération vraiment transparente. Vous pouvez voir la documentation sur le chargement automatique ici:

http://ipython.readthedocs.io/fr/stable/config/extensions/autoreload.html

Voici le code pour recharger automatiquement le module chaque fois qu'il a été modifié:

# autoreload sets up auto reloading of modified .py modules
import autoreload
%load_ext autoreload
%autoreload 2

Notez que j’ai essayé le code mentionné dans une réponse précédente pour simuler le chargement de fichiers .ipynb en tant que modules et que cela fonctionnait bien, mais cela s’étouffe lorsque vous modifiez le fichier .ipynb. Il semble que vous ayez besoin de redémarrer l'environnement de développement Jupyter pour pouvoir recharger le 'module' .ipynb, ce qui n'était pas acceptable pour moi car j'apporte beaucoup de modifications à mon code.

0
David Miller

Vous pouvez utiliser import nbimporter puis import notebookName

0
Fractale