python - notebook - jupyter server

Reutilizando código de diferentes notebooks de IPython

Question

Estoy usando IPython y quiero ejecutar funciones desde una notebook desde otra (sin cortarlas y pegarlas entre diferentes notebooks). ¿Es esto posible y razonablemente fácil de hacer?

Answer 1

Aquí hay dos consejos adicionales:

1. También puede ejecutar %qtconsole magic directamente desde el cuaderno y se conectará automáticamente al núcleo del cuaderno.

2. Echa un vistazo a https://github.com/atiasnir/ipnb

   Puede usarlo para importar archivos de notebook como si fueran módulos estándar de Python (soy el autor :-)). La principal limitación aquí es que descartará las células mágicas (porque no usa IPython en absoluto), pero de lo contrario debería funcionar bien.

Answer 2

En IPython 2.0, simplemente puede %run ''my_shared_code.ipynb'' para compartir código entre cuadernos. Ver, por ejemplo, http://nbviewer.ipython.org/gist/edrex/9044756 .

Answer 3

Entonces, la buena idea de @MikeMuller funcionará para un portátil local, pero no remoto (¿no?). No creo que haya una manera de invocar de forma remota bloques de células individuales o funciones de código ipynb en un servidor remoto y poder obtener resultados en su rutina de llamadas programáticamente, a menos que ese código haga algo extraordinario para comunicar los resultados.

Estaba en el proceso de escribir cuando @Matt presentó la misma idea sobre

ipython <URI_to_Notebook> --script

El * .pynb es un contenedor JSON y no un script de python real. Puede obtener ipython para exportar un * .py con

Si el destino * .ipynb está en una máquina remota que no controla, probablemente necesitará extraer el archivo para poder escribir la salida en una ruta local. (No se ha investigado si puede invocar esto en un recurso remoto para crear una salida local). Una vez que se haya creado, debería poder importar y ejecutar las funciones * .py o individuales dentro de él.

Una pregunta para @Matt en ese ejemplo claro de ejecutar otro archivo * .ipynb al por mayor con io.open(nbfile) es si el nbfile puede ser remoto. Parece un tiro largo, pero sería genial ...

Answer 4

Iniciando su servidor portátil con:

ipython notebook --script

guardará los cuadernos ( .ipynb ) como scripts de Python ( .py ) también, y podrá importarlos.

O eche un vistazo a: http://nbviewer.ipython.org/5491090/ que contiene 2 cuadernos, uno ejecutando el otro.

Answer 5

Ipythons %run magic te permite ejecutar archivos python y scripts ipython en un cuaderno. A veces uso la opción -i para que se ejecute en el espacio de nombres de los cuadernos. Ejecutar una celda con %run? en él para más información.

Puede usar el ipython --script para guardar cuadernos también como archivos .py en cada guardado o descomentar la línea c.NotebookManager.save_script=True en su ipython_notebook_config.py para el mismo efecto (use el ipython profile create para ipython profile create en Ubuntu los archivos de configuración viven en ~/.config/ipython/ ).

Edición: Lo siguiente es cierto, pero innecesario: %run puede %run un archivo .ipynb directamente. Gracias

Si utilizas ipython magics en el cuaderno que quieres importar, encontré que puedes cambiar el nombre del archivo .py a .ipy (un script de ipython), pero tuve que eliminar la primera línea (que contenía la declaración de codificación del archivo). trabajar. Probablemente hay una mejor manera! Es probable que este enfoque también confunda la magia celular (todos se aplicarían a la vez).

Answer 6

Llamo cuadernos de otros cuadernos. Incluso puede pasar "parámetros" a otros portátiles utilizando el siguiente truco:

Coloque el diccionario de parámetros en la primera celda de "report_template.ipynb".

params = dict(platform=''iOS'', 
              start_date=''2016-05-01'', 
              retention=7)
df = get_data(params ..)
do_analysis(params ..)

Y en otro cuaderno (nivel lógico superior), ejecútelo usando esta función:

