Veel dank aan Brian Granger, Fernando Pérez en Robert Kern voor hun input voor dit artikel!
Voor zowel beginners als gevorderde data scientists is de Jupyter Notebook een van de populairste datatools: de interactieve omgeving is niet alleen ideaal om te onderwijzen en te leren, en om je werk met anderen te delen, maar zorgt ook voor reproduceerbaar onderzoek. Toch kom je, terwijl je deze notebook leert kennen, vaak IPython tegen.
De twee lijken in sommige gevallen synoniemen en je zult het met me eens zijn dat het behoorlijk verwarrend is wanneer je dieper wilt graven: horen magics bij Jupyter of IPython? Is het opslaan en laden van notebooks een functie van IPython of Jupyter?
Je kunt waarschijnlijk eindeloos doorgaan met vragen.
Deze blogpost wil enkele kernverschillen tussen de twee explicieter illustreren: we starten bij de oorsprong van beide om uit te leggen hoe ze zich tot elkaar verhouden, en behandelen ook specifieke functies die óf bij de een óf bij de ander horen, zodat je het onderscheid makkelijker kunt maken!
Denk er ook aan om DataCamp’s Definitieve gids voor Jupyter Notebook te lezen voor tips en tricks, best practices, voorbeelden en meer.
De oorsprong van IPython / Jupyter
Om volledig te begrijpen wat de Jupyter Notebook is en hoe die verschilt van IPython, is het interessant om eerst te lezen hoe deze twee passen in de geschiedenis en toekomst van computationele notebooks.
Het begin van computationele notebooks: MATLAB, Mathematica & Maple
Midden jaren tachtig werd MATLAB uitgebracht door The MathWorks, opgericht door Jack Little, Steve Bangert en Cleve Moler.
Ga naar de late jaren tachtig, 1987 om precies te zijn. Theodore Gray begon te werken aan wat de Mathematica notebook-frontend zou worden en een jaar later werd die publiek uitgebracht. De GUI maakte het mogelijk om interactief notebookdocumenten te maken en te bewerken die mooi opgemaakte code, geformatteerde tekst en een hele reeks functies bevatten, zoals gezet wiskundig schrift, graphics, GUI-componenten, tabellen en geluiden. Standaard tekstverwerkingsfuncties waren aanwezig, zoals realtime meertalige spellingcontrole. Je kon de documenten in een slideshow-omgeving presenteren.
Kijk je naar de structuur van deze notebooks, dan valt meteen op dat ze afhankelijk waren van een hiërarchie van cellen die het mogelijk maakte om documenten te structureren en te secties te verdelen, iets wat je nu ook in Jupyter-notebooks terugvindt.
Ook eind jaren tachtig, in 1989, introduceerde Maple hun eerste notebook-achtige GUI. Die zat bij versie 4.3 voor de Macintosh. Versies van de nieuwe interface voor X11 en Windows volgden in 1990. Deze vroege notebooks inspireerden en legden de basis voor anderen om te ontwikkelen wat later “data science notebooks” zouden worden genoemd.
De opkomst van data science-notebooks
Na de Maple- en Mathematica-notebooks zijn veel computationele notebooks ontwikkeld. Deze sectie focust echter op de notebooks die hebben bijgedragen aan de opkomst van data science-notebooks. Je zult zien dat sommige hiervan nog steeds erg populair zijn bij beginnende en meer ervaren data scientists.
Sage Notebook
De Sage-notebook als browsersysteem werd voor het eerst uitgebracht midden jaren 2000 en in 2007 volgde een nieuwe, krachtigere versie met gebruikersaccounts en de mogelijkheid om documenten openbaar te maken. De UI deed denken aan Google Docs, aangezien de lay-out van de Sage-notebook was gebaseerd op die van Google notebooks.
De makers van de Sage-notebooks hebben bevestigd dat ze fervente gebruikers waren van de Mathematica-notebooks en Maple-werkbladen. Andere drijfveren die belangrijk waren bij de ontwikkeling van de Sage-notebooks waren de volgende: ten eerste hadden de ontwikkelaars nauw contact met het team achter IPython, ook omdat de terminalversie van Sage IPython gebruikte. Ten tweede was er “een mislukte poging” van twee studenten om een GUI voor IPython te maken, en ten derde de opkomst van “AJAX” (een pseudo-acroniem voor “Asynchronous JavaScript And XML”) webapplicaties, waarbij gebruikers niet de hele pagina hoefden te verversen bij elke actie.
Dat zie je bijvoorbeeld wanneer je een formulier op een website invult: zonder AJAX word je bij het klikken op verzenden doorgestuurd naar een nieuwe pagina met nieuwe informatie van de server. Met AJAX doet JavaScript het verzoek aan de server, haalt de resultaten op en werkt het scherm bij. Je hoeft niet te verversen, en je wordt niet doorgestuurd.
Andere AJAX-toepassingen die je mogelijk kent zijn bijvoorbeeld Gmail, Google Maps, Facebook, Twitter,… Zoals je ziet: bijna alles is AJAX.
IPython en Jupyter Notebook
Eind 2001, zo’n twintig jaar nadat Guido van Rossum begon te werken aan Python bij het Centrum Wiskunde & Informatica in Nederland, begon Fernando Pérez met de ontwikkeling van IPython. Het project werd sterk beïnvloed door de Mathematica-notebooks en Maple-werkbladen, net als de Sage-notebook en vele andere daaropvolgende projecten.
In 2005 was er een eerste poging om een notebooksysteem te bouwen met Wx, een widgettoolkit en bibliotheek voor het maken van GUI’s voor cross-platform applicaties. Twee Google Summer of Code-studenten werkten aan het prototype onder leiding van Robert Kern en Fernando Pérez. Daarna stak Robert nog wat werk in het probleem. Het was minder een prototype van een notebooksysteem dan wel een opschoning van de kerncode van IPython, met als doel het makkelijker te maken om een wxPython GUI-frontend voor de IPython-shell te schrijven. Die opschoningen hielpen ook om een schoon notebooksysteem te maken en sommige daarvan zijn stapsgewijs in IPython samengevoegd toen de uiteindelijk succesvolle notebookinspanning op gang kwam.
Het tweede prototype voor IPython werd in de zomer van 2006 gebouwd door Min Ragan-Kelley, geadviseerd door Brian Granger. Het was webgebaseerd en had een SQL-databasebackend, maar het werk werd stopgezet omdat de implementatie met de webtechnologieën van toen te complex bleek.
Het derde prototype van de IPython-notebook kwam in oktober 2010 en werd door een derde partij in een paar dagen gehackt. Uiteindelijk werkte Brian Granger in de lente-zomer van 2011 fulltime aan het prototype van de webnotebook, gebaseerd op werk dat hij in 2010 deed, waarbij hij samen met Fernando Pérez de IPython-kernelarchitectuur en berichten specificatie creëerde en met Min Ragan Kelley PyZMQ bouwde.
PyZMQ is een bibliotheek die Python-bindings levert voor ZeroMQ; Deze bibliotheek was nodig voor IPython’s parallel computing-functies, qt-console en notebook.
PyZMQ en websockets waren de hoofdtechnologieën die de notebook mogelijk maakten. In de herfst van datzelfde jaar droegen andere bijdragers (zoals Matthias Bussonnier, Min en Fernando) ook bij. Op 21 december 2011 werd de eerste versie van de IPython Notebook (0.12) uitgebracht.
In de daaropvolgende jaren ontving het team prijzen, zoals de Advancement of Free Software voor Fernando Pérez op 23 maart 2013 en de Jolt Productivity Award, en financiering van onder andere de Alfred P. Sloan Foundation.
Uiteindelijk, in 2014, startte Project Jupyter als een afsplitsing van IPython.
De laatste release van IPython vóór de splitsing bevatte een interactieve shell, de notebookserver, de Qt-console, enzovoort, in één repository. Het project was groot, met componenten die steeds meer op zichzelf staande projecten werden die toevallig tot hetzelfde geheel behoorden.
Maar bedenk dat de omvang niet de enige reden was om Project Jupyter te starten: van 2011 tot 2014 begon de IPython-notebook ook met andere programmeertalen te werken. De eerste was Julia, daarna R. Het feit dat IPython-notebook, wat impliceerde dat de notebook puur Python-gebaseerd was, ook werkte met kernels van andere talen zoals Julia en R, zorgde voor verwarring.
Waarom dan de naam “IPython” als er ook andere programmeertalen bij betrokken waren?
De naam “Jupyter” werd geïnspireerd door de toonaangevende open talen voor de wetenschap (Julia, Python en R), en ook al lijkt het op een acroniem, het heeft nooit betekend dat andere talen niet welkom waren. Sterker nog, de naam vertegenwoordigde beter het project waar de ontwikkelaars aan werkten en knipoogde naar de wetenschappelijke wortels!
Na de start van Project Jupyter werden de taalonafhankelijke delen van het IPython-project, zoals het notebookformaat, het berichtprotocol, de Qt-console, de webapplicatie voor notebooks, enz. ondergebracht in het Jupyter-project. De belangrijkste Jupyter GitHub-organisatie vind je hier.
In de Jupyter- en IPython-gemeenschappen heet dit “The Big Split”.
IPython heeft nu nog twee rollen: het is de Python-backend voor de Jupyter Notebook, ook wel de kernel genoemd, én een interactieve Python-shell. Maar dat is niet alles: binnen het IPython-ecosysteem vind je ook een platform voor parallelle computing. Daar lees je later meer over!
En net als IPython is Project Jupyter eigenlijk een verzamelnaam voor een reeks projecten: de drie applicaties die het omvat zijn de Notebook zelf, een Console en een Qt-console, maar er zijn ook subprojecten zoals JupyterHub voor notebookdeployments, nbgrader voor onderwijsdoeleinden, enzovoort. Je ziet een overzicht van de Jupyter-architectuur hier.
Let op: juist de evolutie van dit project verklaart de verwarring die veel Pythonistas hebben rond IPython en Jupyter: omdat het een uit het ander is voortgekomen (nog niet zo lang geleden), hebben sommigen nog moeite om de juiste namen te hanteren. Een nog complicerender factor is de evolutie zelf: omdat het een uit het ander is ontstaan, is er een aanzienlijke overlap tussen de functies van IPython en de Jupyter Notebook die soms lastig te onderscheiden is! Hoe je het onderscheid maakt, wordt duidelijk in de volgende secties. Wil je meer details over de ontwikkeling van IPython, bekijk dan de persoonlijke verslaglegging van Fernando Pérez en William Stein over de geschiedenis van hun notebooks.
R-notebooks
R Markdown en de Jupyter Notebook delen het leveren van een reproduceerbare workflow: het verweven van code, output en tekst in één document, ondersteuning voor interactieve widgets en output naar meerdere formaten.
Toch verschillen de twee ook: de eerste focust op reproduceerbare batchuitvoering, platte-tekstrepresentatie, versiebeheer, productie-output en biedt dezelfde editor en tools als voor R-scripts. De tweede focust op inline-uitvoer bij code, het cachen van uitvoer over sessies heen, het delen van code en uitvoer in één bestand. Notebooks leggen de nadruk op een interactief executiemodel. Ze gebruiken geen platte-tekstrepresentatie, maar een gestructureerde datarepresentatie, zoals JSON.
Dat verklaart het doel van RStudio’s notebookapplicatie: die combineert alle voordelen van R Markdown met de sterke punten van computationele notebooks.
Wil je meer leren over werken met R-notebooks en de exacte verschillen tussen Jupyter- en R Markdown-notebooks qua delen, projectbeheer, versiecontrole en meer, bekijk dan DataCamp’s post Jupyter en R: Notebooks met R.
Andere data science-notebooks
Natuurlijk zijn er nog meer notebooks om te overwegen als je met data science begint. De laatste jaren hebben veel nieuwe alternatieven hun weg gevonden naar data scientists en -liefhebbers: denk niet alleen aan Beaker Notebook, Apache Zeppelin, Spark Notebook, DataBricks Cloud, enzovoort, maar ook aan tools zoals de Rodeo IDE of nteract, die je analyses ook interactief en reproduceerbaar maken. Goed om te weten: nteract verschilt van de andere genoemde tools omdat het gebruikmaakt van de Jupyter-architectuur, zoals de protocollen en formaten.
De toekomst van notebooks
En notebooks lijken te blijven. Onlangs is de volgende generatie van de Jupyter Notebook geïntroduceerd: JupyterLab. De Notebook-applicatie biedt niet alleen ondersteuning voor Notebooks, maar ook een bestandsbeheerder, een teksteditor, een terminalemulator, een monitor voor draaiende Jupyter-processen, een IPython-clusterbeheerder en een pager om help te tonen.
Je denkt nu misschien dat dit niets nieuws is; De Jupyter Notebook heeft dit ook allemaal. JupyterLab stelt je echter in staat om al deze bouwstenen van interactief rekenen op nieuwe manieren te gebruiken.
Lees er meer over hier.
De rijke toolset van de Jupyter Notebook is organisch gegroeid en gedreven door de behoeften van gebruikers en ontwikkelaars. JupyterLab is een next-gen architectuur om al deze tools te ondersteunen, maar dan met een flexibele en responsieve UI die een door de gebruiker te bepalen lay-out biedt die de tools kan samenbrengen.
IPython of Jupyter?
De evolutie van het project en de daaropvolgende “Big Split” vormen de basis om de echte verschillen tussen de twee te begrijpen. Maar omdat ze inherent verbonden zijn, zul je soms twijfelen wat bij wat hoort.
De volgende sectie behandelt enkele functies die óf deel uitmaken van het IPython-ecosysteem óf van Project Jupyter.
Aan jou om het juiste antwoord te kiezen en meer over elke functie te ontdekken!
Kernels?
Hoewel kernels nu prominent aanwezig zijn in de Jupyter Notebook-applicatie, was de eerste tool die ooit een volledige kernel en protocol gebruikte de Qt-console, ontwikkeld vóór de Notebook. Tegenwoordig worden de kernels flexibel benut door de Notebook, zowel historisch als architectonisch, en zijn ze een functie van Jupyter en niet van de Notebook. Dit betekent dat kernels veel meer zijn dan zomaar een functie: ze zijn een kernabstractie van de Jupyter-architectuur en worden gebruikt door niet-notebooktools, zoals de tekstconsole, Qt-console, O’Reilly’s Thebe, de Kernel Gateway-tool, nteract’s Hydrogen-editor. Tot slot kunnen in JupyterLab kernels ook worden verbonden met alles, van een notebook tot een webconsole of zelfs een tekstbestand.
Een kernel is een programma dat de code van de gebruiker draait en inspecteert: het levert rekenkracht en communicatie met de frontendinterfaces, zoals notebooks. De Jupyter Notebook-applicatie heeft drie hoofd-kernels: de IPython-, IRkernel- en IJulia-kernel.
Aangezien de naam “Jupyter” is geïnspireerd op de toonaangevende open talen voor de wetenschap (Julia, Python en R), is dat geen grote verrassing. De IPython-kernel wordt onderhouden door het Jupyter-team, als gevolg van de evolutie van het project.
Je kunt echter ook veel andere talen draaien, zoals Scala, JavaScript, Haskell, Ruby en meer in de Jupyter Notebook-applicatie. Dat zijn community-onderhouden kernels.
Notebook-deployment?
Het uitrollen van notebooks is iets wat je typisch vindt of onderzoekt wanneer je met Jupyter-notebooks werkt. Er zijn heel wat pakketten die je helpen om je notebooks te deployen en die deel uitmaken van het Jupyter-ecosysteem.
Hier zijn er een paar:
docker-stacksis handig wanneer je stapels Jupyter-applicaties en -kernels als Docker-containers nodig hebt.ipywidgetsbiedt interactieve HTML- & JavaScript-widgets (zoals sliders, selectievakjes, tekstvakken, grafieken, enz.) voor de Jupyter-architectuur die frontendbesturingen koppelen aan een Jupyter-kernel.jupyter-drivelaat IPython Google Drive gebruiken voor bestandsbeheer.jupyter-sphinx-themeom een Jupyter Sphinx-thema aan je notebook toe te voegen. Dat maakt het eenvoudiger om slimme en mooie documentatie te maken.kernel_gatewayis een webserver die verschillende mechanismen ondersteunt voor het starten en communiceren met Jupyter-kernels. Kijk hier voor use-cases waarin dit pakket van pas kan komen.nbviewerom je notebooks te delen. Bekijk de galerij hier.tmpnbom tijdelijke Jupyter Notebook-servers te maken met Docker-containers. Probeer het zelf hier.traitletsis een framework waarmee Python-klassen attributen kunnen hebben met typecontrole, dynamisch berekende standaardwaarden en ‘on change’-callbacks. Je kunt het pakket ook gebruiken voor configuratie, om waarden uit bestanden of via commandoregelargumenten te laden. traitlets voedt het configuratiesysteem van IPython en Jupyter en de declaratieve API van IPython interactieve widgets.
Systeem-shell gebruiken?
Het is mogelijk om IPython aan te passen voor gebruik als systeem-shell met de shell-escape: regels die beginnen met ! worden rechtstreeks doorgegeven aan de systeem-shell. Bijvoorbeeld, !ls draait ls in de huidige map. Je kunt het resultaat van een systeemcommando toewijzen aan een Python-variabele met de syntaxis myfiles=!ls. Wil je het resultaat van een ls-commando expliciet als lijst met strings geprint zien, zonder toewijzing aan een variabele, gebruik dan twee uitroeptekens (!!ls) of de %sx-magic zonder toewijzing.
# Assign the result to `ls`
ls = !ls
# Explicit `ls`
!!ls
# Or with magics
%sx
# Assign magics result
ls = %sxLet op dat !!-commando’s niet aan een variabele kunnen worden toegewezen, maar dat het resultaat van een magic (zolang die een waarde teruggeeft) wel aan een variabele kan worden toegewezen.
IPython laat je ook de waarde van Python-variabelen uitbreiden bij systeemaanroepen: zet je variabelen of expressies gewoon tussen accolades ({}). Ook wordt in een shell-commando met ! of !! elke Python-variabele met het voorvoegsel $ uitgebreid. In het onderstaande codeblok zie je dat je het argv-attribuut van de variabele sys echoot. Let op: je kunt de syntaxis $/$$ ook gebruiken voor Python-variabelen uit systeemoutput, die je later voor verdere scripting kunt gebruiken.
Om een letterlijk $ aan de shell door te geven, gebruik je een dubbele $$. Je hebt deze letterlijke $ nodig als je toegang wilt tot shell- en omgevingsvariabelen zoals $PATH:
# 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"Lees meer hier.
Let op dat er, naast IPython, ook andere kernels zijn met speciale syntaxis om ervoor te zorgen dat regels als shellcommando’s worden uitgevoerd! Dit zijn niet echt “magics” in de striktste zin, omdat ze het met elke gewenste naam kunnen implementeren en het compleet anders (en meer of minder uitgebreid) kan zijn dan de IPython-magics.
Daarnaast zijn er aliassen die je kunt definiëren voor systeemcommando’s. Deze aliassen zijn in feite snelkoppelingen naar bash-commando’s. Eén alias is een tuple: (“showTheDirectory”, “ls”). Draai %alias? voor meer informatie!
Tip: gebruik %rehashx om je volledige $PATH als IPython-aliassen te laden.
Magics?
Als je DataCamp’s Definitieve gids voor Jupyter Notebook hebt doorgenomen of al met Jupyter hebt gewerkt, ken je de zogenaamde “magic commands” waarschijnlijk al. De magics bestaan meestal uit een syntactisch element dat niet geldig is in de onderliggende taal en een soort woord dat een commando impliceert. Onder de motorkap zijn magics eigenlijk Python-functies.
De IPython-kernel gebruikt, zoals je al weet, het %-synthaxelement omdat het geen geldige unair operator in Python is. Regels die beginnen met %% duiden echter een cell magic aan: ze nemen als argumenten niet alleen de rest van de huidige regel, maar ook alle regels eronder in het huidige uitvoerblok. Cell magics kunnen in feite willekeurige wijzigingen aanbrengen in de input die ze ontvangen, die zelfs helemaal geen geldige Python-code hoeft te zijn. Ze ontvangen het hele blok als één string.
Magics zijn specifiek voor en worden geleverd door kernels en zijn ontworpen om je werk en ervaring binnen Jupyter Notebook een stuk interactiever te maken. Of magic commands in een bepaalde kernel beschikbaar zijn, hangt af van de ontwikkelaar(s) en verschilt per kernel. Je ziet het al: magics zijn een kernelfunctie.
Wanneer je de Python-backend voor de Jupyter Notebook gebruikt, IPython, ook wel de kernel genoemd, wil je misschien de volgende trucs gebruiken om toegang te krijgen tot functionaliteiten die je programmeren sneller, eenvoudiger en interactiever maken. Merk op dat de lijst niet uitputtend is. Bekijk deze lijst met ingebouwde magic commands voor een compleet overzicht.
Plotten
Een belangrijke functie van de IPython-kernel is de mogelijkheid om plots te tonen die het resultaat zijn van het uitvoeren van codecellen. De kernel is ontworpen om naadloos samen te werken met de datavisualisatiebibliotheek matplotlib om deze functionaliteit te bieden. Gebruik hiervoor het magic-commando %matplotlib.
Standaard wordt je plot in een apart venster getoond. Daarnaast kun je ook een backend specificeren, zoals inline of qt; de uitvoer van de plotcommando’s wordt dan inline getoond of via een andere GUI-backend. Je leest er meer over hier.
Navigeren in het bestandssysteem
De magic-commando’s van de kernel bieden ook een manier om door je bestandssysteem te navigeren. De magics %cd en %bookmark kun je gebruiken om van map te wisselen of om een map te bookmarken voor snellere toegang tot vaak gebruikte directories.
Debugger-toegang
Verder kun je magics gebruiken om bij elke onopgevangen uitzondering een Python-debugger %pdb op te roepen. Dit leidt je door het deel van de code dat de uitzondering veroorzaakte, zodat je de bron van een bug snel kunt vinden.
Je kunt ook het magic-commando %run met de optie -d gebruiken om scripts onder controle van de Python-debugger uit te voeren. Het zet automatisch initiële breakpoints voor je. Tot slot is er ook de %debug-magic voor nog makkelijker debuggen.
IPython-extensies
Je kunt de magic %load_ext gebruiken om een IPython-extensie te laden op basis van de modulenaam. IPython-extensies zijn Python-modules die het gedrag van de shell aanpassen: extensies kunnen magics registreren, variabelen definiëren en in het algemeen de user-namespace aanpassen om nieuwe features voor gebruik in codecellen te bieden. Enkele voorbeelden:
- Gebruik
%load_ext oct2py.ipythonom M-bestanden en Octave-functies naadloos vanuit Python aan te roepen, - Gebruik
%load_ext rpy2.ipythonvoor een interface naar R die ingebed draait in een Python-proces, - Gebruik
%load_ext Cythonvoor een Python-naar-C-compiler, - Gebruik
sympy.init_printing()om Sympy Basic-objecten mooi opgemaakt automatisch te printen, en - Voor Fortran in je interactieve sessie gebruik je
%load_ext fortranmagic.
… Er zijn er veel meer! Je kunt je eigen IPython-extensies maken en registreren op PyPi: dat betekent ook dat er veel andere door gebruikers gedefinieerde extensies en magics bestaan! Een voorbeeld is ipython_unittest, maar bekijk ook deze Extensions Index.
Een andere extensie om in de gaten te houden is sparkmagic, een set tools om interactief te werken met externe Spark-clusters via Livy, een Spark REST-server, in Jupyter-notebooks. De sparkmagic-bibliotheek biedt een %%spark-magic die je kunt gebruiken om eenvoudig code tegen een extern Spark-cluster te draaien vanuit een normale IPython-notebook.
# Load in sparkmagic
%load_ext sparkmagic.magics
# Set the endpoint
%manage_spark
# Ask for help
%spark?Ga hier heen voor meer voorbeelden van hoe je deze magics kunt gebruiken om interactief met Spark-clusters te werken.
Let op dat IPython naast %load_ext nog twee andere magics heeft waarmee je extensies vanuit je Jupyter Notebook kunt beheren: %reload_ext en %unload_ext om respectievelijk een extensie te herladen en te laden, en om de extensie te ontladen.
Andere kernels, andere magics
In andere talen kan het syntactische element in de magic-commando’s echter een betekenis hebben. De R-kernel, IRKernel, heeft geen magics-systeem. Om bash-commando’s uit te voeren, gebruik je bijvoorbeeld R-functies zoals system() om een OS-commando aan te roepen. Een voorbeeld is system("head -5 *.csv", intern=TRUE). Door het argument intern mee te geven, geef je aan dat je de output van het commando als een karaktervector in R wilt opvangen. Om markdown in te tonen, gebruik je display_markdown(), waaraan je de Markdown-code als karaktervector doorgeeft. Evenzo gebruikt de Julia-kernel IJulia ook geen “magics”. In plaats daarvan zijn andere syntaxes om dezelfde doelen te bereiken natuurlijker in Julia, werken ze buiten IJulia-codecellen en zijn ze vaak krachtiger. Wel hebben de ontwikkelaars van de IJulia-kernel ervoor gezorgd dat wanneer je een IPython-magic in een IJulia-codecel invoert, je een helpuitvoer ziet die uitlegt hoe je een vergelijkbaar effect in Julia kunt bereiken, indien mogelijk.
Het equivalent van IPython’s %load in IJulia is bijvoorbeeld IJulia.load().
Aan de andere kant zijn er kernels zoals de Scala-kernel IScala die magics ondersteunen, vergelijkbaar met IPython. De set magics is echter anders, omdat die moet aansluiten bij de eigenheden van Scala en de JVM. Magic-commando’s bestaan uit een procentteken % gevolgd door een identifier en optionele input voor een magic. Enkele opvallende magics zijn:
# Type Information
%type 1
# Library Management
%libraryDependencies
%updateZoals je hierboven hebt gelezen, biedt de sparkmagic-bibliotheek ook een set Scala- en Python-kernels waarmee je automatisch verbinding kunt maken met een extern Spark-cluster, code en SQL-queries kunt uitvoeren, je Livy-server en Spark-jobconfiguratie kunt beheren en automatische visualisaties kunt genereren. En dat zonder ook maar enige code nodig te hebben!
Zo kun je eenvoudig SparkSQL-queries uitvoeren met %%sql of informatie en logs van Spark-applicaties bekijken via de %%info-magic.
Werk je met een andere kernel en vraag je je af of je magics kunt gebruiken, dan is het handig om te weten dat er kernels zijn die voortbouwen op het metakernel-project en in veel gevallen dezelfde magics gebruiken die je ook in de IPython-kernel vindt. Je vindt een lijst van de metakernel-magics hier. De metakernel is een Jupyter/IPython-kernelsjabloon met kern-magicfuncties.
Enkele voorbeelden:
- De MATLAB-kernel
matlab_kernel, - De Octave-kernel
octave_kernel, - De Java9-kernel
java9_kernel, - De Wolfram-kernel
wolfram_kernel, - De SAS-kernel. … En nog veel meer!
Dit betekent dat je, wanneer je bijvoorbeeld de MATLAB-kernel gebruikt, de volgende magics beschikbaar hebt:
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 %%spellAls je naar het bovenstaande blok kijkt, zie je dat sommige van die magic-commando’s erg bekend voorkomen. Voor wie de magics minder goed kent: vergelijk het bovenstaande blok met de magics die je standaard in de IPython-kernel beschikbaar hebt, en je ziet dat sommige magics hetzelfde zijn:
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 %%writefileIn essentie kun je één vraag gebruiken om te onderscheiden welke magics specifiek zijn voor IPython en welke in andere kernels gebruikt kunnen worden: is deze functionaliteit Python-specifiek of is het iets algemeens dat ook in de taal waarmee je werkt zin heeft?
Bijvoorbeeld, %pdb of de Python Debugger, of %matplotlib, is iets specifieks voor Python dat niet logisch is wanneer je met de JavaScript-kernel werkt. Maar van map wisselen met %cd is typisch iets algemeens dat in elke taal zou moeten werken, omdat het zo’n “algemeen” commando is. De kans is dus groot dat dit een magic is die je in andere kernels kunt gebruiken. Natuurlijk moet je nog steeds weten of jouw kernel magics ondersteunt.
Notebooks converteren en formatteren?
Converteren en formatteren van notebooks zijn functies die je in het Jupyter-ecosysteem vindt. Twee tools die je hiervoor vaak gebruikt zijn nbconvert en nbformat.
Met de eerste kun je notebooks naar diverse andere formaten omzetten om informatie in vertrouwde formaten te presenteren, onderzoek te publiceren en notebooks in papers op te nemen, samen te werken en content met een groter publiek te delen.
De tweede bevat in feite het Jupyter Notebook-formaat en is de sleutel tot het begrijpen dat notebookbestanden eenvoudige JSON-documenten zijn die bevatten: metadata (zoals kernel- of taalinfo), de versie van het notebookformaat (major en minor) en de cellen waarin alle tekst, code, enz. is opgeslagen.
Notebooks opslaan en laden?
Notebooks opslaan en laden is een functie van de Jupyter Notebook-applicatie. Je kunt notebooks laden, opgeslagen als bestanden met de extensie .ipynb, die door anderen zijn gemaakt, door het bestand te downloaden en te openen in de Jupyter-applicatie. Concreet kun je een nieuwe notebook maken en ervoor kiezen om het bestand te openen door op het tabblad “File” te klikken, “Open” te kiezen en je gedownloade notebook te selecteren.
Omgekeerd kun je ook je eigen notebooks opslaan door op hetzelfde tabblad “File” te klikken en “Download as” te selecteren om je eigen notebookbestand te verkrijgen, of je kunt ervoor kiezen om het bestand op te slaan en een checkpoint te zetten. Dit is handig wanneer je wat klein versiebeheer wilt doen en misschien wilt terugkeren naar een eerdere versie van je notebook. Uiteraard worden je wijzigingen automatisch elke paar minuten opgeslagen, dus het is niet altijd nodig dit expliciet te doen.
Let op: je kunt er ook voor kiezen om geen wijzigingen in een origineel notebook op te slaan door er een kopie van te maken en alle wijzigingen in die kopie te bewaren!
Sneltoetsen & multicursor-ondersteuning?
Meerdere cellen selecteren, de output van cellen toggelen, nieuwe cellen invoegen, enzovoort. Voor al deze acties heb je sneltoetsen die deel uitmaken van de Jupyter Notebook. Je vindt een lijst met sneltoetsen onder het menu bovenaan: ga naar het tabblad “Help” en selecteer “Keyboard Shortcuts”.
Ook de multicursor-ondersteuning is een functie die je in de Jupyter Notebook vindt!
Parallel computing-netwerk?
Het parallel computing-netwerk maakte deel uit van het IPython-project, maar sinds 4.0 is het een losstaand pakket genaamd ipyparallel. Het pakket is in feite een verzameling CLI-scripts voor het aansturen van clusters voor Jupyter.
Hoewel het is afgesplitst, is het nog steeds een krachtig onderdeel van het IPython-ecosysteem dat vaak over het hoofd wordt gezien; Het is zo krachtig omdat je in plaats van één Python-kernel er veel gedistribueerde kernels over meerdere machines kunt starten.
Typische use-cases voor ipyparallel zijn bijvoorbeeld situaties waarin je modellen vaak moet draaien om de verdelingen van de outputs te schatten of hoe ze variëren met inputparameters. Wanneer de runs van het model onafhankelijk zijn, kun je het proces versnellen door ze parallel te draaien over meerdere computers in een cluster. Denk aan gedistribueerde modeltraining of simulaties.
Terminal?
Deze functie is onderdeel van het Jupyter-ecosysteem: je hebt de Jupyter Console en een Jupyter-terminalapplicatie. Maar sinds het begin werd IPython gebruikt om te verwijzen naar de oorspronkelijke, interactieve command-line terminal voor Python. Die biedt een verbeterde read-eval-print loop (REPL)-omgeving, bijzonder geschikt voor wetenschappelijk rekenen. Dit was de standaard vóór 2011, toen de Notebook-tool werd geïntroduceerd en een moderne en krachtige webinterface voor Python begon te bieden.
Vervolgens had je ook de IPython-console, die twee processen startte: de oorspronkelijke IPython-terminalshell en het standaardprofiel of de kernel die wordt gestart als er niets anders is opgegeven. Standaard was dat Python. De IPython-console is nu verouderd en als je die wilt starten, moet je de Jupyter Console gebruiken, een terminalgebaseerde console-frontend voor Jupyter-kernels. Deze code is gebaseerd op de single-process IPython-terminal. De Jupyter Console biedt de interactieve client-side ervaring van IPython in de terminal, maar dan met de mogelijkheid om verbinding te maken met elke Jupyter-kernel in plaats van alleen met IPython. Hierdoor kun je elke Jupyter-kernel die je hebt geïnstalleerd vanaf de terminal testen, zonder een volledige Notebook te hoeven opstarten. De Console maakt consolegebaseerde interactie mogelijk met andere Jupyter-kernels zoals IJulia en IRKernel.
Tot slot heeft de Jupyter Notebook-applicatie ook een Terminal-applicatie: een eenvoudige bash-shellterminal die in je browser draait. Je vindt die gemakkelijk wanneer je de applicatie start en in het dropdownmenu een nieuwe terminal selecteert.
Qt-console?
De Qt-console maakte vroeger deel uit van het IPython-project, maar is nu overgeheveld naar het Jupyter-project. Het is een lichtgewicht applicatie die grotendeels aanvoelt als een terminal, maar een aantal verbeteringen biedt die alleen in een GUI mogelijk zijn, zoals inline-figuren, echte multi-line editing met syntax highlighting, grafische call tips en veel meer. De Qt-console kan elke Jupyter-kernel gebruiken.
Conclusie
De blogpost van vandaag bouwde voort op DataCamp’s Definitieve gids en besprak de geschiedenis van computationele notebooks in meer detail, samen met enkele van de belangrijkste functies van zowel IPython- als Jupyter-projecten, zodat je de evolutie en het verschil tussen de twee duidelijker kunt begrijpen. Het doel was te laten zien dat het onderscheid tussen beide soms lastig is als je het historische perspectief van de twee projecten niet meeneemt. In sommige gevallen is er een grijze zone, een “tussenin”, die niet eenvoudig te classificeren is.
