webentwicklung-frage-antwort-db.com.de

Konvertieren in das (nicht aus dem) ipython Notebook-Format

IPython Notebook enthält nbconvert , mit demexportnotebooks in andere Formate exportiert werden können. Aber wie konvertiere ich Text in die entgegengesetzte Richtung? Ich frage, weil ich bereits Materialien und einen guten Workflow in einem anderen Format habe, aber ich möchte die interaktive Umgebung von Notebook nutzen.

Eine wahrscheinliche Lösung: Ein Notizbuch kann durch Importieren einer .py - Datei erstellt werden. Wenn nbconvert ein Notizbuch als python Skript exportiert, heißt es in der Dokumentation Bettet Anweisungen in Kommentare ein, die zum erneuten Erstellen des Notizbuchs verwendet werden können. Die Informationen enthalten jedoch einen Haftungsausschluss zu den Einschränkungen dieser Methode, und das akzeptierte Format ist nirgendwo dokumentiert, wo ich könnte find. (Ein Beispiel wird seltsamerweise in dem Abschnitt gezeigt, in dem das JSON-Format des Notizbuchs beschrieben wird.) Kann jemand weitere Informationen oder eine bessere Alternative bereitstellen?

Bearbeiten (1. März 2016): Die akzeptierte Antwort funktioniert nicht mehr, da dieses Eingabeformat aus irgendeinem Grund von Version 4 der Notebook-API nicht unterstützt wird. Ich habe eine Selbstantwort hinzugefügt, die zeigt, wie ein Notizbuch mit der aktuellen (v4) -API importiert wird . (Ich akzeptiere die aktuelle Antwort nicht, da sie mein Problem zu der Zeit löste und mich auf die Ressourcen hinwies, die ich in meiner Selbstantwort verwendet habe.)

51
alexis

Das Folgende funktioniert für IPython 3, aber nicht für IPython 4.

Die IPython-API verfügt über Funktionen zum Lesen und Schreiben von Notebook-Dateien. Sie sollten diese API verwenden und JSON nicht direkt erstellen. Der folgende Codeausschnitt konvertiert beispielsweise ein Skript test.py In ein Notizbuch test.ipynb.

import IPython.nbformat.current as nbf
nb = nbf.read(open('test.py', 'r'), 'py')
nbf.write(nb, open('test.ipynb', 'w'), 'ipynb')

Bezüglich des Formats der .py-Datei, das von nbf.read verstanden wird, ist es am besten, einfach in die Parserklasse IPython.nbformat.v3.nbpy.PyReader zu schauen. Der Code ist hier zu finden (er ist nicht sehr groß):

https://github.com/ipython/ipython/blob/master/jupyter_nbformat/v3/nbpy.py

Edit: Diese Antwort wurde ursprünglich für IPyhton 3 geschrieben. Ich weiß nicht, wie ich das mit IPython 4 richtig machen soll. Hier ist eine aktualisierte Version von Link oben, der auf die Version von nbpy.py aus der IPython 3.2.1-Version verweist:

https://github.com/ipython/ipython/blob/rel-3.2.1/IPython/nbformat/v3/nbpy.py

Grundsätzlich verwenden Sie spezielle Kommentare wie # <codecell> Oder # <markdowncell>, Um die einzelnen Zellen zu trennen. Eine vollständige Liste finden Sie in den Anweisungen line.startswith In PyReader.to_notebook.

34
CliffordVienna

Da der Code in der akzeptierten Antwort nicht mehr funktioniert, habe ich diese Selbstantwort hinzugefügt, die zeigt, wie mit der aktuellen API (v4) In ein Notizbuch importiert wird.

Eingabeformat

Die Versionen 2 und 3 der IPython Notebook-API können ein python= Skript mit speziellen Strukturierungskommentaren importieren und wie gewünscht in Zellen aufteilen. Hier ist eine Beispieleingabedatei (Originaldokumentation hier ). Die ersten beiden Zeilen werden ignoriert und sind optional. (Tatsächlich ignoriert der Reader die Zeilen coding: Und <nbformat> An einer beliebigen Stelle in der Datei.)

