Vielen Dank an Brian Granger, Fernando Pérez und Robert Kern für ihren Input zu diesem Artikel!
Für Lernende wie auch fortgeschrittene Data Scientists gehört das Jupyter Notebook zu den beliebtesten Tools: Die interaktive Umgebung ist nicht nur ideal zum Lehren, Lernen und Teilen der eigenen Arbeit mit anderen, sondern sorgt auch für reproduzierbare Forschung. Während du dich mit dem Notebook vertraut machst, begegnest du jedoch immer wieder IPython.
Beides wirkt in manchen Fällen wie Synonyme, und du wirst mir zustimmen: Sobald man tiefer einsteigt, wird es schnell verwirrend. Gehören Magics zu Jupyter oder zu IPython? Ist das Speichern und Laden von Notebooks eine Funktion von IPython oder von Jupyter?
Diese Fragen ließen sich beliebig fortsetzen.
Dieser Blogpost will einige der zentralen Unterschiede klarer herausarbeiten: Er beginnt bei den Ursprüngen beider Projekte, erklärt ihr Verhältnis zueinander und beleuchtet anschließend konkrete Funktionen, die jeweils nur zum einen oder anderen gehören. So fällt dir die Unterscheidung künftig leichter.
Lies ergänzend auch DataCamps Definitive Guide to Jupyter Notebook mit Tipps, Best Practices, Beispielen und mehr.
Die Ursprünge von IPython / Jupyter
Um wirklich zu verstehen, was das Jupyter Notebook ist und wie es sich von IPython unterscheidet, lohnt ein Blick darauf, wie beide in die Geschichte und Zukunft der Computational Notebooks einzuordnen sind.
Der Anfang der Computational Notebooks: MATLAB, Mathematica & Maple
Mitte der 1980er brachte The MathWorks, gegründet von Jack Little, Steve Bangert und Cleve Moler, MATLAB heraus.
Springen wir ins Jahr 1987: Theodore Gray begann an der Notebook-Oberfläche von Mathematica zu arbeiten, die ein Jahr später erschien. Die GUI erlaubte die interaktive Erstellung und Bearbeitung von Notebook-Dokumenten mit schön gesetztem Code, formatiertem Text und zahlreichen Features wie formelgesetzter Mathematik, Grafiken, GUI-Komponenten, Tabellen und Sounds. Standardfunktionen der Textverarbeitung waren ebenso vorhanden, etwa eine mehrsprachige Echtzeit-Rechtschreibprüfung. Dokumente ließen sich im Präsentationsmodus als Slideshow ausgeben.
Wer sich die Struktur dieser Notebooks ansah, bemerkte sofort ihre Zellenhierarchie zur Gliederung von Dokumenten – etwas, das du heute auch in Jupyter Notebooks findest.
Ebenfalls Ende der 1980er, 1989, stellte Maple seine erste Notebook-ähnliche GUI vor, enthalten in Version 4.3 für den Macintosh. Varianten für X11 und Windows folgten 1990. Diese frühen Notebooks inspirierten und legten die Basis für das, was später als „Data-Science-Notebooks“ bekannt wurde.
Der Aufstieg der Data-Science-Notebooks
Nach Maple und Mathematica entstanden viele weitere Computational Notebooks. Hier fokussieren wir auf jene, die maßgeblich zum Siegeszug der Data-Science-Notebooks beigetragen haben. Einige davon sind unter angehenden wie erfahrenen Data Scientists bis heute beliebt.
Sage Notebook
Das browserbasierte Sage Notebook erschien erstmals Mitte der 2000er. 2007 folgte eine leistungsfähigere Version mit Benutzerkonten, die das öffentliche Teilen von Dokumenten erlaubte. Optisch erinnerte es an Google Docs, da sich das Layout am Aufbau der Google Notebooks orientierte.
Die Macher der Sage Notebooks waren bekennende Nutzer der Mathematica Notebooks und Maple Worksheets. Wichtige Treiber bei der Entwicklung waren außerdem: Erstens der enge Kontakt zum IPython-Team, nicht zuletzt weil die terminalbasierte Sage-Version IPython nutzte. Zweitens „ein gescheiterter Versuch“ zweier Studierender, eine GUI für IPython zu bauen. Drittens der Aufstieg von „AJAX“ („Asynchronous JavaScript And XML“), also Webanwendungen, bei denen nicht bei jeder Aktion die ganze Seite neu geladen werden muss.
Das kennst du zum Beispiel von Webformularen: Ohne AJAX wirst du nach dem Absenden auf eine neue Seite mit Serverantwort weitergeleitet. Mit AJAX stellt JavaScript die Anfrage, holt die Antwort und aktualisiert die Seite – ohne Reload und ohne Redirect.
Weitere bekannte AJAX-Anwendungen sind etwa Gmail, Google Maps, Facebook, Twitter, … Kurz: Fast alles ist AJAX.
IPython und Jupyter Notebook
Ende 2001, rund zwanzig Jahre nachdem Guido van Rossum am National Research Institute for Mathematics and Computer Science in den Niederlanden mit Python begonnen hatte, startete Fernando Pérez die Entwicklung von IPython. Wie das Sage Notebook und viele nachfolgende Projekte war es stark von den Mathematica Notebooks und Maple Worksheets beeinflusst.
2005 gab es einen ersten Versuch, mit Wx – einem Toolkit für plattformübergreifende GUIs – ein Notebook-System zu bauen. Zwei Google-Summer-of-Code-Studierende arbeiteten unter Anleitung von Robert Kern und Fernando Pérez an einem Prototyp. Danach steckte Robert weitere Arbeit hinein. Es war weniger ein Notebook-Prototyp als vielmehr eine Bereinigung des IPython-Kerns, um die Entwicklung eines wxPython-GUI-Frontends für die IPython-Shell zu erleichtern. Diese Bereinigungen ebneten den Weg für ein sauberes Notebook-System; Teile davon wurden nach und nach in IPython integriert, als der letztlich erfolgreiche Notebook-Ansatz Fahrt aufnahm.
Der zweite IPython-Prototyp entstand im Sommer 2006 durch Min Ragan-Kelley, beraten von Brian Granger. Er war webbasiert und nutzte eine SQL-Datenbank als Backend, wurde aber aufgegeben, weil die Implementierung mit den damaligen Webtechnologien zu komplex wurde.
Der dritte Prototyp des IPython Notebooks entstand im Oktober 2010 als kurzer Hack eines Drittentwicklers. Schließlich arbeitete Brian Granger im Frühjahr/Sommer 2011 in Vollzeit am Prototyp des Web-Notebooks, basierend auf Arbeiten aus 2010, in deren Rahmen er zusammen mit Fernando Pérez die IPython-Kernel-Architektur und -Nachrichtenspezifikation entwickelte und mit Min Ragan Kelley PyZMQ.
PyZMQ ist eine Bibliothek, die Python-Bindings für ZeroMQ bereitstellt. Diese wurde für IPythons Funktionen zu Parallel Computing, die Qt-Konsole und das Notebook benötigt.
PyZMQ und WebSockets waren die Schlüsseltechnologien, die das Notebook möglich machten. Im Herbst desselben Jahres beteiligten sich weitere Contributor (u. a. Matthias Bussonnier, Min und Fernando). Am 21. Dezember 2011 erschien die erste Version des IPython Notebooks (0.12).
In den Folgejahren erhielt das Team Auszeichnungen wie den Advancement of Free Software (für Fernando Pérez am 23. März 2013) und den Jolt Productivity Award sowie Förderungen u. a. von der Alfred P. Sloan Foundation.
2014 startete schließlich Project Jupyter als Ausgründung aus IPython.
Die letzte IPython-Version vor der Trennung enthielt interaktive Shell, Notebook-Server, Qt-Konsole etc. in einem einzigen Repository. Das Projekt war groß geworden, mit Komponenten, die zunehmend eigenständige Projekte waren – die jedoch zufällig unter demselben Dach lagen.
Die Größe war aber nicht der einzige Grund für Jupyter: Zwischen 2011 und 2014 lief das IPython Notebook zunehmend auch mit anderen Programmiersprachen. Zuerst mit Julia, später mit R. Dass das „IPython Notebook“ – dem Namen nach rein Python – plötzlich auch mit Julia- und R-Kernels arbeitete, sorgte für Verwirrung.
Warum also „IPython“, wenn mehrere Sprachen im Spiel sind?
Der Name „Jupyter“ ist eine Anspielung auf führende offene Sprachen in den Wissenschaften (Julia, Python, R). Auch wenn er wie ein Akronym wirkt, schloss er nie andere Sprachen aus. Vor allem repräsentierte er das Projekt besser und verneigte sich vor den wissenschaftlichen Wurzeln.
Nach dem Start wurden die sprachenagnostischen Teile von IPython – etwa Notebook-Format, Nachrichtenprotokoll, Qt-Konsole, Webanwendung des Notebooks usw. – ins Jupyter-Projekt ausgegliedert. Die zentrale Jupyter-Organisation auf GitHub findest du hier.
In den Jupyter- und IPython-Communities nennt man das „The Big Split“.
IPython hat seither zwei Aufgaben: Es ist erstens der Python-Backend-Kernel für das Jupyter Notebook und zweitens eine interaktive Python-Shell. Darüber hinaus findest du im IPython-Ökosystem auch ein Framework für Parallel Computing. Mehr dazu weiter unten!
Und wie IPython steht auch Project Jupyter für einen Verbund mehrerer Projekte: Die drei Anwendungen sind das Notebook selbst, eine Konsole und eine Qt-Konsole. Daneben gibt es Subprojekte wie JupyterHub zur Bereitstellung von Notebooks, nbgrader für Bildungsszenarien usw. Einen Überblick über die Jupyter-Architektur findest du hier.
Genau diese Entwicklung erklärt die Verwirrung vieler Pythonistas in Bezug auf IPython und Jupyter: Da das eine aus dem anderen hervorgegangen ist (und das relativ kürzlich), tun sich manche schwer, die richtigen Begriffe zu verwenden. Erschwerend kommt hinzu: Weil das eine aus dem anderen entstand, gibt es einen beträchtlichen Funktionsüberlapp zwischen IPython und dem Jupyter Notebook, der nicht immer leicht zu trennen ist. Wie du beide sauber unterscheidest, zeigen die nächsten Abschnitte. Wer tiefer in die Entstehungsgeschichte einsteigen will, liest die Berichte von Fernando Pérez und William Stein.
R Notebooks
R Markdown und das Jupyter Notebook teilen das Ziel einer reproduzierbaren Arbeitsweise: Code, Ausgabe und Text werden in einem Dokument verflochten, interaktive Widgets werden unterstützt und der Export in verschiedene Formate ist möglich.
Es gibt aber Unterschiede: R Markdown betont reproduzierbare Batch-Ausführung, reine Textrepräsentation, Versionskontrolle, Produktionsausgaben und bietet denselben Editor und dieselben Tools wie für R-Skripte. Jupyter setzt auf Inline-Ausgaben direkt beim Code, Caching von Ergebnissen über Sessions hinweg, das Teilen von Code und Ausgaben in einer einzigen Datei und ein interaktives Ausführungsmodell. Notebooks nutzen keine reine Textrepräsentation, sondern strukturierte Datenformate wie JSON.
Genau hier setzt RStudios Notebook-Anwendung an: Sie kombiniert die Vorteile von R Markdown mit den Stärken von Computational Notebooks.
Wie du mit R Notebooks arbeitest und worin sich Jupyter- und R-Markdown-Notebooks im Hinblick auf Teilen, Projektmanagement, Versionskontrolle u. a. unterscheiden, erfährst du in DataCamps Beitrag Jupyter and R: Notebooks with R.
Weitere Data-Science-Notebooks
Natürlich gibt es noch mehr Notebooks, die du für Data Science in Betracht ziehen kannst. In den letzten Jahren sind viele Alternativen hinzugekommen: etwa Beaker Notebook, Apache Zeppelin, Spark Notebook, DataBricks Cloud usw., aber auch Tools wie die Rodeo IDE oder nteract, die Analysen ebenfalls interaktiv und reproduzierbar machen. Wichtig: nteract unterscheidet sich von den anderen genannten Tools, weil es auf die Jupyter-Architektur (Protokolle und Formate) setzt.
Die Zukunft der Notebooks
Notebooks sind gekommen, um zu bleiben. Kürzlich wurde die nächste Generation des Jupyter Notebooks vorgestellt: JupyterLab. Die Notebook-Anwendung bietet nicht nur Notebooks, sondern auch Dateimanager, Texteditor, Terminalemulator, Monitor für laufende Jupyter-Prozesse, IPython-Cluster-Manager und einen Pager für Hilfetexte.
Du denkst jetzt vielleicht: Nichts Neues – all das gibt es doch schon im Jupyter Notebook. JupyterLab ermöglicht jedoch, all diese Bausteine des interaktiven Rechnens auf neue Weise zu kombinieren.
Mehr dazu hier.
Das umfangreiche Toolset des Jupyter Notebooks ist organisch gewachsen und wurde von den Bedürfnissen der Nutzerinnen, Nutzer und Entwicklerinnen, Entwickler getrieben. JupyterLab liefert eine Next-Gen-Architektur für all diese Tools – mit einer flexiblen, responsiven UI und frei gestaltbarem Layout, das die Tools zusammenführt.
IPython oder Jupyter?
Die Entwicklung und der „Big Split“ sind die Basis, um die Unterschiede zu verstehen. Weil beide jedoch eng verbunden sind, zweifelst du in der Praxis oft, was wohin gehört.
Im Folgenden gehen wir Funktionen durch, die entweder Teil des IPython-Ökosystems oder des Jupyter-Projekts sind.
Deine Aufgabe: die richtige Zuordnung treffen und mehr über jede Funktion erfahren!
Kernels?
Auch wenn Kernels heute prominent in der Jupyter-Notebook-Anwendung erscheinen, war das erste Tool mit vollständigem Kernel und Protokoll die Qt-Konsole – sie entstand vor dem Notebook. Historisch wie architektonisch werden die Kernels heute flexibel vom Notebook genutzt, sie sind jedoch eine Jupyter-Funktion und nicht „Eigentum“ des Notebooks. Das heißt: Kernels sind mehr als nur ein Feature – sie sind eine Kernabstraktion der Jupyter-Architektur und werden auch von Nicht-Notebook-Tools genutzt, z. B. Textkonsole, Qt-Konsole, O’Reillys Thebe, Kernel Gateway, nteracts Hydrogen-Editor. In JupyterLab können Kernels außerdem mit allem verbunden werden – vom Notebook über eine Webkonsole bis hin zur Textdatei.
Ein Kernel ist ein Programm, das den vom Nutzer ausgeführten Code verarbeitet und inspiziert: Es stellt Rechenleistung und die Kommunikation mit Frontends wie Notebooks bereit. Die Jupyter-Notebook-Anwendung bringt drei Haupt-Kernels mit: IPython, IRkernel und IJulia.
Das passt zum Namen „Jupyter“, der auf Julia, Python und R verweist. Der IPython-Kernel wird vom Jupyter-Team gepflegt – eine Folge der Projektentwicklung.
Du kannst in der Jupyter-Notebook-Anwendung aber auch viele andere Sprachen ausführen, etwa Scala, JavaScript, Haskell, Ruby und mehr. Das sind Community-verwaltete Kernels.
Notebook-Bereitstellung?
Deployments von Notebooks begegnen dir typischerweise im Jupyter-Kontext. Es gibt eine ganze Reihe von Paketen zur Bereitstellung, die zum Jupyter-Ökosystem gehören.
Einige davon:
docker-stacksliefert Stacks aus Jupyter-Anwendungen und -Kernels als Docker-Container.ipywidgetsstellt interaktive HTML- & JavaScript-Widgets (Slider, Checkboxen, Textfelder, Charts usw.) für die Jupyter-Architektur bereit und koppelt Frontend-Controls an einen Jupyter-Kernel.jupyter-driveermöglicht IPython die Dateiverwaltung über Google Drive.jupyter-sphinx-themeergänzt dein Notebook um ein Jupyter-Sphinx-Theme – ideal für elegante, verständliche Doku.kernel_gatewayist ein Webserver, der verschiedene Mechanismen zum Starten und Kommunizieren mit Jupyter-Kernels unterstützt. Hier findest du Anwendungsfälle.nbviewerzum Teilen deiner Notebooks. Die Galerie gibt’s hier.tmpnbzum Erstellen temporärer Jupyter-Notebook-Server via Docker. Probiere es selbst hier aus.traitletsist ein Framework, mit dem Python-Klassen Attribute mit Typprüfung, dynamischen Default-Werten und On-Change-Callbacks erhalten. Außerdem lässt es sich zur Konfiguration nutzen, um Werte aus Dateien oder der Kommandozeile zu laden. traitlets treibt das Konfigurationssystem von IPython und Jupyter sowie die deklarative API der IPython-Widgets.
Nutzung der System-Shell?
Du kannst IPython per Shell-Escape für Systembefehle nutzen: Zeilen, die mit ! beginnen, werden direkt an die System-Shell übergeben. !ls führt z. B. ls im aktuellen Verzeichnis aus. Mit myfiles=!ls kannst du das Ergebnis einem Python-Variable zuweisen. Möchtest du die Ausgabe von ls explizit als Liste von Strings sehen, ohne sie zuzuweisen, nutze zwei Ausrufezeichen (!!ls) oder den Magic-Befehl %sx ohne Zuweisung.
# Assign the result to `ls`
ls = !ls
# Explicit `ls`
!!ls
# Or with magics
%sx
# Assign magics result
ls = %sxBeachte: !!-Befehle lassen sich nicht zuweisen, das Ergebnis eines Magic-Befehls (sofern er einen Wert zurückgibt) hingegen schon.
IPython erlaubt außerdem, Python-Variablen bei Systemaufrufen zu expandieren: Umklammere Variablen oder Ausdrücke mit {}. In Shell-Befehlen mit ! oder !! wird zudem jede mit $ präfixte Python-Variable expandiert. Im folgenden Code-Snippet wird beispielsweise das argv-Attribut von sys ausgegeben. Du kannst mit den Syntaxen $/$$ außerdem Werte aus Systemausgaben in Python-Variablen übernehmen und später weiterverarbeiten.
Um ein wörtliches $ in die Shell zu geben, nutze $$. Das brauchst du etwa, um Umgebungsvariablen wie $PATH zu referenzieren:
# Import and initialize
import math
x = 4
# System call with variable
!echo {math.factorial(x)}
# Expand a variable
!echo $sys.argv
# Use $$ for a literal $
!echo "A system variable: $$HOME"Mehr dazu hier.
Hinweis: Neben IPython gibt es auch andere Kernels mit eigener Syntax, um Zeilen als Shell-Befehle auszuführen. Das sind streng genommen keine „Magics“, weil Name und Umfang völlig abweichen können.
Außerdem gibt es Aliasse für Systembefehle – im Grunde Shortcuts für Bash-Kommandos. Ein Alias ist ein Tupel: („showTheDirectory“, „ls“). Mit %alias? bekommst du weitere Infos.
Tipp: Nutze %rehashx, um deinen gesamten $PATH als IPython-Aliasse zu laden.
Magics?
Wenn du DataCamps Definitive Guide to Jupyter Notebook gelesen oder bereits mit Jupyter gearbeitet hast, kennst du die sogenannten „Magic Commands“. Magics bestehen in der Regel aus einem in der Zielsprache ungültigen Syntaxelement und einem Wort, das den Befehl andeutet. Unter der Haube sind Magics-Pythonfunktionen.
Der IPython-Kernel nutzt – wie du weißt – das %-Syntaxelement, da es in Python kein gültiger unärer Operator ist. Zeilen, die mit %% beginnen, kennzeichnen eine Cell-Magic: Sie erhalten als Argument nicht nur den Rest der aktuellen Zeile, sondern auch alle folgenden Zeilen des aktuellen Ausführungsblocks. Cell-Magics können den Input beliebig verändern – er muss nicht einmal gültiger Python-Code sein. Sie bekommen den gesamten Block als einen String.
Magics sind kernel-spezifisch und werden von den Kernels bereitgestellt. Sie machen deine Arbeit im Jupyter Notebook deutlich interaktiver. Ob bestimmte Magics verfügbar sind, hängt vom jeweiligen Kernelteam ab. Kurz: Magics sind eine Kernel-Funktion.
Wenn du den Python-Backend-Kernel IPython im Jupyter Notebook nutzt, helfen dir folgende Kniffe, schneller, einfacher und interaktiver zu programmieren. Die Liste ist nicht vollständig. Eine komplette Übersicht der eingebauten Magics findest du hier.
Plotten
Ein zentrales Feature des IPython-Kernels ist die Anzeige von Plots als Ausgabe von Codezellen. Der Kernel arbeitet nahtlos mit der Visualisierungsbibliothek matplotlib zusammen. Verwende dazu den Magic-Befehl %matplotlib.
Standardmäßig erscheint der Plot in einem separaten Fenster. Du kannst aber auch einen Backend wie inline oder qt angeben – dann werden Ausgaben inline oder über ein anderes GUI-Backend gezeigt. Mehr dazu hier.
Dateisystem-Navigation
Mit Magics kannst du auch im Dateisystem navigieren. %cd und %bookmark wechseln das Verzeichnis bzw. setzen Lesezeichen für Ordner, die du häufig nutzt.
Debugger-Zugriff
Du kannst per Magic bei jeder unbehandelten Exception automatisch den Python-Debugger %pdb starten. So wirst du durch den Codeabschnitt geführt, der die Exception ausgelöst hat, und findest den Bug schneller.
Mit %run und der Option -d führst du Skripte unter Kontrolle des Debuggers aus; notwendige Breakpoints werden automatisch gesetzt. Auch %debug bietet bequemen Debugger-Zugriff.
IPython-Erweiterungen
Mit %load_ext lädst du eine IPython-Erweiterung per Modulnamen. IPython-Erweiterungen sind Python-Module, die das Verhalten der Shell verändern: Sie können Magics registrieren, Variablen definieren und den Namespace erweitern. Beispiele:
%load_ext oct2py.ipython, um M-Files und Octave-Funktionen nahtlos aus Python aufzurufen,%load_ext rpy2.ipython, um eine R-Schnittstelle in einem eingebetteten Python-Prozess zu nutzen,%load_ext Cythonfür einen Python-zu-C-Compiler,sympy.init_printing()für schön gesetzte Sympy-Ausgaben, und%load_ext fortranmagic, um Fortran in der interaktiven Session zu nutzen.
… Und vieles mehr! Du kannst eigene IPython-Erweiterungen erstellen und auf PyPI registrieren. Entsprechend gibt es zahlreiche Community-Erweiterungen und Magics. Ein Beispiel ist ipython_unittest. Sieh dir auch den Extensions Index an.
Eine weitere empfehlenswerte Erweiterung ist sparkmagic, ein Set an Tools für die interaktive Arbeit mit entfernten Spark-Clustern über Livy (einen Spark-REST-Server) in Jupyter Notebooks. Die Bibliothek sparkmagic stellt eine %%spark-Magic bereit, mit der du aus einem normalen IPython-Notebook heraus bequem Code auf einem entfernten Spark-Cluster ausführst.
# Load in sparkmagic
%load_ext sparkmagic.magics
# Set the endpoint
%manage_spark
# Ask for help
%spark?Weitere Beispiele, wie du damit interaktiv mit einem Spark-Cluster arbeitest, findest du hier.
Neben %load_ext gibt es in IPython noch %reload_ext und %unload_ext, um Erweiterungen im Jupyter Notebook neu zu laden bzw. zu entladen.
Andere Kernels, andere Magics
In anderen Sprachen kann das Magic-Syntaxelement eine Bedeutung haben. Der R-Kernel IRKernel hat kein Magic-System. Um Bash-Befehle auszuführen, nutzt du R-Funktionen wie system() für OS-Kommandos, z. B. system("head -5 *.csv", intern=TRUE). Mit dem Argument intern gibst du an, dass die Ausgabe als Zeichenkettenvektor in R zurückgegeben wird. Markdown zeigst du mit display_markdown() an, dem du den Markdown-Code als Zeichenkettenvektor übergibst. Ähnlich hat der Julia-Kernel IJulia keine „Magics“. Stattdessen gibt es natürlichere Syntaxen, die auch außerhalb von IJulia-Codezellen funktionieren und oft mächtiger sind. Wenn du in IJulia einen IPython-Magic-Befehl eingibst, zeigt dir der Kernel eine Hilfsausgabe, wie du den Effekt in Julia erreichst.
Das Pendant zu IPythons %load ist in IJulia beispielsweise IJulia.load().
Es gibt aber auch Kernels wie den Scala-Kernel IScala, die Magics ähnlich zu IPython unterstützen. Der Satz an Magics unterscheidet sich jedoch und ist auf Scala und die JVM zugeschnitten. Magics bestehen aus einem Prozentzeichen %, gefolgt von einem Bezeichner und optionalen Eingaben. Einige der wichtigsten Magics sind:
# Type Information
%type 1
# Library Management
%libraryDependencies
%updateWie oben beschrieben, bietet sparkmagic zudem Scala- und Python-Kernels, die automatisch eine Verbindung zu einem entfernten Spark-Cluster herstellen, Code und SQL-Queries ausführen, deinen Livy-Server und Spark-Jobkonfiguration verwalten und Visualisierungen erzeugen – ohne eigenen Code.
So kannst du z. B. SparkSQL-Queries mit %%sql ausführen oder Informationen und Logs einer Spark-Anwendung mit %%info abrufen.
Wenn du mit einem anderen Kernel arbeitest und dich fragst, ob Magics verfügbar sind: Einige Kernels bauen auf dem metakernel-Projekt auf und nutzen oft dieselben Magics wie der IPython-Kernel. Eine Liste der metakernel-Magics findest du hier. metakernel ist eine Jupyter/IPython-Kernel-Vorlage mit Kern-Magicfunktionen.
Beispiele:
- Der MATLAB-Kernel
matlab_kernel, - der Octave-Kernel
octave_kernel, - der Java9-Kernel
java9_kernel, - der Wolfram-Kernel
wolfram_kernel, - der SAS-Kernel. … Und viele mehr!
Das bedeutet: Wenn du z. B. den MATLAB-Kernel nutzt, stehen dir folgende Magics zur Verfügung:
Available line magics:
%cd %connect_info %download %edit %get %help %html %install %install_magic %javascript %kernel %kx %latex %load %ls %lsmagic %magic %parallel %plot %pmap %px %python %reload_magics %restart %run %set %shell %spell
Available cell magics:
%%debug %%file %%help %%html %%javascript %%kx %%latex %%processing %%px %%python %%shell %%show %%spellVergleichst du das mit den standardmäßig im IPython-Kernel verfügbaren Magics, erkennst du einige Überschneidungen:
Available line magics:
%alias %alias_magic %autocall %automagic %autosave %bookmark %cat %cd %clear %colors %config %connect_info %cp %debug %dhist %dirs %doctest_mode %ed %edit %env %gui %hist %history %killbgscripts %ldir %less %lf %lk %ll %load %load_ext %loadpy %logoff %logon %logstart %logstate %logstop %ls %lsmagic %lx %macro %magic %man %matplotlib %mkdir %more %mv %notebook %page %pastebin %pdb %pdef %pdoc %pfile %pinfo %pinfo2 %popd %pprint %precision %profile %prun %psearch %psource %pushd %pwd %pycat %pylab %qtconsole %quickref %recall %rehashx %reload_ext %rep %rerun %reset %reset_selective %rm %rmdir %run %save %sc %set_env %store %sx %system %tb %time %timeit %unalias %unload_ext %who %who_ls %whos %xdel %xmode
Available cell magics:
%%! %%HTML %%SVG %%bash %%capture %%debug %%file %%html %%javascript %%js %%latex %%perl %%prun %%pypy %%python %%python2 %%python3 %%ruby %%script %%sh %%svg %%sx %%system %%time %%timeit %%writefileIm Kern hilft eine Leitfrage, um IPython-spezifische Magics von allgemeineren zu trennen: Ist die Funktion Python-spezifisch oder allgemein und auch in der Zielsprache sinnvoll?
%pdb (Python Debugger) oder %matplotlib sind Python-spezifisch und in einem JavaScript-Kernel wenig sinnvoll. %cd zum Verzeichniswechseln ist dagegen allgemein und sollte in vielen Sprachen funktionieren – sofern der jeweilige Kernel Magics unterstützt.
Konvertieren und Formatieren von Notebooks?
Konvertierung und Formatierung sind Aufgaben im Jupyter-Ökosystem. Typische Tools sind nbconvert und nbformat.
Mit nbconvert wandelst du Notebooks in verschiedene Formate um – für Präsentationen, zur Veröffentlichung, zur Einbettung in Papers, für Kollaboration oder zum Teilen mit einer größeren Zielgruppe.
nbformat definiert das Jupyter-Notebook-Format und macht klar: Notebook-Dateien sind einfache JSON-Dokumente mit Metadaten (z. B. Kernel-/Sprachinfo), der Formatversion (Major/Minor) und den Zellen, in denen Text, Code usw. liegen.
Notebooks speichern und laden?
Das Speichern und Laden von Notebooks ist eine Funktion der Jupyter-Notebook-Anwendung. Du kannst fremde Notebooks mit der Endung .ipynb laden, indem du die Datei herunterlädst und in Jupyter öffnest. Konkret: Erstelle ein neues Notebook, klicke auf den Tab „File“, dann „Open“ und wähle die heruntergeladene Datei.
Umgekehrt kannst du eigene Notebooks über denselben „File“-Tab mit „Download as“ herunterladen oder per „Save and Checkpoint“ sichern. Das ist praktisch für leichtgewichtige Versionskontrolle und um ggf. zu einem früheren Stand zurückzukehren. Änderungen werden außerdem alle paar Minuten automatisch gespeichert – manuelles Speichern ist nicht immer nötig.
Du kannst auch eine Kopie anlegen und alle Änderungen in dieser Kopie speichern, um das Original unverändert zu lassen.
Keyboard Shortcuts & Multi-Cursor?
Mehrere Zellen markieren, Ausgaben ein-/ausblenden, neue Zellen einfügen usw.: Für all das gibt es Tastaturkürzel im Jupyter Notebook. Die Liste findest du im oberen Menü unter „Help“ → „Keyboard Shortcuts“.
Auch die Multi-Cursor-Unterstützung ist eine Funktion des Jupyter Notebooks.
Parallel-Computing-Netzwerk?
Das Parallel-Computing-Netzwerk gehörte zum IPython-Projekt, ist aber seit Version 4.0 als eigenständiges Paket ipyparallel verfügbar. Das Paket ist eine Sammlung von CLI-Skripten zur Steuerung von Clustern für Jupyter.
Auch wenn es ausgelagert wurde, ist es ein leistungsfähiger, oft übersehener Teil des IPython-Ökosystems. Statt nur eines Python-Kernels kannst du viele verteilte Kernels über mehrere Maschinen starten.
Typische Einsatzszenarien für ipyparallel sind Modelle, die vielfach mit variierenden Eingaben ausgeführt werden müssen, um die Verteilung der Ausgaben zu schätzen. Sind die Läufe unabhängig, beschleunigst du sie, indem du sie parallel auf mehreren Rechnern im Cluster laufen lässt. Beispiele: verteiltes Modelltraining oder Simulationen.
Terminal?
Diese Funktion gehört zum Jupyter-Ökosystem: Es gibt die Jupyter Console und eine Jupyter-Terminalanwendung. Seit Beginn stand „IPython“ jedoch für das ursprüngliche interaktive Python-Terminal mit erweitertem REPL, besonders geeignet für Scientific Computing. Das war der Standard, bevor 2011 das Notebook-Tool eine moderne, leistungsfähige Weboberfläche brachte.
Daneben gab es die IPython-Konsole, die zwei Prozesse startete: die ursprüngliche IPython-Terminal-Shell und das Default-Profil bzw. den Kernel (standardmäßig Python). Die IPython-Konsole ist inzwischen veraltet; stattdessen nutzt du die Jupyter Console, ein terminalbasiertes Frontend für Jupyter-Kernels. Der Code basiert auf dem Ein-Prozess-IPython-Terminal. Die Jupyter Console bietet das interaktive IPython-Erlebnis im Terminal, kann aber mit beliebigen Jupyter-Kernels statt nur mit IPython verbinden. So testest du jeden installierten Kernel direkt im Terminal – ohne gleich ein Notebook zu starten. Die Console erlaubt terminalbasiertes Arbeiten etwa mit IJulia oder IRKernel.
Schließlich bringt die Jupyter-Notebook-Anwendung auch ein Terminal mit: eine einfache Bash-Shell im Browser. Du findest sie, wenn du die Anwendung startest und im Dropdown ein neues Terminal wählst.
Qt-Konsole?
Die Qt-Konsole war früher Teil von IPython, gehört heute jedoch zu Jupyter. Sie ist eine schlanke Anwendung, die sich wie ein Terminal anfühlt, aber GUI-Vorteile mitbringt: Inline-Grafiken, echtes Multiline-Editing mit Syntax-Highlighting, grafische Tooltips u. v. m. Die Qt-Konsole kann mit jedem Jupyter-Kernel arbeiten.
Fazit
Dieser Beitrag ergänzt DataCamps Definitive Guide und beleuchtet die Geschichte der Computational Notebooks sowie zentrale Funktionen von IPython und Jupyter. Ziel war, die Entwicklung und den Unterschied beider Projekte klarer zu machen. Ohne den historischen Kontext bleibt die Abgrenzung oft schwierig – und es gibt Graubereiche, die sich nicht eindeutig zuordnen lassen.