ipynb importer un autre fichier ipynb

90

Le Python interactif (ipython) est tout simplement incroyable, d'autant plus que vous assemblez des choses à la volée ... et le fait 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 blocs-notes ipython (fichiers ipynb). Il semble apparemment qu'un ordinateur portable n'est PAS censé avoir une relation avec d'autres ordinateurs portables, ce qui est logique, sauf que j'aimerais importer d'autres fichiers ipynb.

La seule solution de contournement que je vois est de convertir mes fichiers * .ipynb en fichiers * .py, qui peuvent ensuite être importés dans mon ordinateur portable. Avoir un fichier contenant tout dans un projet est un peu étrange, surtout si je veux vraiment pousser pour 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 blocs-notes ipython? Existe-t-il une autre solution que je peux utiliser pour cette importation d'un fichier ipynb dans un autre notebook? J'adorerais continuer à utiliser ipynb, mais cela perturbe vraiment mon flux de travail en ce moment :(

Andrew Harris
la source
Double possible: stackoverflow.com/questions/19082397/…
Warren Weckesser
2
Vous pouvez démarrer le serveur de notebooks avec --scriptpour enregistrer des copies .py de vos notebooks. Dans IPython 2.0, vous pourrez créer %runun notebook. Nous travaillons toujours à de meilleurs mécanismes pour la réutilisation du code.
Thomas K
1
Cet exemple montre comment importer des blocs-notes IPython en tant que modules sans exporter les doublons en tant que scripts.
minrk

Réponses:

130

C'est vraiment simple dans le nouveau Jupyter:

%run MyOtherNotebook.ipynb
johndodo
la source
5
% run MyOtherNotebook.ipynb a fait le travail pour moi. (no '')
Florian H
6
Attention, cette méthode exécutera complètement le notebook enfant. Vous pouvez ajouter une vérification __name__ == '__main__' and '__file__' not in globals()pour vérifier si vous êtes dans le bloc-notes enfant. (de blog.sicara.com/… )
Flavian Hautbois
8
% run 'MyOtherNotebook.ipynb' ERREUR: racine: fichier u'MyOtherNotebook.ipynb.py'introuvable.
user3673
1
@ Kocur4d Merci pour la correction! Il est intéressant de noter que cela a fonctionné pour moi (avec des guillemets) lorsque je l'ai essayé, mais les exemples dans la documentation n'ont pas de citations.
johndodo
3
si quelqu'un rencontre cela, vous pouvez également utiliser le chemin complet comme% run "/path/to/my/file/notebook.ipynb"
Jeremie
33

Si vous souhaitez importer A.ipynben B.ipynbécriture

import import_ipynb
import A

dans B.ipynb.

Le import_ipynbmodule que j'ai créé est installé via pip:

pip install import_ipynb

Ce n'est qu'un fichier et il adhère strictement au howto officiel sur le site jupyter.

PS Il prend également en charge des choses comme from A import foo, from A import *etc.

aisselle
la source
@Crash pip install import-ipynbfonctionne également et installe le même package, mais comme python ne vous permet pas d'écrire import import-ipynbet considérant qu'il ne s'agit que d'un seul fichier, cela pip install import_ipynbme semble plus cohérent.
axil
3
Y a-t-il une différence entre import nbimporteret import import_ipynb?
Fractale
1
Cela ne fonctionne pas du tout dans mon Jupyter avec Python 3
Sebastialonso
@Sebastialonso Qu'est-ce qui ne fonctionne pas exactement? Décrivez ce que vous faites et les messages d'erreur que vous voyez. Idéalement, ouvrez un ticket sur github.
axil
@axil J'ai la même erreur où cela ne fonctionne pas pour moi dans Py3. Cela me donne l'erreur suivante - ModuleNotFoundError: Aucun module nommé 'A' PS: A.ipynb n'existe dans le même dossier
Soman Dubey
10

Courir

!pip install ipynb

puis importez l'autre notebook sous

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

ou

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

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

Edit 1: Vous pouvez voir la documentation officielle ici - https://ipynb.readthedocs.io/en/stable/

De plus, si vous souhaitez importer uniquement des définitions de classe et de fonction à partir d'un notebook (et non les instructions de niveau supérieur), vous pouvez utiliser à la ipynb.fs.defsplace de ipynb.fs.full. L'affectation complète des variables majuscules sera également évaluée.

Malgo
la source
Que faire si mon nom de fichier contient des espaces?
Sameh
Il est conseillé de ne conserver aucun espace dans votre nom de fichier
Malgo
2
Notez que dans les deux cas décrits, le bloc-notes importé est exécuté intégralement. Le ipynbpackage prend également en charge l'exécution partielle des définitions uniquement. C'est un paquet officiel d'IPyhton, donc je pense que cela devrait être la réponse acceptée.
amka66 le
Cela peut-il importer des blocs-notes dans un dossier? par exempleMyFolder/book.ipynb
bones225
Cela avait l'air bien mais tombe quand il rencontre par exemple% matplotlib inline ....
jtlz2
7

Installez ipynb à partir de votre invite de commande

pip install import-ipynb

Importez dans votre fichier notebook

import import_ipynb

Maintenant, utilisez la commande d'importation régulière pour importer votre fichier

import MyOtherNotebook
hors du monde
la source
Réponse la plus simple mais explicative. Merci!
The Poor Jew
3

Vous pouvez utiliser import nbimporteralorsimport notebookName

Fractale
la source
+1, nbimporter fonctionne comme un charme pour moi, il peut également être installé en utilisant conda:conda install -c conda-forge importnb
Zuku
2

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

  1. Téléchargez ce fichier depuis 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. Importez simplement le fichier .PY dans le fichier ipynb
Yash Bansal
la source
hmm ... J'ai converti le fichier callee.ipync en fichier callee.py, puis j'ai téléchargé le fichier callee.py sur le cahier sous le même dossier avec caller.ipync, et le dans caller.ipync que je viens d'écrire import callee, je ne pouvais tout simplement pas travail.
Elsa Lin
ps l'IPython est la version: 5.1.0.
Elsa Lin
1

Le problème est qu'un notebook n'est pas un simple fichier Python. Les étapes d'importation du .ipynbfichier sont décrites ci-dessous: Importation du bloc-notes

Je suis en train de coller le code, donc si vous en avez besoin ... vous pouvez simplement faire un copier-coller rapide. Remarquez qu'à la fin j'ai la import primesdéclaration. Vous devrez bien sûr changer cela. 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 aimé qu'il y ait une méthode plus simple, mais cela vient directement de la documentation.
Remarque: j'utilise jupyter et non 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
germe13
la source
1

Il n'y a aucun problème à utiliser Jupyter avec des modules Python .py existants ou nouveaux. Avec Jupyter en cours d'exécution, lancez simplement Spyder (ou n'importe quel éditeur de votre choix) pour créer / modifier vos définitions de classe de module dans un fichier .py, puis importez simplement les modules selon vos besoins dans Jupyter.

Une chose qui rend cela vraiment transparent est l'utilisation de l'extension magique de chargement automatique. Vous pouvez voir la documentation pour le chargement automatique ici:

http://ipython.readthedocs.io/en/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 je l'ai fait fonctionner, mais cela s'étouffe lorsque vous apportez des modifications au fichier .ipynb. Il semble que vous deviez redémarrer l'environnement de développement Jupyter afin de recharger le «module» .ipynb, ce qui n'était pas acceptable pour moi car j'apporte beaucoup de modifications à mon code.

David Miller
la source
0

Veuillez vous assurer que vous ajoutez également un __init__.pyfichier dans le package où se trouvent tous vos autres fichiers .ipynb.

Ceci est en plus le lien qui nbviewer minrket syifourni 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 a un exemple fonctionnel :)

Mon article Stackoverflow avec expérimentation étape par étape et solution:

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

J'espère que cela aidera également les autres. Merci a tous!

anugrah
la source