Conversion au format ipython Notebook (pas à partir de)
IPython Notebook est livré avec nbconvert , qui peut exporter les blocs-notes vers d'autres formats. Mais comment convertir du texte dans le sens opposé? Je pose la question parce que j'ai déjà du matériel et un bon flux de production dans un format différent, mais j'aimerais profiter de l'environnement interactif de Notebook.
Une solution probable: un cahier peut être créé en important un fichier .py fichier, et la documentation indique que lorsque nbconvert exporte un bloc-notes en tant que script python, il incorpore des directives dans des commentaires qui peuvent être utilisés pour recréer le bloc-notes. vient avec n disclaimer à propos des limitations de cette méthode, et le format accepté n’est documenté nulle part. (Un exemple est montré, assez curieusement, dans la section décrivant le cahier JSON format ) Quelqu'un peut-il fournir plus d'informations ou une meilleure alternative?
Éditer (1er mars 2016): La réponse acceptée ne fonctionne plus car, pour une raison quelconque, ce format de saisie n'est pas pris en charge par la version 4 de l'API Notebook. J'ai ajouté ne réponse automatique montrant comment importer un bloc-notes avec l'API actuelle (v4). (Je ne suis pas en train d'accepter la réponse actuelle, car cela a résolu mon problème à l'époque et m'a indiqué les ressources que j'ai utilisées dans ma réponse personnelle.)
Ce qui suit fonctionne pour IPython 3, mais pas IPython 4.
L'API IPython possède des fonctions pour la lecture et l'écriture de fichiers de bloc-notes. Vous devez utiliser cette API et non pas créer directement JSON. Par exemple, l’extrait de code suivant convertit un script test.py dans un cahier test.ipynb.
import IPython.nbformat.current as nbf
nb = nbf.read(open('test.py', 'r'), 'py')
nbf.write(nb, open('test.ipynb', 'w'), 'ipynb')
En ce qui concerne le format du fichier .py compris par nbf.read, il est préférable de simplement examiner la classe de l'analyseur syntaxique IPython.nbformat.v3.nbpy.PyReader. Le code peut être trouvé ici (il n'est pas très gros):
https://github.com/ipython/ipython/blob/master/jupyter_nbformat/v3/nbpy.py
Edit: Cette réponse a été écrite à l'origine pour IPyhton 3. Je ne sais pas comment procéder correctement avec IPython 4. Voici une version mise à jour de la lien ci-dessus, pointant vers la version de nbpy.py de la version IPython 3.2.1:
https://github.com/ipython/ipython/blob/rel-3.2.1/IPython/nbformat/v3/nbpy.py
Fondamentalement, vous utilisez des commentaires spéciaux tels que # <codecell> ou # <markdowncell> pour séparer les cellules individuelles. Regarde le line.startswith déclarations dans PyReader.to_notebook pour une liste complète.
Comme le code de la réponse acceptée ne fonctionne plus, j'ai ajouté cette réponse automatique qui explique comment importer dans un cahier avec l'API actuelle (v4).
Format d'entrée
Les versions 2 et 3 de l'API IPython Notebook peuvent importer un script python avec des commentaires de structuration spéciaux, et le diviser en cellules à votre guise. Voici un exemple de fichier d'entrée (documentation originale ici ). Les deux premières lignes sont ignorées et facultatives (en fait, le lecteur ignorera les lignes coding: Et <nbformat> N'importe où dans le fichier.)
# -*- coding: utf-8 -*-
# <nbformat>3.0</nbformat>
# <markdowncell>
# The simplest notebook. Markdown cells are embedded in comments,
# so the file is a valid `python` script.
# Be sure to **leave a space** after the comment character!
# <codecell>
print("Hello, IPython")
# <rawcell>
# Raw cell contents are not formatted as markdown
(L'API accepte également les directives obsolètes <htmlcell> Et <headingcell level=...>, Qui sont immédiatement transformées en d'autres types.)
Comment l'importer
Pour une raison quelconque, ce format n'est pas pris en charge par la version 4 de l'API Notebook. C'est toujours un format sympa, donc ça vaut la peine de le supporter en l'important dans la version 3 et en le mettant à jour. En principe , il ne s'agit que de deux lignes de code, plus i/o:
from IPython.nbformat import v3, v4
with open("input-file.py") as fpin:
text = fpin.read()
nbook = v3.reads_py(text)
nbook = v4.upgrade(nbook) # Upgrade v3 to v4
jsonform = v4.writes(nbook) + "\n"
with open("output-file.ipynb", "w") as fpout:
fpout.write(jsonform)
Mais pas si vite! En fait, l'API du bloc-notes a un bogue méchant: si la dernière cellule de l'entrée est une cellule de démarque, v3.reads_py() le perdra. La solution la plus simple consiste à utiliser une cellule fictive <markdown> À la fin: le bogue le supprimera et tout le monde sera heureux. Procédez comme suit avant de passer text à v3.reads_py():
text += """
# <markdowncell>
# If you can read this, reads_py() is no longer broken!
"""
très vieille question, je sais. mais il y a jupytext (également disponible sur pypi ) qui peut convertir de ipynb en plusieurs formats et inversement.
quand jupytext est installé, vous pouvez utiliser
$ jupytext --to notebook test.py
afin de générer test.ipynb.
jupytext a beaucoup plus de fonctionnalités intéressantes qui peuvent être utiles lorsque vous travaillez avec des cahiers.
voici ne question plus récente sur ce sujet.
Exemple de code Python comment construire IPython Notebook V4:
# -*- coding: utf-8 -*-
import os
from base64 import encodestring
from IPython.nbformat.v4.nbbase import (
new_code_cell, new_markdown_cell, new_notebook,
new_output, new_raw_cell
)
# some random base64-encoded *text*
png = encodestring(os.urandom(5)).decode('ascii')
jpeg = encodestring(os.urandom(6)).decode('ascii')
cells = []
cells.append(new_markdown_cell(
source='Some NumPy Examples',
))
cells.append(new_code_cell(
source='import numpy',
execution_count=1,
))
cells.append(new_markdown_cell(
source='A random array',
))
cells.append(new_raw_cell(
source='A random array',
))
cells.append(new_markdown_cell(
source=u'## My Heading',
))
cells.append(new_code_cell(
source='a = numpy.random.Rand(100)',
execution_count=2,
))
cells.append(new_code_cell(
source='a = 10\nb = 5\n',
execution_count=3,
))
cells.append(new_code_cell(
source='a = 10\nb = 5',
execution_count=4,
))
cells.append(new_code_cell(
source=u'print "ünîcødé"',
execution_count=3,
outputs=[new_output(
output_type=u'execute_result',
data={
'text/plain': u'<array a>',
'text/html': u'The HTML rep',
'text/latex': u'$a$',
'image/png': png,
'image/jpeg': jpeg,
'image/svg+xml': u'<svg>',
'application/json': {
'key': 'value'
},
'application/javascript': u'var i=0;'
},
execution_count=3
),new_output(
output_type=u'display_data',
data={
'text/plain': u'<array a>',
'text/html': u'The HTML rep',
'text/latex': u'$a$',
'image/png': png,
'image/jpeg': jpeg,
'image/svg+xml': u'<svg>',
'application/json': {
'key': 'value'
},
'application/javascript': u'var i=0;'
},
),new_output(
output_type=u'error',
ename=u'NameError',
evalue=u'NameError was here',
traceback=[u'frame 0', u'frame 1', u'frame 2']
),new_output(
output_type=u'stream',
text='foo\rbar\r\n'
),new_output(
output_type=u'stream',
name='stderr',
text='\rfoo\rbar\n'
)]
))
nb0 = new_notebook(cells=cells,
metadata={
'language': 'python',
}
)
import IPython.nbformat as nbf
import codecs
f = codecs.open('test.ipynb', encoding='utf-8', mode='w')
nbf.write(nb0, f, 4)
f.close()
À l’aide de l’exemple de Volodimir Kopey, j’ai élaboré un script simple pour convertir un fichier .py obtenu en exportant un fichier .ipynb vers un fichier .ipynb V4.
J'ai piraté ce script ensemble lorsque j'ai édité (dans un IDE approprié) un fichier .py que j'avais exporté depuis un bloc-notes et que je voulais revenir à Bloc-notes pour l'exécuter cellule par cellule.
Le script ne gère que les cellules de code. Le .py exporté ne contient pas grand chose d’autre.
import nbformat
from nbformat.v4 import new_code_cell,new_notebook
import codecs
sourceFile = "changeMe.py" # <<<< change
destFile = "changeMe.ipynb" # <<<< change
def parsePy(fn):
""" Generator that parses a .py file exported from a IPython notebook and
extracts code cells (whatever is between occurrences of "In[*]:").
Returns a string containing one or more lines
"""
with open(fn,"r") as f:
lines = []
for l in f:
l1 = l.strip()
if l1.startswith('# In[') and l1.endswith(']:') and lines:
yield "".join(lines)
lines = []
continue
lines.append(l)
if lines:
yield "".join(lines)
# Create the code cells by parsing the file in input
cells = []
for c in parsePy(sourceFile):
cells.append(new_code_cell(source=c))
# This creates a V4 Notebook with the code cells extracted above
nb0 = new_notebook(cells=cells,
metadata={'language': 'python',})
with codecs.open(destFile, encoding='utf-8', mode='w') as f:
nbformat.write(nb0, f, 4)
Aucune garantie, mais cela a fonctionné pour moi
A pris la liberté de prendre et de modifier le code de P.Toccateli et alexis afin qu'il fonctionne également avec pycharm et spyder comme des marqueurs de cellules et l'a publié sur github .
J'ai écrit une extension pour vscode qui pourrait aider. Il convertit les fichiers python en blocs-notes ipython. Il en est à ses débuts. Par conséquent, en cas d'erreur, n'hésitez pas à envoyer un problème.
J'espère que je ne suis pas trop en retard.
Je viens de publier un Python sur PyPI appelé p2j . Ce paquet crée un carnet Jupyter .ipynb de a Python .py.
pip install p2j
p2j script.py
Exemple de carnet Jupyter généré à partir d'un .py fichier:
Vous pouvez utiliser le script py2nb de https://github.com/sklam/py2nb
Vous devrez utiliser une certaine syntaxe pour votre * .py, mais son utilisation est assez simple (regardez l'exemple dans le dossier 'samples')