Réutiliser le code de différents notebooks IPython

démarrage de votre serveur de bloc-notes avec:

ipython notebook --script

enregistrer le carnets (.ipynb) en tant que scripts Python (.py) et vous pourrez les importer.

Ou jeter un oeil à: http://nbviewer.ipython.org/5491090/ qui contient 2 pc portable, d'une exécution à l'autre.

dans IPython 2.0 vous pouvez tout simplement %run 'my_shared_code.ipynb' pour partager le code entre les ordinateurs portables. Voir, par exemple,http://nbviewer.ipython.org/gist/edrex/9044756.

Ipythons %run magic vous permet d'exécuter des fichiers python et des scripts ipython dans un notebook. J'utilise parfois l' -i option de façon à ce qu'elle s'exécute dans l'espace de noms des notebooks. Exécutez une cellule avec %run? pour plus d'infos.

Vous pouvez utiliser le ipython --script pour sauvegarder les notebooks aussi comme .py les fichiers sur chaque enregistrer ou décommenter la ligne c.NotebookManager.save_script=True dans votre ipython_notebook_config.py fichier pour le même effet (utilisez ipython profile create pour la mise en place de cette Up-sur Ubuntu les fichiers de configuration vivent dans ~/.config/ipython/).

Edit: La suite est vrai, mais pas nécessaire, vous pouvez %run.ipynb le fichier directement. Merci Eric.

si vous utilisez ipython magics dans le carnet que vous voulez importer, j'ai trouvé que vous pouvez renommer le .py le fichier .ipy (un script ipython), mais j'ai dû supprimer la première ligne (qui contenait la déclaration d'encodage du fichier) pour qu'elle fonctionne. Il y a probablement un meilleur moyen! Cette approche sera probablement confondre la magie des cellules aussi (ils seraient tous appliqués à la fois).

il y a aussi une extension "write and execute", qui vous permettra d'écrire le contenu d'une cellule dans un fichier (et de remplacer l'ancien contenu -> code de mise à jour), qui peut ensuite être importé dans un autre bloc-notes.

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

Dans un bloc-notes (deux cellules)

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

Et puis dans l'autre ordinateur portable:

from functions import do_something
do_something("hello world")

Oui, vous pouvez "exécuter des fonctions à partir d'un bloc-notes à partir d'un autre (sans les couper et les coller entre différents blocs-notes)" -- et, oui, c'est facile à faire!

tl;dr: mettez le code dans les fichiers python (*.py) dans le système de fichiers et laissez plusieurs ordinateurs portables utilisent le même code. (C'est aussi simple que cela.)

(Pourquoi mettre autant de code dans les blocs-notes, alors que nous avons de très bons éditeurs de code et IDEs qui sont tellement mieux pour écrire & lecture de code? Sans parler de la nécessité d'un contrôle de version adéquat! Que cherchons-nous à atteindre, et à quelles dépenses? </rant>)

Détails:

• mettez votre code dans les fichiers python normaux, par exemple my_code/foo.py, ajoutant un (probablement vide)my_code/__init__.py
• profitez d'avoir le code sous le bon contrôle de version ( par exemple git) -- notez à quel point il était difficile de différencier les fichiers ipynb json?
• mettez aussi les cahiers aussi sous version contrôle. Les journaux git bruts seront difficiles à lire, mais les commentaires peuvent être utiles. (GitHub/GitLab affiche ipython cahiers, btw.)
• limitez la source py dans le bloc-notes ipynb à de petites quantités de code" pilote", de sortie et de documentation.
• si vous voulez "inline" les fichiers Python externes, utilisez (par exemple) magic %cat my_code/foo.py ...

...Si vous voulez quelque chose de plus fantaisiste pour afficher cette source en ligne (optionnellement, ajouter ce qui suit à un fichier source externe et réutilisable)...

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)))

Votre favori éditeurs de code et IDEs vous remercier pour votre soutien.

j'appelle les carnets d'autres carnets. Vous pouvez même passer "paramètres" à d'autres ordinateurs portables en utilisant le truc suivant:

params dictionnaire dans la première cellule "report_template.ipynb".

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

et dans un autre bloc-notes (niveau logique supérieur), exécutez-le en utilisant cette fonction:

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')

cette commande exécutera chaque cellule du bloc-notes "report_template" et annulera les clés pertinentes params dictionnaire à partir de la deuxième cellule

j'utilise la fonction suivante dans le bloc-notes à partir de laquelle je veux charger des fonctions ou des actions à partir d'une source portable:

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)

utiliser comme:

execute_notebook(path/to/notebook.ipynb)

donc la bonne idée de @MikeMuller fonctionnera pour un carnet local, mais pas un à distance (d'accord?). Je ne pense pas qu'il y ait un moyen pour vous d'invoquer à distance des blocs de cellules individuels ou des fonctions de code ipynb sur un serveur distant et d'être en mesure d'obtenir des résultats de nouveau dans votre routine d'appel programmatique, à moins que ce code fasse quelque chose d'assez extraordinaire pour communiquer des résultats.

j'étais en train d'écrire quand @ Matt a soumis la même idée

ipython <URI_to_Notebook> --script

*.pynb est un conteneur JSON et non un script python. Vous pouvez obtenir ipython pour exporter un *.py with

Si la cible *.ipynb est sur une machine distante que vous ne contrôlez pas, vous aurez probablement besoin de tirer le fichier pour que vous puissiez écrire la sortie sur un chemin local. (Je n'ai pas vérifié si vous pouvez l'invoquer sur une ressource distante pour créer une sortie locale.) Une fois que ceci est créé, vous devriez être capable d'importer et d'exécuter le *.AP ou particulier fonctions en son sein.

une question pour @Matt sur cet exemple soigné d'exécution d'un autre *.ipynb gros fichier io.open(nbfile) est-ce que nbfile peut être distant? Semble comme un long shot, mais serait génial...

Voici deux conseils supplémentaires:

1. Vous pouvez aussi exécuter %qtconsole magie directement à partir du bloc-notes et il se connectera automatiquement au noyau du bloc-notes.

2. découvrez https://github.com/atiasnir/ipnb

   Vous pouvez l'utiliser pour importer des fichiers notebook comme s'ils étaient des modules python standard (je suis l'auteur :-)). La principale limitation ici est qu'il va jeter les cellules magiques (parce qu'il n'utilise pas IPython du tout) mais sinon, il devrait fonctionner correctement.