# -*- 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

(Die API akzeptiert auch die veralteten Direktiven <htmlcell> Und <headingcell level=...>, Die sofort in andere Typen umgewandelt werden.)

So importieren Sie es

Aus irgendeinem Grund wird dieses Format von Version 4 der Notebook-API nicht unterstützt. Es ist immer noch ein nettes Format, es lohnt sich also, es zu unterstützen, indem Sie es in Version 3 importieren und aktualisieren. Im Prinzip sind es nur zwei Codezeilen 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)

Aber nicht so schnell! Tatsächlich hat die Notebook-API einen üblen Fehler: Wenn die letzte Zelle in der Eingabe eine Abschriftenzelle ist, verliert sie v3.reads_py(). Die einfachste Lösung besteht darin, am Ende eine falsche <markdown> - Zelle anzuheften: Der Fehler löscht sie und alle sind glücklich. Führen Sie daher die folgenden Schritte aus, bevor Sie text an v3.reads_py() übergeben:

text += """
# <markdowncell>

# If you can read this, reads_py() is no longer broken! 
"""
31
alexis

sehr alte Frage, ich weiß. aber es gibt jupytext (auch verfügbar auf pypi ), das von ipynb in verschiedene Formate und zurück konvertieren kann.

wenn jupytext installiert ist, können Sie verwenden

$ jupytext --to notebook test.py

um test.ipynb zu generieren.

jupytext verfügt über viel interessantere Funktionen, die sich bei der Arbeit mit Notebooks als nützlich erweisen können.


hier ist eine neuere Frage zu diesem Thema.

12

Python-Codebeispiel zum Erstellen von 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()
9
Volodimir Kopey

Anhand des Beispiels von Volodimir Kopey habe ich ein Bare-Bones-Skript zusammengestellt, um eine .py-Datei, die durch den Export von einer .ipynb-Datei zurück in eine .ipynb-Datei der Version 4 erhalten wurde, zu konvertieren.

Ich habe dieses Skript zusammen gehackt, als ich (in einer geeigneten IDE) eine .py-Datei bearbeitet habe, die ich aus einem Notebook exportiert hatte, und ich wollte zu Notebook zurückkehren, um sie Zelle für Zelle auszuführen.

Das Skript verarbeitet nur Codezellen. Die exportierte .py enthält sowieso nicht viel anderes.

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)

Keine Garantie, aber es hat bei mir geklappt

7
P.Toccaceli

Ich habe mir erlaubt, den Code von P.Toccateli und alexis so zu ändern, dass er auch mit pycharm- und spyderartigen Zellmarkern funktioniert, und habe ihn auf github veröffentlicht.

4
John Smith

Ich habe eine Erweiterung für vscode geschrieben, die helfen könnte. Es konvertiert die python Dateien in ipython-Notizbücher. Es befindet sich in einem frühen Stadium. Wenn also ein Fehler auftritt, können Sie ein Problem melden.

Jupyter Notebook Converter

4
YigitOzgumus

Hoffe ich bin nicht zu spät.

Ich habe gerade ein Python -Paket mit dem Namen p2j auf PyPI veröffentlicht. Dieses Paket erstellt ein Jupyter-Notizbuch .ipynb aus einem Python Quellcode .py.

pip install p2j
p2j script.py

Beispiel eines Jupyter-Notizbuchs, das aus einer .py - Datei generiert wurde:

Example of .ipynb generated from a .py file

PyPI: https://pypi.org/project/p2j/

GitHub: https://github.com/raibosome/python2jupyter

2
Raimi bin Karim

Sie können das Skript py2nb unter https://github.com/sklam/py2nb verwenden

Sie müssen für Ihre * .py-Datei eine bestimmte Syntax verwenden, diese ist jedoch recht einfach zu verwenden (siehe Beispiel im Ordner "samples").

0
valbarriere