notebook - ipython import again

ipynb importa otro archivo ipynb

Question

Interactive Python (ipython) es simplemente increíble, especialmente cuando estás juntando cosas sobre la marcha ... y lo hace de tal manera que es fácil volver atrás.

Sin embargo, lo que parece ser interesante es el caso de uso de tener múltiples portátiles ipython (archivos ipynb). Aparentemente parece que un cuaderno NO debe tener una relación con otros portátiles, lo que tiene sentido, excepto que me encantaría importar otros archivos ipynb.

La única solución que veo es convertir mis archivos * .ipynb en archivos * .py, que luego se pueden importar a mi computadora portátil. Tener un archivo que contenga todo en un proyecto es un poco extraño, especialmente si realmente quiero impulsar la reutilización de código (¿no es ese un principio básico de Python?).

¿Me estoy perdiendo de algo? ¿No es esto un caso de uso soportado de los portátiles ipython? ¿Hay alguna otra solución que pueda utilizar para esta importación de un archivo ipynb en otro portátil? Me encantaría seguir usando ipynb, pero realmente está arruinando mi flujo de trabajo ahora mismo (

Answer 1

Asegúrese de agregar también un archivo __init__.py en el paquete donde se encuentran todos sus otros archivos .ipynb.

Esto se suma al enlace minrk que minrk y syi proporcionaron anteriormente.

También tuve un problema similar y luego escribí la solución, así como un enlace a mi carpeta pública de Google Drive, que tiene un ejemplo de trabajo :)

Mi publicación de Stackoverflow con experimentación paso a paso y solución:

Jupyter Notebook: Importar archivo .ipynb y acceder a su método en otro archivo .ipynb dando error

Espero que esto ayude a otros también. ¡Gracias a todos!

Answer 2

El problema es que un cuaderno no es un archivo simple de Python. Los pasos para importar el archivo .ipynb se describen a continuación: Importar el cuaderno

Estoy pegando el código, así que si lo necesitas ... puedes hacer una copia rápida y pegarlo. Tenga en cuenta que al final tengo la instrucción de import primes . Tendrás que cambiar eso por supuesto. El nombre de mi archivo es primes.ipynb . A partir de este punto, puede usar el contenido dentro de ese archivo como lo haría regularmente.

Desearía que hubiera un método más simple, pero esto es directamente de los documentos.
Nota: Estoy usando jupyter no 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

Answer 3

Es realmente simple en Jupyter más nuevo:

%run MyOtherNotebook.ipynb

Answer 4

Los comentarios mencionados anteriormente son muy útiles pero son un poco difíciles de implementar. Debajo de los pasos puedes probar, también lo intenté y funcionó:

1. Descargue ese archivo de su computadora portátil en formato de archivo PY (puede encontrar esa opción en la pestaña Archivo).
2. Ahora copie ese archivo descargado en el directorio de trabajo de Jupyter Notebook
3. Ahora estás listo para usarlo. Solo importa el archivo .PY en el archivo ipynb

Answer 5

No hay ningún problema en absoluto al usar Jupyter con módulos Python .py existentes o nuevos. Con Jupyter ejecutándose, simplemente inicie Spyder (o cualquier editor de su elección) para construir / modificar las definiciones de clase de su módulo en un archivo .py, y luego solo importe los módulos según sea necesario en Jupyter.

Una cosa que lo hace realmente perfecto es usar la extensión mágica de autorrecarga. Puede ver la documentación para la recarga automática aquí:

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

Aquí está el código para volver a cargar automáticamente el módulo en cualquier momento que se haya modificado:

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

Tenga en cuenta que probé el código mencionado en una respuesta anterior para simular la carga de archivos .ipynb como módulos, y lo puse a funcionar, pero se bloquea cuando realiza cambios en el archivo .ipynb. Parece que necesita reiniciar el entorno de desarrollo Jupyter para poder cargar el .ipynb ''module'', que no era aceptable para mí ya que estoy haciendo muchos cambios en mi código.

Answer 6

Si quiere importar A.ipynb de B.ipynb escriba

import import_ipynb
import A

en B.ipynb .

El módulo import_ipynb que he creado se instala a través de pip:

pip install import_ipynb

Es solo un archivo y se adhiere estrictamente al howto oficial en el sitio jupyter.

PS: también admite cosas como from A import foo , from A import * etc.

Answer 7

Este ejemplo muestra cómo importar libretas de IPython como módulos sin exportar duplicados como scripts.