def run_notebook(nbfile, **kwargs):
    """
    example:
    run_notebook(''report.ipynb'', platform=''google_play'', start_date=''2016-06-10'')
    """

    def read_notebook(nbfile):
        if not nbfile.endswith(''.ipynb''):
            nbfile += ''.ipynb''

        with io.open(nbfile) as f:
            nb = nbformat.read(f, as_version=4)
        return nb

    ip = get_ipython()
    gl = ip.ns_table[''user_global'']
    gl[''params''] = None
    arguments_in_original_state = True

    for cell in read_notebook(nbfile).cells:
        if cell.cell_type != ''code'':
            continue
        ip.run_cell(cell.source)

        if arguments_in_original_state and type(gl[''params'']) == dict:
            gl[''params''].update(kwargs)
            arguments_in_original_state = False

run_notebook("report_template.ipynb", start_date=''2016-09-01'')

Este comando ejecutará cada celda del cuaderno "report_template" y anulará las claves relevantes del diccionario de parámetros a partir de la segunda celda

Answer 7

Puedes conectarte con un qtconsole al mismo kernel. Simplemente suministre esto al inicio:

ipython qtconsole --existing kernel-0300435c-3d07-4bb6-abda-8952e663ddb7.json

Mira la salida después de iniciar el cuaderno para la cadena larga.

Answer 8

Sí, puede "ejecutar funciones desde una notebook desde otra (sin cortarlas y pegarlas entre diferentes notebooks)" y, sí, ¡es fácil de hacer!

tl; dr: coloque el código en los archivos de Python ( *.py ) en el sistema de archivos y deje que múltiples cuadernos usen el mismo código. (Es así de simple.)

(¿Por qué poner tanto código en las computadoras portátiles, cuando tenemos editores de código e IDE perfectamente buenos que son mucho mejores para escribir y leer código? ¡Por no mencionar la necesidad de un control de versión adecuado! ¿Qué estamos tratando de lograr y a qué costo? ? </rant> )

Detalles:

• Coloque su código en archivos normales de Python, por ejemplo, my_code/foo.py , agregando un (probablemente vacío) my_code/__init__.py
• Aproveche la ventaja de tener el código bajo el control de versión adecuado (p. Ej., Git). ¿Se da cuenta de lo difícil que fue diferenciar archivos ipynb json?
• También poner los cuadernos también bajo control de versiones. Los registros de git sin procesar serán difíciles de leer, pero los comentarios pueden ser útiles. (GitHub / GitLab muestra notebooks ipython, por cierto).
• Limite la fuente de py en el cuaderno ipynb a pequeñas cantidades de código, controlador y salida de "controlador".
• Si desea "en línea" los archivos de Python externos, simplemente use (por ejemplo) magic %cat my_code/foo.py ...

... Si desea que algo más elegante muestre esa fuente en línea (opcionalmente, agregando lo siguiente a un archivo fuente externo y reutilizable) ...

import IPython
from pygments import highlight
from pygments.formatters import HtmlFormatter
from pygments.lexers import get_lexer_for_filename

filename=''my_code/foo.py''
with open(filename) as f: code = f.read()
formatter = HtmlFormatter(linenos=''inline'')
IPython.display.HTML(''<style type="text/css">{}</style>{}''.format(
                formatter.get_style_defs(''.highlight''),
                highlight(code, get_lexer_for_filename(filename), formatter)))

Sus editores de código y IDE favoritos le agradecen por su apoyo.

Answer 9

También hay una extensión de "escribir y ejecutar", que le permitirá escribir el contenido de una celda en un archivo (y reemplazar el contenido antiguo -> código de actualización), que luego se puede importar en otro cuaderno.

https://github.com/minrk/ipython_extensions#write-and-execute

En un cuaderno (dos celdas)

%reload_ext writeandexecute
--
%%writeandexecute -i some_unique_string functions.py
def do_something(txt):
    print(txt)

Y luego en la otra libreta:

from functions import do_something
do_something("hello world")

Answer 10

Utilizo la siguiente función en el cuaderno desde el que quiero cargar funciones o acciones desde un cuaderno de origen:

import io
import nbformat

def execute_notebook(nbfile):
    with io.open(nbfile, encoding="utf8") as f:
        nb = nbformat.read(f, as_version=4)

    ip = get_ipython()

    for cell in nb.cells:
        if cell.cell_type != ''code'':
            continue
        ip.run_cell(cell.source)

Utilizar como

execute_notebook(path/to/notebook.ipynb)