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?
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.
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.
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 .
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).
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")
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:
my_code/foo.py
, en ajoutant un (probablement vide) my_code/__init__.py
%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.
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)
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
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 ...
Voici deux astuces supplémentaires:
Vous pouvez également exécuter %qtconsole
magic directement à partir du notebook et celui-ci se connectera automatiquement au noyau du notebook.
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.