ipynb importar otro archivo ipynb

Interactive Python (ipython) es simplemente asombroso, especialmente porque 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 varios cuadernos ipython (archivos ipynb). Aparentemente, parece que NO se supone que un portátil tenga una relación con otros portátiles, lo cual 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 cuaderno. Tener un archivo que contenga todo en un proyecto es un poco extraño, especialmente si realmente quiero impulsar la reutilización del código (¿no es ese un principio básico de Python?)

¿Me estoy perdiendo de algo? ¿No es este un caso de uso compatible con los portátiles ipython? ¿Existe otra solución que pueda usar para esta importación de un archivo ipynb a otro portátil? Me encantaría seguir usando ipynb, pero realmente está arruinando mi flujo de trabajo en este momento :(

Es realmente simple en el nuevo Jupyter:

%run MyOtherNotebook.ipynb

Si desea importar A.ipynbpor B.ipynbescrito

import import_ipynb
import A

en B.ipynb.

El import_ipynbmódulo 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 del sitio de jupyter.

PD: también es compatible con cosas como from A import foo, from A import *etc.

correr

!pip install ipynb

y luego importar el otro cuaderno como

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

o

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

Asegúrese de que todos los cuadernos estén en el mismo directorio.

Edición 1: puede ver la documentación oficial aquí: https://ipynb.readthedocs.io/en/stable/

Además, si desea importar solo definiciones de clases y funciones desde un cuaderno (y no las declaraciones de nivel superior), puede usar en ipynb.fs.defslugar de ipynb.fs.full. También se evaluará la asignación completa de variables en mayúsculas.

Instale ipynb desde su símbolo del sistema

pip install import-ipynb

Importar en su archivo de cuaderno

import import_ipynb

Ahora use el comando de importación regular para importar su archivo

import MyOtherNotebook

Puedes usar import nbimporterentoncesimport notebookName

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

1. Descargue ese archivo de su cuaderno 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á listo para usarlo. Simplemente importe el archivo .PY al archivo ipynb

El problema es que un cuaderno no es un archivo Python simple. Los pasos para importar el .ipynbarchivo se describen a continuación: Importación del cuaderno

Estoy pegando el código, así que si lo necesitas ... puedes copiar y pegar rápidamente. Note que al final tengo la import primesdeclaración. Tendrás que cambiar eso, por supuesto. El nombre de mi archivo es primes.ipynb. A partir de este momento, puede utilizar el contenido de ese archivo como lo haría habitualmente.

Ojalá 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

No hay ningún problema al utilizar Jupyter con módulos .py de Python nuevos o existentes. 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 simplemente importe los módulos según sea necesario en Jupyter.

Una cosa que hace que esto sea realmente perfecto es usar la extensión mágica de recarga automática. 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 recargar automáticamente el módulo cada vez 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 hice funcionar, pero se ahoga cuando realiza cambios en el archivo .ipynb. Parece que necesita reiniciar el entorno de desarrollo de Jupyter para volver a cargar el 'módulo' .ipynb, lo cual no era aceptable para mí ya que estoy haciendo muchos cambios en mi código.

Asegúrese de agregar también un __init__.pyarchivo en el paquete donde se encuentran todos los demás archivos .ipynb.

Esto es en adición al enlace nbviewer que minrky syiproporcionado 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 funcional :)

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

Jupyter Notebook: importe el archivo .ipynb y acceda a su método en otro archivo .ipynb que da error

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