web-dev-qa-db-fra.com

Réutilisation du code de différents cahiers IPython

J'utilise IPython et je souhaite exécuter des fonctions d'un ordinateur portable à un autre (sans les couper et les coller entre différents ordinateurs portables). Est-ce possible et assez facile à faire?

pythonipythonipython-notebook
42
user7289

Vous pouvez vous connecter avec une qtconsole au même noyau. Fournissez simplement ceci au démarrage:

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

Regardez la sortie après le démarrage du cahier pour la longue chaîne.

4
Mike Müller

Démarrer votre serveur de cahiers avec:

ipython notebook --script

les cahiers (.ipynb) seront également sauvegardés sous forme de scripts Python (.py) et vous pourrez les importer.

Ou jetez un oeil à: http://nbviewer.ipython.org/5491090/ qui contient 2 cahiers, l'un exécutant l'autre.

34
Matt

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

19
Eric Drechsel

Ipythons %run magic vous permet d’exécuter des fichiers python et des scripts ipython dans un cahier. J'utilise parfois l'option -i pour qu'elle s'exécute dans l'espace de noms des blocs-notes. Exécutez une cellule contenant %run? pour plus d’informations.

Vous pouvez également utiliser le ipython --script pour enregistrer les notebooks aussi en tant que fichiers .py à chaque enregistrement ou décommenter la ligne c.NotebookManager.save_script=True dans votre fichier ipython_notebook_config.py pour le même effet (utilisez ipython profile create pour le configurer, les fichiers de configuration résidant dans ~/.config/ipython/).

Edit: Ce qui suit est vrai, mais inutile - vous pouvez %run un fichier .ipynb directement. Merci Eric .

Si vous utilisez ipython magics dans le bloc-notes que vous souhaitez importer, j'ai découvert que vous pouvez renommer le fichier .py en .ipy (un script ipython), mais je devais supprimer la première ligne (qui contenait la déclaration d'encodage du fichier) pour que cela fonctionne. . Il y a probablement un meilleur moyen! Cette approche va probablement confondre les magies cellulaires aussi (elles seraient toutes appliquées en même temps).

13
drevicko

Il existe également 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 pourra ensuite être importé dans un autre bloc-notes.

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

Dans un cahier (deux cellules)

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

Et puis dans l'autre cahier:

from functions import do_something
do_something("hello world")
4
Jan Katins

Oui, vous pouvez "exécuter les fonctions d’un cahier à un autre (sans les couper et les coller entre différents cahiers)" - et, oui, c’est facile à faire! 

tl; dr: place le code dans des fichiers python (*.py) dans le système de fichiers et permet à plusieurs ordinateurs portables d'utiliser le même code. (C'est si simple.)

(Pourquoi mettre autant de code dans les cahiers, alors que nous avons d'excellents éditeurs de code et des IDE qui sont tellement meilleurs pour l'écriture et la lecture de code? Sans parler de la nécessité d'un contrôle de version correct! quelle dépense? </rant>)

Détails:

  • Mettez votre code dans des fichiers Python normaux, par exemple my_code/foo.py, en ajoutant un (probablement vide) my_code/__init__.py
  • Profitez du code sous le contrôle de version approprié (par exemple, git) - remarquez à quel point il était difficile de comparer les fichiers ipynb json?
  • Mettez également les cahiers également sous contrôle de version. Les journaux bruts de git seront difficiles à lire, mais les commentaires peuvent être utiles. (GitHub/GitLab affiche les cahiers ipython, au fait.)
  • Limitez la source py du cahier ipynb à de petites quantités de code "pilote", de sortie et de documentation.
  • Si vous voulez "incorporer" les fichiers Python externes, utilisez simplement (par exemple) magic %cat my_code/foo.py ...

... Si vous voulez que quelque chose de plus sophistiqué affiche cette source en ligne (éventuellement, ajoutez ce qui suit à un fichier source externe 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)))

Vos rédacteurs de code et IDE préférés vous remercient de votre soutien.

2
michael

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

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)

Utilisez comme:

execute_notebook(path/to/notebook.ipynb)
1
Mattijn

J'appelle des cahiers d'autres cahiers. Vous pouvez même passer des "paramètres" à d'autres ordinateurs portables en utilisant l'astuce suivante:

Placezparamsdictionary dans la première cellule de "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 à l'aide de 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écute chaque cellule du bloc-notes "report_template" et remplace les clés pertinentes deparamsdictionary à partir de la deuxième cellule

1
volodymyr

La bonne idée de @ MikeMuller fonctionnera donc pour un ordinateur portable local, mais pas pour un ordinateur distant (non?). Je ne pense pas qu'il soit possible d'invoquer à distance des blocs de cellules ou des fonctions de code ipynb sur un serveur distant et de pouvoir obtenir des résultats dans votre routine d'appel par programme, à moins que ce code ne produise quelque chose d'assez extraordinaire pour communiquer les résultats. 

J'étais en train d'écrire lorsque @Matt a soumis la même idée à propos de 

ipython <URI_to_Notebook> --script

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

Si la cible * .ipynb se trouve sur un ordinateur distant que vous ne contrôlez pas, vous devrez probablement extraire le fichier afin de pouvoir écrire la sortie sur un chemin local. (N'a pas cherché à savoir si vous pouvez appeler ceci sur une ressource distante pour créer une sortie locale.) Une fois que cela est créé, vous devriez pouvoir importer et exécuter le * .py ou des fonctions individuelles qu'il contient.

Une question pour @Matt sur ce bel exemple d’exécution d’un autre fichier * .ipynb en gros avec io.open(nbfile) est de savoir si le fichier nb peut être distant? Cela semble être un long plan, mais ce serait génial ...

0
Roland

Voici deux astuces supplémentaires:

  1. Vous pouvez également exécuter %qtconsole magic directement à partir du notebook et celui-ci se connectera automatiquement au noyau du notebook.

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

    Vous pouvez l'utiliser pour importer des fichiers de cahier comme s'il s'agissait de modules Python standard (j'en suis l'auteur :-)). La principale limitation ici est qu’elle rejettera les cellules magiques (car elle n’utilise pas du tout IPython), mais sinon cela devrait fonctionner correctement.

0
atiasnir