ipynb importar otro archivo ipynb

90

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 :(

Andrew Harris
fuente
Posible duplicado: stackoverflow.com/questions/19082397/…
Warren Weckesser
2
Puede iniciar el servidor de cuadernos con --scriptpara guardar copias .py de sus cuadernos. En IPython 2.0, podrá utilizar %runun cuaderno. Todavía estamos trabajando en mejores mecanismos para la reutilización del código.
Thomas K
1
Este ejemplo muestra cómo importar cuadernos IPython como módulos sin exportar duplicados como scripts.
minrk

Respuestas:

130

Es realmente simple en el nuevo Jupyter:

%run MyOtherNotebook.ipynb
johndodo
fuente
5
% run MyOtherNotebook.ipynb hizo el trabajo por mí. (no '')
Florian H
6
Tenga cuidado, este método ejecutará completamente el cuaderno secundario. Puede agregar un cheque __name__ == '__main__' and '__file__' not in globals()para verificar si está en el cuaderno secundario. (de blog.sicara.com/… )
Flavian Hautbois
8
% ejecutar 'MyOtherNotebook.ipynb' ERROR: root: Archivo u'MyOtherNotebook.ipynb.py'no encontrado.
user3673
1
@ Kocur4d ¡Gracias por arreglarlo! Curiosamente, funcionó para mí (con comillas) cuando lo probé, pero los ejemplos en la documentación no tienen comillas.
johndodo
3
si alguien se encuentra con eso, también puede usar la ruta completa como% run "/path/to/my/file/notebook.ipynb"
Jeremie
33

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.

axila
fuente
@Crash pip install import-ipynbtambién funciona e instala el mismo paquete, pero dado que Python no le permitirá escribir import import-ipynby considerando que es solo un archivo, me pip install import_ipynbparece más consistente.
axil
3
¿Hay alguna diferencia entre import nbimportery import import_ipynb?
Fractale
1
Esto no funciona en absoluto en mi Jupyter con Python 3
Sebastialonso
@Sebastialonso ¿Qué es exactamente lo que no funciona? Describe lo que haces y qué mensajes de error ves. Lo ideal es abrir un ticket en github.
axila
@axil Tengo el mismo error en el que no me funciona en Py3. Me da el siguiente error: ModuleNotFoundError: ningún módulo llamado 'A' PD: A.ipynb existe en la misma carpeta
Soman Dubey
10

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.

Malgo
fuente
¿Qué pasa si mi nombre de archivo tiene espacios en blanco?
Sameh
Se recomienda no dejar espacios en blanco en el nombre de su archivo
Malgo
2
Tenga en cuenta que en los dos casos descritos, el cuaderno importado se ejecuta en su totalidad. El ipynbpaquete también admite la ejecución parcial de definiciones únicamente. Es un paquete oficial de IPyhton, por lo que creo que esta debería ser la respuesta aceptada.
amka66
¿Puede esto importar cuadernos dentro de una carpeta? por ejemploMyFolder/book.ipynb
bones225
Esto se veía bien, pero se cae cuando encuentra, por ejemplo,% matplotlib en línea ....
jtlz2
7

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
fuera del mundo
fuente
La respuesta más simple pero explicativa. ¡Gracias!
The Poor Jew
3

Puedes usar import nbimporterentoncesimport notebookName

Fractale
fuente
+1, nbimporter funciona de maravilla para mí, también se puede instalar usando conda:conda install -c conda-forge importnb
Zuku
2

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
Yash Bansal
fuente
hmm ... convertí el archivo callee.ipync en callee.py, y luego cargué el archivo callee.py en el cuaderno en la misma carpeta con caller.ipync, y el in caller.ipync que acabo de escribir import callee, simplemente no pude trabajo.
Elsa Lin
ps el IPython es la versión: 5.1.0.
Elsa Lin
1

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
germen13
fuente
1

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.

David Miller
fuente
0

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!

anugrah
fuente