notebook - jupyter python 3
Conversión a(no desde) formato de ipython Notebook (7)
Dado el ejemplo de Volodimir Kopey, armé un guión escueto para convertir un .py obtenido exportando de un .ipynb a un V4 .ipynb.
Arreglé este guión cuando edité (en un IDE adecuado) una .py que había exportado de un portátil y quería volver al portátil para ejecutarlo celda por celda.
La secuencia de comandos maneja solo celdas de código. El .py exportado no contiene mucho más, de todos modos.
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)
Sin garantías, pero funcionó para mí
IPython Notebook viene con nbconvert , que puede exportar portátiles a otros formatos. ¿Pero cómo convierto el texto en la dirección opuesta? Pregunto porque ya tengo materiales y un buen flujo de trabajo en un formato diferente, pero me gustaría aprovechar el entorno interactivo de Notebook.
Una solución probable: se puede crear un bloc de notas importando un archivo .py , y la documentación establece que cuando nbconvert exporta un bloc de notas como un script de python, inserta directivas en comentarios que se pueden usar para recrear el notebook. Pero la información viene con un descargo de responsabilidad sobre las limitaciones de este método, y el formato aceptado no está documentado en ningún lugar que pueda encontrar. (Una muestra se muestra, curiosamente, en la sección que describe el formato JSON del portátil). ¿Alguien puede proporcionar más información o una mejor alternativa?
Editar (1 de marzo de 2016): la respuesta aceptada ya no funciona porque, por alguna razón, este formato de entrada no es compatible con la versión 4 de la API de Notebook. He agregado una respuesta automática que muestra cómo importar un bloc de notas con la API actual (v4). (No estoy rechazando la respuesta actual, ya que resolvió mi problema en ese momento y me señaló los recursos que utilicé en mi auto-respuesta).
Dado que el código en la respuesta aceptada ya no funciona, he agregado esta respuesta automática que muestra cómo importar en un portátil con la API actual ( v4 ).
Formato de entrada
Las versiones 2 y 3 de la API de IPython Notebook pueden importar una secuencia de comandos python con comentarios de estructuración especiales y dividirla en celdas como lo desee. Aquí hay un archivo de entrada de muestra (documentación original aquí ). Las dos primeras líneas se ignoran y son opcionales. (De hecho, el lector ignorará coding: líneas de coding: y <nbformat> en cualquier parte del archivo).
# -*- 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
(La API también acepta las directivas obsoletas <htmlcell> y <headingcell level=...> , que se transforman inmediatamente en otros tipos).
Cómo importarlo
Por alguna razón, este formato no es compatible con la versión 4 de la API de Notebook. Sigue siendo un buen formato, por lo que vale la pena soportarlo importándolo a la versión 3 y actualizando. En principio , son solo dos líneas de código, más 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)
¡Pero no tan rápido! De hecho, la API de la notebook tiene un desagradable error: si la última celda de la entrada es una celda de v3.reads_py() , v3.reads_py() perderá. La solución más simple es colocar una celda falsa <markdown> al final: el error lo eliminará, y todos estarán contentos. Haga lo siguiente antes de pasar el text a v3.reads_py() :
text += """
# <markdowncell>
# If you can read this, reads_py() is no longer broken!
"""
Ejemplo de código Python cómo compilar el cuaderno IPython 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()
Escribí una extensión para vscode que podría ayudar. Convierte los archivos de python a portátiles de ipython. Está en las primeras etapas, por lo que si se produce algún error, no dude en enviar un problema.
Lo siguiente funciona para IPython 3, pero no para IPython 4.
La API de IPython tiene funciones para leer y escribir archivos de cuaderno. Deberías usar esta API y no crear JSON directamente. Por ejemplo, el siguiente fragmento de código convierte un script test.py en un cuaderno 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 cuanto al formato del archivo .py entendido por nbf.read, lo mejor es simplemente mirar en la clase de analizador IPython.nbformat.v3.nbpy.PyReader. El código se puede encontrar aquí (no es muy grande):
https://github.com/ipython/ipython/blob/master/jupyter_nbformat/v3/nbpy.py
Editar: Esta respuesta se escribió originalmente para IPyhton 3. No sé cómo hacerlo correctamente con IPython 4. Aquí hay una versión actualizada del enlace anterior, que apunta a la versión de nbpy.py del nbpy.py de IPython 3.2.1 :
https://github.com/ipython/ipython/blob/rel-3.2.1/IPython/nbformat/v3/nbpy.py
Básicamente, utiliza comentarios especiales como # <codecell> o # <markdowncell> para separar las celdas individuales. Mire la línea. line.startswith declaraciones en PyReader.to_notebook para obtener una lista completa.
Puede usar el script py2nb de https://github.com/sklam/py2nb
Deberá usar una cierta sintaxis para su * .py pero es bastante simple de usar (vea el ejemplo en la carpeta ''samples'')
Se tomó la libertad de tomar y modificar el código de P.Toccateli y alexis para que también funcione con pycharm y spyder como marcadores celulares y lo lanzó en github .