Jupyter - Guide rapide

Project Jupyter est une suite de produits logiciels utilisés en informatique interactive. IPython a été développé à l'origine par Fernando Perez en 2001 en tant qu'interpréteur Python amélioré. Une interface Web vers le terminal IPython sous la forme d'un notebook IPython a été introduite en 2011. En 2014, le projet Jupyter a démarré comme un projet dérivé d'IPython.

Les packages du projet Jupyter incluent -

Jupyter notebook - Une interface Web pour les environnements de programmation de Python, Julia, R et bien d'autres
QtConsole - Terminal basé sur Qt pour les noyaux Jupyter similaire à IPython
nbviewer - Possibilité de partager des notebooks Jupyter
JupyterLab - Interface Web intégrée moderne pour tous les produits.

La distribution standard de Python est fournie avec un REPL (Read-Evaluate-Print Loop) environnement sous forme de shell Python avec >>>rapide. IPython (signifie Interactive Python) est un environnement interactif amélioré pour Python avec de nombreuses fonctionnalités par rapport au shell Python standard.

Caractéristiques d'IPython

IPython offre plus de fonctionnalités que le Python standard. Ils sont les suivants -

Offre un puissant shell Python interactif.
Agit en tant que noyau principal pour le notebook Jupyter et d'autres outils frontaux du projet Jupyter.
Possède une capacité d'introspection d'objets. L'introspection est la capacité de vérifier les propriétés d'un objet pendant l'exécution.
Mise en évidence de la syntaxe.
Stocke l'historique des interactions.
Tabulation des mots-clés, des variables et des noms de fonctions.
Système de commande magique utile pour contrôler l'environnement Python et effectuer des tâches du système d'exploitation.
Possibilité d'être intégré dans d'autres programmes Python.
Fournit un accès au débogueur Python.

Histoire et développement

IPython a été développé à l'origine par Fernando Perez en 2001. Sa version actuelle est IPython7.0.1 qui nécessite la version Python 3.4 ou supérieure. IPython 6.0 a été la première version à prendre en charge Python 3. Les utilisateurs ayant Python 2.7 devraient travailler avec la version 2.0 à 5.7 d'IPython

Le concept de cahiers de calcul a commencé dans les années 80 lorsque MATLAB et Mathematica ont été publiés. Ces interfaces graphiques du shell interactif avaient des fonctionnalités telles que le formatage du texte, l'ajout de graphiques, de tableaux et l'ajout de symboles mathématiques. Le bloc-notes Sage est également un bloc-notes basé sur le Web.

Les créateurs d'IPython ont commencé à travailler sur l'interface notebook pour le shell IPython en 2005. Le notebook IPython a rapidement ajouté la prise en charge d'autres langages comme R et Julia. C'est en 2014 que Perez a lancé le projet Jupyter en tant que projet dérivé d'IPython, car le projet IPython devenait de plus en plus important avec des produits tels que le serveur de notebook et la console Qt ajoutés.

Depuis IPython 4.0, tous les composants supplémentaires ont été déplacés vers Project Jupyter et l'ajout de la prise en charge d'autres langages au notebook IPython. IPython continue de se concentrer sur l'amélioration de sa fonctionnalité d'interprétation améliorée. Il fournit également le noyau principal à l'interface du notebook Jupyter.

IPython est inclus par défaut dans la distribution Anaconda de Python. Il peut être téléchargé à partir de la page de téléchargement d'Anaconda www.anaconda.com/download/ Les binaires pour tous les principaux systèmes d'exploitation (Windows, MacOS et Linux) et l'architecture (32 bits et 64 bits) sont disponibles sur ce lien.

Pour installer IPython séparément dans l'installation standard de Python, vous pouvez utiliser la commande pip comme indiqué ci-dessous -

pip3 install ipython

IPython utilise en interne les packages suivants -

Sr.No.	Dépendances et fonctionnalités IPython
1	colorama API multiplateforme pour l'impression de texte de terminal coloré à partir de Python
2	jedi Un outil de saisie semi-automatique pour Python
3	pickleshare Petit magasin de données comme un magasin de données avec prise en charge de la concurrence
4	prompt_toolkit Bibliothèque pour créer de puissantes lignes de commande interactives en Python
5	pygments Paquet de coloration syntaxique écrit en Python
6	simplegeneric Fonctions génériques simples
sept	traitlets Système de configuration pour les applications Python.

En général, toutes les dépendances sont installées automatiquement. Sinon, vous pouvez les installer individuellement à l'aide de pip.

Ce chapitre explique comment commencer à travailler sur IPython.

Démarrage d'IPython à partir de l'invite de commande.

Avant de commencer à comprendre IPython en profondeur, notez qu'au lieu du >>>, vous remarquerez deux invites Python majeures comme expliqué ci-dessous -

In[1] apparaît avant toute expression d'entrée.
Out[1] apparaît avant que la sortie n'apparaisse.

De plus, les nombres entre crochets sont incrémentés automatiquement. Observez la capture d'écran suivante pour une meilleure compréhension -

Maintenant, si vous avez installé la distribution Anaconda de Python, ouvrez l'invite Anaconda à partir du menu Démarrer.

Démarrez IPython à partir de l'invite conda

Par rapport à la console Python classique, nous pouvons remarquer une différence. Le shell IPython montre la coloration syntaxique en utilisant différents schémas de couleurs pour différents éléments tels que l'expression, la fonction, la variable, etc.

Une autre amélioration utile est la complétion des onglets. Nous savons que chaque objet a une ou plusieurs méthodes disponibles telles que définies dans sa classe. IPython affiche la liste appropriée des méthodes lorsque vous appuyez sur la touche de tabulation après le point devant l'objet.

Dans l'exemple suivant, une chaîne est définie. En réponse, les méthodes de la classe string sont affichées.

IPython fournit des informations sur n'importe quel objet en mettant '?' devant lui. Il comprend la docstring, les définitions de fonction et les détails du constructeur de la classe. Par exemple, pour explorer l'objet string var défini ci-dessus, dans l'invite de saisie, entrezvar?. Le résultat affichera toutes les informations à ce sujet. Observez la capture d'écran ci-dessous pour une meilleure compréhension -

Fonctions magiques

Les fonctions magiques intégrées d'IPython sont extrêmement puissantes. Il existe deux types de fonctions magiques.

Line magics, qui fonctionnent très bien comme les commandes DOS.
Cell magics, qui fonctionnent sur plusieurs lignes de code.

Nous en apprendrons davantage sur les fonctions de magie des lignes et les fonctions de magie cellulaire dans les chapitres suivants.

Dans ce chapitre, voyons comment exécuter et éditer un script Python.

Exécuter la commande

Vous pouvez utiliser runcommande dans l'invite d'entrée pour exécuter un script Python. La commande run est en fait une commande magique de ligne et devrait en fait être écrite comme%run. Cependant, le%automagic le mode est toujours activé par défaut, vous pouvez donc l'omettre.

In [1]: run hello.py
Hello IPython

Modifier la commande

IPython fournit également la commande d'édition magique. Il appelle l'éditeur par défaut du système d'exploitation. Vous pouvez l'ouvrir via l'éditeur de bloc-notes Windows et le script peut être modifié. Une fois que vous le fermez après avoir enregistré son entrée, la sortie du script modifié sera affichée.

In [2]: edit hello.py
Editing... done. Executing edited code...
Hello IPython
welcome to interactive computing

Notez que hello.py ne contenait initialement qu'une seule instruction et après avoir modifié une autre instruction a été ajoutée. Si aucun nom de fichier n'est donné à la commande d'édition, un fichier temporaire est créé. Observez le code suivant qui montre la même chose.

In [7]: edit
IPython will make a temporary file named:
C:\Users\acer\AppData\Local\Temp\ipython_edit_4aa4vx8f\ipython_edit_t7i6s_er.py
Editing... done. Executing edited code...
magic of IPython
Out[7]: 'print ("magic of IPython")'

IPython préserve à la fois les commandes et leurs résultats de la session en cours. Nous pouvons faire défiler les commandes précédentes en appuyant sur les touches haut et bas.

En outre, les trois derniers objets de sortie sont stockés dans des variables spéciales _, __ et ___. lehistory La commande magique montre les commandes précédentes dans la session actuelle comme indiqué dans la capture d'écran ci-dessous -

Si l'instruction dans la cellule d'entrée commence par le symbole d'exclamation (!), Elle est traitée comme une commande système pour le système d'exploitation sous-jacent. Par exemple,!ls (pour linux) et !dir (pour Windows) affiche le contenu du répertoire courant

La sortie de la commande système peut également être affectée à une variable Python comme indiqué ci-dessous -

La variable stocke la sortie sans couleurs et se divise aux caractères de nouvelle ligne.

Il est également possible de combiner des variables ou des expressions Python avec des appels de commande système. La variable entre accolades {} peut être incorporée dans le texte de la commande. Observez l'exemple suivant -

Voici un autre exemple pour comprendre que le préfixage de la variable Python avec $ permet également d'obtenir le même résultat.

Dans ce chapitre, voyons comment travailler avec diverses options de ligne de commande dans IPython.

Appel du programme IPython

Vous pouvez appeler un programme IPython en utilisant les options suivantes -

C:\python36> ipython [subcommand] [options] [-c cmd | -m mod | file] [--] [arg]

L'option de fichier est un script Python avec l'extension .py. Si aucune autre option n'est donnée, le script est exécuté et l'invite de commande réapparaît.

C:\python36>ipython hello.py
Hello IPython
welcome to interactive computing

Sous-commandes et paramètres

Une commande IPython accepte les options de sous-commande suivantes -

Profile - Créez et gérez des profils IPython.
Kernel - Démarrez un noyau sans frontend attaché.
Locate - Imprimez le chemin vers le répertoire IPython.
History - Gérez la base de données d'historique IPython.

Une sous-commande de profil IPython accepte les paramètres suivants -

ipython profile create myprofile - Crée un nouveau profil.
ipython profile list - Répertorie tous les profils disponibles.
ipython locate profile myprofile - Localise le profil requis.

Pour installer un nouveau noyau IPython, utilisez la commande suivante -

Ipython kernel –install –name

Pour imprimer le chemin d'accès au répertoire IPython, utilisez la commande suivante -

C:\python36>ipython locate myprofile
C:\Users\acer\.ipython

De plus, nous savons que -

le history La sous-commande gère la base de données d'historique IPython.
le trim L'option réduit la base de données d'historique IPython aux 1000 dernières entrées.
le clear L'option supprime toutes les entrées.

Certaines des autres options de ligne de commande importantes d'IPython sont répertoriées ci-dessous -

Sr.No.	Commande et description IPython
1	--automagic Activez l'appel automatique des commandes magiques.
2	--pdb Activez l'appel automatique du débogueur pdb après chaque exception.
3	--pylab Pré-chargez matplotlib et numpy pour une utilisation interactive avec le backend matplotlib par défaut.
4	--matplotlib Configurez matplotlib pour une utilisation interactive avec le backend matplotlib par défaut.
5	--gui=options Activez l'intégration de la boucle d'événement de l'interface graphique avec l'un des éléments suivants ('glut', 'gtk', 'gtk2', 'gtk3', 'osx', 'pyglet', 'qt', 'qt4', 'qt5', 'tk', ' wx ',' gtk2 ',' qt4 ').

L'exemple d'utilisation de certaines des options de ligne de commande IPython est présenté dans le tableau suivant -

Sr.No.	Commande et description IPython
1	ipython --matplotlib activer l'intégration de matplotlib
2	ipython --matplotlib=qt activer l'intégration de matplotlib avec le backend qt4
3	ipython --profile=myprofile commencez par le profil foo
4	ipython profile create myprofile créer un profil foo avec les fichiers de configuration par défaut
5	ipython help profile afficher l'aide pour le sous-cmd de profil
6	ipython locate imprimer le chemin du répertoire IPython
sept	ipython locate profile myprofile affiche le chemin du répertoire du profil `myprofile`

IPython dispose de différentes manières d'obtenir des informations sur les objets Python de manière dynamique. Dans ce chapitre, apprenons les méthodes d'introspection dynamique d'objets dans IPython.

Utilisation de ? et ??fournit des informations spécifiques et plus détaillées sur l'objet. Dans le premier exemple présenté ci-dessous, un objet entier simple a est créé. Ses informations peuvent être obtenues en tapant un? dans la cellule d'entrée.

Dans le deuxième exemple, définissons une fonction et introspectons cet objet fonction avec ? et ??.

Notez que la fonction magique %psearch équivaut à l'utilisation de ? ou ?? pour récupérer les informations sur les objets.

Les cellules d'entrée et de sortie de la console IPython sont numérotées de manière incrémentielle. Dans ce chapitre, examinons en détail la mise en cache d'E / S en Python.

Dans IPython, les entrées sont récupérées à l'aide de la touche fléchée vers le haut. En outre, toutes les entrées précédentes sont enregistrées et peuvent être récupérées. Les variables_i, __i, et ___istockez toujours les trois entrées précédentes. En plus,In et _invariables fournit des listes de toutes les entrées. Évidemment_in[n]récupère l'entrée de la nième cellule d'entrée. La session IPython suivante vous aide à comprendre ce phénomène -

In [1]: print ("Hello")
Hello

In [2]: 2+2
Out[2]: 4

In [3]: x = 10

In [4]: y = 2

In [5]: pow(x,y)
Out[5]: 100

In [6]: _iii, _ii, _i
Out[6]: ('x = 10', 'y = 2', 'pow(x,y)')

In [7]: In
Out[7]:
['',
   'print ("Hello")',
   '2+2',
   'x = 10',
   'y = 2',
   'pow(x,y)',
   '_iii, _ii, _i',
   'In'
]
   
In [8]: In[5] 9. IPython — IO
Out[8]: 'pow(x,y)'

In [9]: _ih
Out[9]:
['',
   'print ("Hello")',
   '2+2',
   'x = 10',
   'y = 2',
   'pow(x,y)',
   '_iii, _ii, _i',
   'In',
   'In[5]',
   '_ih'
]
   
In [11]: _ih[4]
Out[11]: 'y = 2'

In [12]: In[1:4]
Out[12]: ['print ("Hello")', '2+2', 'x=10']

De même, les traits de soulignement simples, doubles et triples agissent comme des variables pour stocker les trois sorties précédentes. ÉgalementOut et _ohforment un objet dictionnaire du numéro de cellule et de la sortie des cellules exécutant une action (sans inclure les instructions d'affectation). Pour récupérer le contenu d'une cellule de sortie spécifique, utilisezOut[n] ou _oh[n]. Vous pouvez également utiliser le découpage pour obtenir des cellules de sortie dans une plage.

In [1]: print ("Hello")
Hello

In [2]: 2+2
Out[2]: 4

In [3]: x = 10

In [4]: y = 3

In [5]: pow(x,y)
Out[5]: 1000

In [6]: ___, __, _
Out[6]: ('', 4, 1000)

In [7]: Out
Out[7]: {2: 4, 5: 1000, 6: ('', 4, 1000)}

In [8]: _oh
Out[8]: {2: 4, 5: 1000, 6: ('', 4, 1000)}

In [9]: _5
Out[9]: 1000

In [10]: Out[6]
Out[10]: ('', 4, 1000)

Différentes variables d'environnement influencent le comportement de Python. La variable d'environnement PYTHONSTARTUP est affectée à un script Python. En conséquence, ce script est exécuté avant que l'invite Python n'apparaisse. Ceci est utile si certains modules doivent être chargés par défaut à chaque fois qu'une nouvelle session Python démarre.

Le script suivant (start.py) importe le module IPython et exécute la fonction start_ipython () pour remplacer le shell Python par défaut par l'invite (>>>) par le shell IPython lorsque l'exécutable Python est appelé.

import os, IPython
os.environ['PYTHONSTARTUP'] = ''
IPython.start_ipython()
raise SystemExit

En supposant que ce fichier est stocké dans le répertoire d'installation de Python (c: \ python36), définissez la variable d'environnement PYTHONSTARTUP et démarrez Python à partir de la ligne de commande. Ensuite, le shell IPython apparaît comme indiqué ci-dessous -

Notez que la variable d'environnement peut être définie de manière permanente à l'aide de la boîte de dialogue Propriétés système de Windows et de la commande d'exportation sous Linux.

IPython peut lire à partir de la console Python standard avec la valeur par défaut >>>invite et une autre session IPython. La capture d'écran suivante montre une boucle for écrite dans le shell Python standard -

Copiez le code (avec l'invite Python) et collez-le dans la cellule d'entrée IPython. IPython filtre intelligemment les invites d'entrée (>>> et ...) ou celles IPython (In [N]: et ... :)

De même, le code d'une session IPython peut être collé dans une autre. La première capture d'écran ci-dessous montre la définition de la fonction SayHello () dans une fenêtre IPython -

Maintenant, sélectionnons le code et collez-le dans un autre shell IPython et appelons la fonction SayHello ().

La fonction embed () du module IPython permet d'incorporer IPython dans l'espace de noms de vos codes Python. Vous pouvez ainsi tirer parti des fonctionnalités IPython telles que l'introspection d'objets et la complétion par tabulation, dans l'environnement Python par défaut.

Les objets Python présents dans l'espace de noms global avant l'incorporation, seront disponibles pour IPython.

Si de nouveaux objets sont formés dans IPython ou si des objets précédents sont modifiés, ils seront automatiquement disponibles dans l'environnement par défaut après avoir quitté IPython. Le shell IPython intégré ne change pas l'état du code ou des objets antérieurs.

Cependant, si IPython est intégré dans l'espace de noms local comme dans une fonction, les objets qu'il contient ne seront pas disponibles une fois qu'il sera fermé. Ici, nous avons défini une fonction add (). Dans add (), nous invoquons IPython et déclarons une variable. Si nous essayons d'accéder à la variable dans IPython après sa fermeture, l'exception NameError sera déclenchée.

Les commandes magiques ou les fonctions magiques sont l'une des améliorations importantes qu'offre IPython par rapport au shell Python standard. Ces commandes magiques sont destinées à résoudre des problèmes courants dans l'analyse de données à l'aide de Python. En fait, ils contrôlent le comportement d'IPython lui-même.

Les commandes magiques agissent comme des fonctions pratiques où la syntaxe Python n'est pas la plus naturelle. Ils sont utiles pour incorporer une syntaxe python invalide dans leur flux de travail.

Types de commandes magiques

Il existe deux types de commandes magiques -

Magie de ligne
Magie cellulaire

Magie de ligne

Ils sont similaires aux appels de ligne de commande. Ils commencent par% character. Le reste de la ligne est son argument passé sans parenthèses ni guillemets. La magie des lignes peut être utilisée comme expression et leur valeur de retour peut être affectée à une variable.

Magie cellulaire

Ils ont le préfixe de caractère %%. Contrairement aux fonctions de magie de ligne, ils peuvent fonctionner sur plusieurs lignes en dessous de leur appel. Ils peuvent en fait apporter des modifications arbitraires à l'entrée qu'ils reçoivent, qui n'ont même pas besoin d'être un code Python valide. Ils reçoivent le bloc entier comme une seule chaîne.

Pour en savoir plus sur les fonctions magiques, les magies intégrées et leurs docstrings, utilisez la commande magic. L'information d'une fonction magique spécifique est obtenue par%magicfunction?Commander. Décrivons maintenant certaines des commandes de magie de ligne et de cellule intégrées.

Magies en ligne intégrées

%autocall [mode]

Cette fonction magique rend une fonction automatiquement appelable sans avoir à utiliser de parenthèses. Il faut trois paramètres de mode possibles:0 (off), 1 (smart) is default ou 2 (always on).

% automagique

Les fonctions magiques peuvent être appelées sans avoir à taper le% initial si elles sont définies sur 1. Sans arguments, elles sont activées / désactivées. Pour désactiver, réglez sur 0.

L'exemple suivant montre une fonction magique %pwd (affiche le répertoire de travail actuel) appelé sans% de début lorsque% automagic est défini sur 1

%CD

Cette magie de ligne change le répertoire courant. Cette commande maintient automatiquement une liste interne des répertoires que vous visitez pendant votre session IPython, dans la variable _dh. Vous pouvez également faire 'cd - <tab>' pour voir l'historique des répertoires de manière pratique.

Usage

La commande% cd peut être utilisée des manières suivantes -

%cd <dir> - Change le répertoire de travail actuel en <dir>
%cd.. - Change le répertoire actuel en répertoire parent
%cd - passe au dernier répertoire visité.

% dhist

Cette commande magique imprime tous les répertoires que vous avez visités dans la session en cours. Chaque fois que la commande% cd est utilisée, cette liste est mise à jour dans_dh variable.

%Éditer

Cette commande magique fait appel à l'éditeur de texte par défaut du système d'exploitation actuel (Bloc-notes pour Windows) pour éditer un script Python. Le script est exécuté à la fermeture de l'éditeur.

% env

Cette commande magique listera toutes les variables d'environnement. Il lit également la valeur d'une variable particulière ou définit la valeur de la variable d'environnement.

Usage

La commande% cd peut être utilisée des manières suivantes -

%env - Répertorie toutes les variables d'environnement
%env var - Obtient la valeur de var
%env var val - Définit la valeur de var

% gui [GUINAME]

Lorsqu'elle est utilisée sans argument, cette commande active ou désactive l'intégration de la boucle d'événements de l'interface graphique IPython. Avec l'argument GUINAME, cette magie remplace les toolkits GUI par défaut par celui spécifié.

Sr.No.	Commande et description
1	%gui wx activer l'intégration de la boucle d'événements wxPython
2	%gui qt4\|qt activer l'intégration de la boucle d'événements PyQt4
3	%gui qt5 activer l'intégration de la boucle d'événements PyQt5
4	%gui gtk activer l'intégration de la boucle d'événements PyGTK
5	%gui gtk3 activer l'intégration de la boucle d'événements Gtk3
6	%gui tk activer l'intégration de la boucle d'événements Tk
sept	%gui osx activer l'intégration de la boucle d'événements Cocoa
8	(nécessite% matplotlib 1.1)
9	%gui désactiver toute l'intégration de la boucle d'événements

% lsmagic

Affiche toutes les fonctions magiques actuellement disponibles

% matplotlib

Cette fonction active la prise en charge interactive de matplotlib lors d'une session IPython. Cependant, il n'importe pas la bibliothèque matplotlib. La boîte à outils GUI par défaut de matplotlib est TkAgg. Mais vous pouvez demander explicitement un backend GUI différent. Vous pouvez voir une liste des backends disponibles comme indiqué -

In [4]: %matplotlib --list
Available matplotlib backends: 
['osx', 'qt4', 'qt5', 'gtk3', 'notebook', 'wx', 'qt', 'nbagg','gtk', 'tk', 'inline']

La session IPython présentée ici trace une onde sinusoïdale en utilisant qt boîte à outils -

Lors de l'utilisation du notebook Jupyter, la directive en ligne% matplotlib affiche la sortie du tracé dans le navigateur uniquement.

%carnet

Cette fonction convertit l'historique IPython actuel en un fichier notebook IPython avec l'extension ipynb. Les cellules d'entrée de l'exemple précédent sont enregistrées sous le nom sine.ipynb

%notebook sine.ipynb

% pinfo

Cette fonction est similaire à l'introspection d'objets? personnage. Pour obtenir des informations sur un objet, utilisez la commande suivante -

%pinfo object

Ceci est synonyme de object? ou ?object.

%précision

Cette fonction magique limite un résultat en virgule flottante aux chiffres spécifiés après la virgule décimale.

% pwd

Cette fonction magique renvoie le répertoire de travail actuel.

% pylab

Cette fonction remplit la session IPython actuelle avec les bibliothèques matplotlib et numpy.

%rappel

Lorsqu'elle est exécutée sans aucun paramètre, cette fonction exécute la commande précédente.

Notez que dans %recall n, le numéro devant lui est le numéro de cellule d'entrée. Par conséquent, la commande dans la nième cellule est rappelée. Vous pouvez rappeler des commandes dans une section de cellules en utilisant une commande telle que%recall 1-4. La cellule d'entrée actuelle est remplie avec la cellule rappelée et le curseur clignote jusqu'à ce que la touche Entrée soit enfoncée.

%courir

Cette commande exécute un script Python à partir du shell IPython.

%temps

Cette commande affiche le temps requis par l'environnement IPython pour exécuter une expression Python.

% timeit

Cette fonction affiche également le temps requis par l'environnement IPython pour exécuter une expression Python. L'exécution temporelle d'une instruction ou d'une expression Python utilise le module timeit. Cette fonction peut être utilisée à la fois comme une magie de ligne et de cellule comme expliqué ici -

Dans line mode vous pouvez chronométrer une seule ligne.
Dans cell mode, l'instruction de la première ligne est utilisée comme code de configuration et le corps de la cellule est chronométré. Le corps de la cellule a accès à toutes les variables créées dans le code de configuration.

%qui

Cette magie de ligne imprime toutes les variables interactives, avec un formatage minimal. Si des arguments sont donnés, seules les variables dont le type correspond à l'un d'entre eux sont affichées.

Fonction IPython Custom Line Magic

La bibliothèque principale d'IPython contient le décorateur register_line_magic. Une fonction définie par l'utilisateur est convertie en une fonction magique de ligne à l'aide de ce décorateur.

Le projet Jupyter a débuté en tant que spin-off du projet IPython en 2014. Les fonctionnalités indépendantes du langage d'IPython ont été déplacées sous le nom de Jupyter. Le nom fait référence aux principaux langages de programmation pris en charge par Jupyter, à savoir Julia, Python et RProducts sous le projet Jupyter, destinés à prendre en charge la science des données interactive et le calcul scientifique.

Le projet Jupyter se compose de divers produits décrits sous -

IPykernel - Ceci est un package qui fournit le noyau IPython à Jupyter.
Jupyter client- Ce package contient l'implémentation de référence du protocole Jupyter. C'est également une bibliothèque cliente pour démarrer, gérer et communiquer avec les noyaux Jupyter.
Jupyter notebook- C'était auparavant connu sous le nom de notebook IPython. Il s'agit d'une interface Web vers le noyau IPython et les noyaux de nombreux autres langages de programmation.
Jupyter kernels - Kernel est l'environnement d'exécution d'un langage de programmation pour les produits Jupyter.

La liste des noyaux Jupyter est donnée ci-dessous -

Noyau	Langue	URL
IJulia	Julia	https://github.com/JuliaLang
IHaskell	Haskell	https://github.com/gibiansky
IRuby	Rubis	https://github.com/SciRuby/iruby
IJavaScript	JavaScript	https://github.com/n-riesco
IPHP	PHP	https://github.com/dawehner
IRKernel	R	http://irkernel.github.io/

Qtconsole - Une riche console basée sur Qt pour travailler avec les noyaux Jupyter
nbconvert - Convertit les fichiers de notebook Jupyter dans d'autres formats
JupyterLab - Interface Web intégrée pour ordinateurs portables, éditeurs, consoles, etc.
nbviewer - Visionneuse HTML pour les fichiers notebook

Le bloc-notes IPython a été développé par Fernando Perez en tant qu'interface Web du noyau IPython. Afin de créer un environnement informatique interactif intégré pour plusieurs langues, le projet Notebook a été déplacé sous le projet Jupyter, fournissant une interface pour les environnements de programmation Juila et R en plus de Python.

Un document de bloc-notes se compose d'éléments de texte enrichi avec du texte au format HTML, des figures, des équations mathématiques, etc. Le bloc-notes est également un document exécutable constitué de blocs de code en Python ou dans d'autres langages de support.

Jupyter notebook est une application client-serveur. L'application démarre le serveur sur la machine locale et ouvre l'interface du notebook dans le navigateur Web à partir duquel elle peut être modifiée et exécutée. Le notebook est enregistré sous forme de fichier ipynb et peut être exporté sous forme de fichiers html, pdf et LaTex.

Si vous ne connaissez pas Jupyter, vous pouvez essayer les fonctionnalités du notebook Jupyter avant de l'installer sur votre ordinateur local. A cet effet, visitezhttps://jupyter.org dans votre navigateur et choisissez ‘Try Jupyter with Python’ option.

Cela ouvrira la page d'accueil de https://mybinder.orgDans le menu Fichier, choisissez une nouvelle option de bloc-notes pour ouvrir un Jupyter vide dans votre navigateur. La cellule d'entrée, similaire à celle du terminal IPython, sera affichée. Vous pouvez y exécuter n'importe quelle expression Python.

Vous pouvez facilement installer l'application Jupyter notebook à l'aide du gestionnaire de packages pip.

pip3 install jupyter

Pour démarrer l'application, utilisez la commande suivante dans la fenêtre d'invite de commande.

c:\python36>jupyter notebook

L'application serveur démarre avec le numéro de port par défaut 8888 et la fenêtre du navigateur s'ouvre pour afficher le tableau de bord du notebook.

Observez que le tableau de bord affiche une liste déroulante près de la bordure droite du navigateur avec une flèche à côté du bouton Nouveau. Il contient les noyaux de notebook actuellement disponibles. Maintenant, choisissez Python 3, puis un nouveau bloc-notes s'ouvre dans un nouvel onglet. Une cellule d'entrée similaire à celle de la console IPython s'affiche.

Vous pouvez y exécuter n'importe quelle expression Python. Le résultat sera affiché dans la cellule Out.

Le tableau de bord de Jupyter Notebook contient trois onglets comme indiqué dans la capture d'écran ci-dessous -

Onglet Fichiers

L'onglet "Fichiers" affiche les fichiers et les dossiers du répertoire actuel à partir duquel l'application notebook a été appelée. La ligne correspondant à un notebook actuellement ouvert et son état de fonctionnement est affiché juste à côté de la dernière colonne modifiée. Il affiche également le bouton Télécharger à l'aide duquel un fichier peut être téléchargé sur le serveur notebook.

Onglet Exécution

L'onglet "En cours d'exécution" montre quels notebooks sont actuellement en cours d'exécution.

Onglet Cluster

Le troisième onglet, "Clusters", est fourni par IPython parallel. Le cadre de calcul parallèle d'IPython, une version étendue du noyau IPython.

Dans la liste déroulante Nouveau, choisissez Terminal pour ouvrir une fenêtre cmd. Vous pouvez maintenant démarrer un terminal IPython ici.

Dans l'interface utilisateur de Jupyter, juste à côté du logo dans l'en-tête, le nom du fichier est affiché.

Vous pouvez trouver la barre de menu sous l'en-tête. Chaque menu contient de nombreuses options qui seront discutées plus tard.

Une rangée d'icônes formant la barre d'outils aide l'utilisateur à effectuer des opérations souvent requises

L'ordinateur portable a deux modes - Command mode et Edit mode. Le bloc-notes entre en mode édition lorsque l'utilisateur clique sur une cellule. Notez le symbole du crayon juste à côté du nom du noyau.

Le symbole de l'indicateur de noyau est affiché juste à droite du nom du noyau. Notez qu'un cercle creux signifie que le noyau est inactif et un cercle plein signifie qu'il est occupé.

Menu Fichier

Voici les options disponibles dans le menu Fichier -

Sr.No.	Menu fichier et description
1	New notebook choisissez le noyau pour démarrer un nouveau notebook
2	Open Amène l'utilisateur au tableau de bord pour choisir le bloc-notes à ouvrir
3	Save as enregistrer le bloc-notes actuel et démarrer un nouveau noyau
4	Rename renommer le bloc-notes actuel
5	Save enregistre le bloc-notes actuel et stocke le point de contrôle actuel
6	Revert rétablit l'état du notebook au point de contrôle antérieur
sept	Download exporter le notebook dans l'un des différents formats de fichier

Les formats de fichiers disponibles sont indiqués ci-dessous -

Modifier le menu

Le menu Edition se compose de boutons permettant de couper, copier et coller des cellules, supprimer la cellule sélectionnée, diviser et fusionner des cellules, déplacer des cellules de haut en bas, rechercher et remplacer dans le cahier, couper / copier des pièces jointes et insérer une image.

Afficher le menu

Les boutons de ce menu nous aident à masquer / afficher l'en-tête, la barre d'outils et les numéros de cellule.

Insérer un menu

Ce menu vous propose des options pour insérer une cellule avant ou après la cellule actuelle.

Menu de la cellule

Les options de ce menu permettent à l'utilisateur d'exécuter toutes ou des cellules spécifiques du bloc-notes. Vous pouvez également définir le type de cellule sur le type de code, le markdown ou le type nbconvert brut.

Menu du noyau

À partir de ce menu, vous pouvez démarrer, interrompre, redémarrer ou arrêter le noyau. Vous pouvez également démarrer un nouveau noyau.

Menu des widgets

À partir de ce menu, vous pouvez enregistrer, effacer, télécharger ou intégrer l'état du widget.

Menu d'aide

Différents raccourcis clavier prédéfinis sont affichés à partir de ce menu. Vous pouvez également modifier les raccourcis selon votre convenance.

Les cellules du notebook Jupyter sont de trois types: Code, Markdown et Raw.

Cellules de code

Le contenu de cette cellule est traité comme des instructions dans un langage de programmation du noyau actuel. Le noyau par défaut est Python. Ainsi, nous pouvons écrire des instructions Python dans une cellule de code. Lorsqu'une telle cellule est exécutée, son résultat est affiché dans une cellule de sortie. La sortie peut être du texte, des images, des tracés matplotlib ou des tableaux HTML. Les cellules de code ont une capacité de texte enrichi.

Cellules Markdown

Ces cellules contiennent du texte formaté à l'aide du langage de démarquage. Toutes sortes de fonctionnalités de formatage sont disponibles comme rendre le texte en gras et en italique, afficher une liste ordonnée ou non, rendre le contenu tabulaire, etc. Les cellules Markdown sont particulièrement utiles pour fournir de la documentation sur le processus de calcul du notebook.

Cellules brutes

Le contenu des cellules brutes n'est pas évalué par le noyau du notebook. Une fois passés par nbconvert, ils seront rendus comme vous le souhaitez. Si vous tapez LatEx dans une cellule brute, le rendu aura lieu après l'application de nbconvert.

Alors que la barre de menus et la barre d'outils vous permettent d'effectuer diverses opérations sur le notebook, il est souhaitable de pouvoir utiliser les raccourcis clavier pour les effectuer rapidement.

Les notebooks Jupyter ont deux modes de saisie clavier différents -

Command Mode- Lie le clavier aux actions au niveau du notebook. Indiqué par une bordure de cellule grise avec une marge gauche bleue.
Edit Mode- Lorsque vous tapez dans une cellule. Indiqué par une bordure de cellule verte.

Mode de commande (appuyez sur Echap pour activer)

F	trouver et remplacer	1	changer la cellule en titre 1
Ctrl-Shift-F	ouvrir la palette de commandes	2	changer la cellule en titre 2
Ctrl-Shift-P	ouvrir la palette de commandes	3	changer la cellule en titre 3
Enter	entrer en mode édition	4	changer la cellule en titre 4
P	ouvrir la palette de commandes	5	changer la cellule en titre 5
Shift-Enter	exécuter la cellule, sélectionnez ci-dessous	6	changer la cellule en titre 6
Ctrl-Enter	exécuter les cellules sélectionnées	A	insérer une cellule au-dessus
Alt-Enter	exécuter la cellule et insérer ci-dessous	B	insérer la cellule ci-dessous
Y	changer la cellule en code	X	couper les cellules sélectionnées
M	changer la cellule en démarque	C	copier les cellules sélectionnées
R	changer la cellule en brut	V	coller les cellules ci-dessous
K	sélectionnez la cellule ci-dessus	Z	annuler la suppression de la cellule
Up	sélectionnez la cellule ci-dessus	D,D	supprimer les cellules sélectionnées
Down	sélectionnez la cellule ci-dessous	Shift-M	fusionner les cellules sélectionnées ou la cellule actuelle avec la cellule ci-dessous si une seule cellule est sélectionnée
J	sélectionnez la cellule ci-dessous	Shift-V	coller les cellules ci-dessus
Shift-K	étendre les cellules sélectionnées ci-dessus	L	basculer les numéros de ligne
Shift-Up	étendre les cellules sélectionnées ci-dessus	O	basculer la sortie des cellules sélectionnées
Shift-Down	étendre les cellules sélectionnées ci-dessous	Shift-O	basculer le défilement de sortie des cellules sélectionnées
Shift-J	étendre les cellules sélectionnées ci-dessous	I,I	interrompre le noyau
Ctrl-S	Enregistrer et vérifier le point	0,0	redémarrer le noyau (avec dialogue)
S	Enregistrer et vérifier le point	Esc	ferme le téléavertisseur
Shift-L	bascule les numéros de ligne dans toutes les cellules et conserve le paramètre	Q	ferme le téléavertisseur
Shift-Space	faire défiler le carnet vers le haut	Space	faire défiler le carnet vers le bas

Mode d'édition (appuyez sur Entrée pour activer)

Tab	complétion ou retrait de code	Ctrl-Home	aller au début de la cellule
Shift-Tab	info-bulle	Ctrl-Up	aller au début de la cellule
Ctrl-]	retrait	Ctrl-End	aller à la fin de la cellule
Ctrl-[	dévoué	Ctrl-Down	aller à la fin de la cellule
Ctrl-A	tout sélectionner	Ctrl-Left	aller un mot à gauche
Ctrl-Z	annuler	Ctrl-Right	allez un mot à droite
Ctrl-/	commentaire	Ctrl-M	entrer en mode commande
Ctrl-D	supprimer toute la ligne	Ctrl-Shift-F	ouvrir la palette de commandes
Ctrl-U	annuler la sélection	Ctrl-Shift-P	ouvrir la palette de commandes
Insert	basculer l'indicateur d'écrasement	Esc	entrer en mode commande
Ctrl-Backspace	supprimer le mot avant	Ctrl-Y	refaire
Ctrl-Delete	supprimer le mot après	Alt-U	refaire la sélection
Shift-Enter	exécuter la cellule, sélectionnez ci-dessous	Ctrl-Shift-Minus	diviser la cellule au niveau du curseur
Ctrl-Enter	exécuter les cellules sélectionnées	Down	déplacer le curseur vers le bas
Alt-Enter	exécuter la cellule et insérer ci-dessous	Up	déplacer le curseur vers le haut
Ctrl-S	Enregistrer et vérifier le point

La cellule Markdown affiche le texte qui peut être formaté à l'aide du langage Markdown. Afin de saisir un texte qui ne doit pas être traité comme du code par le serveur Notebook, il doit d'abord être converti en tant que cellule de démarquage à partir du menu de la cellule ou à l'aide du raccourci clavier M en mode commande. L'invite In [] avant la cellule disparaît.

Cellule d'en-tête

Une cellule de démarquage peut afficher un texte d'en-tête de 6 tailles, similaire aux en-têtes HTML. Commencez le texte dans la cellule de démarquage par le symbole #. Utilisez autant de symboles # correspondant au niveau d'en-tête que vous le souhaitez. Cela signifie qu'un seul # rendra la plus grande ligne d'en-tête et que six symboles # rendront l'en-tête de la plus petite taille de police. Le rendu aura lieu lorsque vous exécuterez la cellule à partir du menu de la cellule ou du bouton d'exécution de la barre d'outils.

La capture d'écran suivante montre des cellules de démarque en mode d'édition avec des en-têtes de trois niveaux différents.

Lorsque les cellules sont exécutées, la sortie est la suivante -

Notez que le démarquage du notebook Jupyter ne prend pas en charge la fonctionnalité WYSWYG. L'effet du formatage ne sera rendu qu'après l'exécution de la cellule de démarque.

Listes ordonnées

Pour rendre une liste numérotée comme le fait la balise <ol> de HTML, le premier élément de la liste doit être numéroté comme 1. Les éléments suivants peuvent recevoir n'importe quel nombre. Il sera rendu en série lorsque la cellule de démarque est exécutée. Pour afficher une liste en retrait, appuyez sur la touche de tabulation et démarrez le premier élément de chaque sous-liste avec 1.

Si vous donnez les données suivantes pour la démarque -

Il affichera la liste suivante -

Listes à puces

Chaque élément de la liste affichera un cercle plein s'il commence par le symbole - où le symbole carré plein sera affiché si la liste commence par le symbole *. L'exemple suivant explique cette fonctionnalité -

Le démarque rendu apparaît comme ci-dessous -

Hyperliens

Le texte de démarque commençant par http ou https rend automatiquement le lien hypertexte. Pour attacher un lien à du texte, placez le texte entre crochets [] et le lien entre parenthèses (), en incluant éventuellement le texte en survol. La capture d'écran suivante expliquera cela.

Le démarque rendu apparaît comme indiqué ci-dessous -

Gras et italique

Pour afficher un texte en gras, placez-le entre deux traits de soulignement ou deux astérisques. Pour l'afficher en italique, placez-le entre des traits de soulignement simples ou des astérisques simples.

Le résultat est comme indiqué ci-dessous -

Images

Pour afficher l'image dans une cellule de démarquage, choisissez l'option «Insérer une image» dans le menu Édition et recherchez le fichier image souhaité. La cellule markdown montre sa syntaxe comme suit -

L'image sera rendue sur le cahier comme indiqué ci-dessous -

Table

Dans une cellule de démarquage, un tableau peut être construit en utilisant | (symbole de tuyau) et - (tiret) pour marquer les colonnes et les lignes. Notez que les symboles n'ont pas besoin d'être exactement alignés lors de la saisie. Il ne doit remplacer que les bordures de colonne et de ligne. Notebook se redimensionnera automatiquement en fonction du contenu. Un tableau est construit comme indiqué ci-dessous -

La table de sortie sera rendue comme indiqué ci-dessous -

Dans ce chapitre, laissez-nous comprendre les fonctions de la magie cellulaire et leurs fonctionnalités.

%% html

Cette fonction magique de cellule rend le contenu de la cellule de code sous forme de script html.

%% js ou %% javascript

Vous pouvez intégrer du code javascript dans la cellule du notebook Jupyter à l'aide de cette commande cell magic.

%% writefile

Le contenu de la cellule de code est écrit dans un fichier à l'aide de cette commande.

Le noyau IPython du notebook Jupyter est capable d'afficher des tracés de code dans les cellules d'entrée. Cela fonctionne parfaitement avecmatplotlibbibliothèque. L'option en ligne avec le%matplotlib La fonction magique rend la cellule de tracé même si show()la fonction de l'objet de tracé n'est pas appelée. leshow() La fonction provoque l'affichage du chiffre ci-dessous dans la cellule [] sans sortir [] avec un numéro.

Maintenant, ajoutez plt.show() à la fin et exécutez à nouveau la cellule pour voir la différence.

Notez que la magie du notebook% matplotlib rend le tracé interactif.

Juste en dessous de la figure, vous pouvez trouver une barre d'outils pour changer de vue, de panoramique, de zoom et de téléchargement.

Il est important de noter que si vous modifiez les données sous le tracé, l'affichage change de manière dynamique sans dessiner un autre tracé.

Dans l'exemple ci-dessus, modifiez les ensembles de données de x et y dans la cellule ci-dessous et tracez à nouveau la figure, la figure ci-dessus sera actualisée dynamiquement.

Les fichiers de notebook Jupyter ont .ipynbextension. Le bloc-notes est rendu dans le navigateur Web par l'application bloc-notes. Il peut être exporté vers différents formats de fichiers en utilisant le téléchargement comme option dans le menu Fichier. Jupyter dispose également d'une interface de ligne de commande sous la forme denbconvertoption. Par défaut, nbconvert exporte le bloc-notes au format HTML. Vous pouvez utiliser la commande suivante à cet effet -

jupyter nbconvert mynotebook.ipynb

Cela convertira mynotebook.ipynb à la mynotebook.html. L'autre format d'exportation est spécifié avec`--to` clause.

Notez que les autres options incluent ['asciidoc', 'custom', 'html', 'latex', 'markdown', 'notebook', 'pdf', 'python', 'rst', 'script', 'slides']

HTML comprend des modèles «basiques» et «complets». Vous pouvez spécifier cela dans la ligne de commande comme indiqué ci-dessous -

jupyter nbconvert --to html --template basic mynotebook.ipynb

LaTex est un format de préparation de document utilisé spécialement dans la composition scientifique. Jupyter comprend des modèles «base», «article» et «rapport».

jupyter nbconvert --to latex –template report mynotebook.ipynb

Pour générer un PDF via latex, utilisez la commande suivante -

jupyter nbconvert mynotebook.ipynb --to pdf

Le bloc-notes peut être exporté vers un diaporama HTML. La conversion utilise Reveal.js en arrière-plan. Pour servir les diapositives par un serveur HTTP, ajoutez --postserve sur la ligne de commande. Pour créer des diapositives qui ne nécessitent pas de connexion Internet, placez simplement la bibliothèque Reveal.js dans le même répertoire oùyour_talk.slides.html est situé.

jupyter nbconvert myslides.ipynb --to slides --post serve

L'option markdown convertit le notebook en une simple sortie markdown. Les cellules Markdown ne sont pas affectées et les cellules de code sont indentées de 4 espaces.

--to markdown

Vous pouvez utiliser rstoption pour convertir le notebook en sortie de base reStructuredText. Il est utile comme point de départ pour incorporer des blocs-notes dans des documents Sphinx.

--to rst

C'est le moyen le plus simple d'obtenir un script Python (ou un autre langage, selon le noyau) d'un notebook.

--to script

IPyWidgets est une bibliothèque Python de widgets interactifs HTML pour le notebook Jupyter. Chaque élément d'interface utilisateur de la bibliothèque peut répondre aux événements et invoque des fonctions de gestionnaire d'événements spécifiées. Ils améliorent la fonctionnalité interactive de l'application Jupyter notebook.

Afin d'incorporer des widgets dans le notebook, nous devons importer le module suivant comme indiqué ci-dessous -

from ipywidgets import widgets

Quelques IPyWidgets de base sont expliqués ici -

Saisie de texte

le widgets.text()La fonction rend les widgets dans le bloc-notes. Il est similaire à l'élément de formulaire de zone de texte en HTML. L'objet de ce widget aon_submit() méthode qui écoute l'activité du champ de texte et peut invoquer le gestionnaire d'événements qui lui est donné comme argument.

Bouton

Ce widget est similaire au bouton HTML. Lorsqu'il est cliqué, l'événement est enregistré paron_click() méthode qui appelle le gestionnaire d'événements click.

IntSlider

Un contrôle de curseur qui affiche les valeurs entières incrémentées. Il existe également un FloatSlider et un IntRangeSlider (changement d'entier entre une plage)

Étiquette

Ce widget est utile pour afficher du texte non modifiable dans le notebook.

afficher()

Cette fonction de ipywidgets module rend l'objet widget dans la cellule d'entrée du notebook.

Interagir

Cette fonction rend automatiquement un widget en fonction du type d'argument de données qui lui est donné. Le premier argument de cette fonction est le gestionnaire d'événements et le second est une valeur transmise au gestionnaire d'événements lui-même.

L'exemple suivant montre trois widgets d'étiquette, deux widgets de texte et un bouton avec la légende «ajouter». Lorsque vous cliquez sur le bouton, la somme des nombres dans deux champs de saisie de texte est affichée sur l'étiquette la plus basse.

Dans ce chapitre, voyons comment démarrer avec QtConsole. Ce chapitre vous donnera un aperçu de ce logiciel et explique ses étapes d'installation.

Aperçu

La console Qt est une application graphique similaire au terminal IPython. Cependant, il fournit un certain nombre d'améliorations qui ne sont pas disponibles dans le terminal IPython basé sur du texte. Les fonctionnalités améliorées sont les figures en ligne, l'édition multiligne avec coloration syntaxique, les astuces graphiques, etc. La console Qt peut utiliser n'importe quel noyau Jupyter, le noyau par défaut étant IPython.

Installation

Jupyter QtConsole fait partie du projet Jupyter. La distribution Anaconda contient déjà une application QTconsole. Afin de l'installer individuellement, utilisez la commande pip comme indiqué ci-dessous -

pip3 install qtconsole

Vous pouvez également utiliser la commande conda à cet effet -

conda install qtconsole

Vous pouvez démarrer la console Jupyter à partir du navigateur Anaconda. Pour le démarrer à partir de la ligne de commande, vous devez utiliser la commande suivante, à partir de l'invite de commande Windows ou de l'invite Anaconda -

jupyter qtonsole

Vous obtenez un terminal similaire au terminal IPython avec la première invite In []. Vous pouvez maintenant exécuter n'importe quelle expression Python exactement comme nous le faisons dans le terminal IPython ou le notebook Jupyter

L'édition multiligne est l'une des fonctionnalités qui n'est pas disponible dans le terminal IPython. Pour entrer plus d'une instruction dans une seule cellule d'entrée, appuyez surctrl+enteraprès la première ligne. Par la suite, il suffit d'appuyer sur Entrée pour ajouter une nouvelle ligne dans la même cellule. Pour arrêter la saisie de nouvelles lignes et l'exécution de la cellule, appuyez une fois de plus sur la touche Entrée à la fin. La cellule fonctionnera et la sortie sera affichée dans la prochaine cellule [].

Une autre amélioration importante offerte par QtConsole est la possibilité d'afficher des graphiques en ligne, en particulier des tracés. La fonctionnalité fonctionne bien avec Matplotlib ainsi qu'avec d'autres bibliothèques de traçage.

Cette option pour enregistrer la sortie de QtConsole sous forme de fichier HTML est disponible dans le menu Fichier. Vous pouvez choisir de créer un fichier avec une image en ligne ou la figure tracée en tant que fichier png externe dans un dossier adjacent (nommé qt_files).

Vous pouvez ouvrir plusieurs onglets dans l'application console Jupyter. Trois options du menu Fichier sont fournies à cet effet.

New Tab with New kernel - Vous pouvez charger un nouveau noyau avec ce menu de fichiers.
New Tab with Existing kernel - En utilisant cette option, vous pouvez choisir parmi des noyaux supplémentaires en dehors du noyau IPython.
New Tab with Same Kernel- Cela crée un esclave du noyau chargé sur un onglet particulier. En conséquence, l'objet initialisé sur l'onglet maître sera accessible dans l'esclave et vice versa.

Une commande magique% qtconsole est disponible pour une utilisation avec le notebook Jupyter. Cela invoque la QtConsole en tant que terminal esclave du frontend du notebook. En conséquence, les données entre le notebook et le terminal Qtconsole peuvent être partagées.

Vous pouvez voir que la variable dans notebook est accessible dans qtconsolela fenêtre. En outre, une nouvelle variable dans Qtconsole est utilisée dans notebook.

Observez que les cellules d'entrée et de sortie sont numérotées de manière incrémentielle entre les deux.

Sharing Jupyter notebook – Using github and nbviewer

Fichiers Jupyter Notebook avec .ipynbL'extension dans un référentiel GitHub sera rendue sous forme de fichiers HTML statiques lors de leur ouverture. Les fonctionnalités interactives du bloc-notes, telles que les tracés JavaScript personnalisés, ne fonctionneront pas dans votre référentiel sur GitHub.

Pour partager un fichier notebook à l'aide de github, connectez-vous à https://github.comet créer un référentiel public. Ensuite, téléchargez vos fichiers en utilisant le bouton de téléchargement de fichier comme indiqué ci-dessous -

Cela vous donnera la possibilité de valider les modifications apportées au référentiel. Ensuite, le référentiel affichera le fichier téléchargé comme ci-dessous -

Cliquez sur le fichier téléchargé pour l'afficher dans la visionneuse github. Vous pouvez partager l'URL en surbrillance avec d'autres.

Une autre façon d'afficher le fichier de bloc-notes en ligne consiste à utiliser l'utilitaire nbviewer de Project Jupyter. Ouverthttps://nbviewer.jupyter.org/et placez l'URL du fichier dans votre référentiel dans le champ de texte comme indiqué. Appuyez sur le bouton Go pour afficher le bloc-notes.

Ces deux méthodes affichent le fichier notebook au format HTML statique. Pour pouvoir exécuter du code dans le notebook, ouvrez-le à l'aide de l'application Binder du projet Jupyter.

Dans la fenêtre nbviewer, vous verrez le bouton «Exécuter sur le classeur». Cliquez dessus et vous verrez le fichier notebook ouvert exactement comme vous l'ouvrez à partir du tableau de bord local du serveur notebook sur votre ordinateur local. Vous pouvez effectuer toutes les actions telles que ajouter / modifier des cellules, exécuter les cellules, etc.

Le projet Jupyter décrit JupyterLab comme une interface utilisateur Web de nouvelle génération pour tous les produits de l'écosystème Jupyter. Il vous permet de travailler de manière transparente avec les ordinateurs portables, les éditeurs et les terminaux de manière extensible.

Certaines des fonctionnalités importantes de JupyterLab sont décrites ci-dessous -

La console de code agit comme un bloc-notes pour exécuter le code de manière interactive. Il prend entièrement en charge la sortie riche et peut être lié à un noyau de notebook pour enregistrer l'activité du notebook.
Tout fichier texte (Markdown, Python, R, LaTeX, etc.) peut être exécuté de manière interactive dans n'importe quel noyau Jupyter.
La sortie de la cellule du bloc-notes peut être affichée dans son propre onglet, ou avec le bloc-notes, permettant des tableaux de bord simples avec des contrôles interactifs soutenus par un noyau.
L'édition en direct du document se reflète dans d'autres visualiseurs tels que les éditeurs ou les consoles. Il est possible d'avoir un aperçu en direct des documents Markdown, Valeurs séparées par un séparateur ou Vega / Vega-Lite.

JupyterLab peut gérer de nombreux formats de fichiers (images, CSV, JSON, Markdown, PDF etc.). Il affiche également une sortie riche dans ces formats. JupyterLab fournit des raccourcis clavier personnalisables en utilisant des cartes de touches de nombreux éditeurs de texte bien connus.

Vous pouvez essayer en ligne les fonctionnalités de JupyterLab avant de procéder à l'installation. Visitehttps://jupyter.org/try et choisissez l'option «essayer JupyterLab».

L'onglet du lanceur affiche les noyaux et les consoles actuellement disponibles. Vous pouvez démarrer un nouveau bloc-notes / terminal basé sur l'un d'entre eux. La colonne de gauche contient également des onglets pour le navigateur de fichiers, les noyaux en cours d'exécution et les onglets et la vue des paramètres.

JupyterLab est normalement installé automatiquement avec la distribution Anaconda. Cependant, il peut également être installé séparément en utilisant la commande conda suivante -

conda install -c conda-forge jupyterlab

Vous pouvez également utiliser la commande pip à cet effet -

pip3 install jupyterlab

Pour démarrer l'application JupyterLab, le moyen le plus pratique est d'Anaconda Navigator s'il est installé.

Vous pouvez également le démarrer à partir de la ligne de commande à partir du terminal de commande Windows / Linux ou de l'invite Anaconda à l'aide de cette commande -

jupyter lab

Dans tous les cas, l'écran de lancement de l'application JupyterLab ressemble à ceci -

Pour démarrer un nouveau notebook, cliquez sur le noyau souhaité. Dans la capture d'écran ci-dessus, on voit un noyau qui est le noyau Python3. Cliquez dessus pour démarrer un bloc-notes Python. Notez que sa fonctionnalité est similaire à celle que nous avons étudiée dans ce tutoriel.

Barre de menu

La barre de menu se trouve en haut de la fenêtre. Les menus par défaut que vous pouvez trouver dans ceci sont -

File - Actions liées aux fichiers et répertoires.
Edit - Actions liées à l'édition de documents et autres activités.
View - Actions qui modifient l'apparence de JupyterLab.
Run - Actions pour exécuter du code dans différentes activités telles que les blocs-notes et les consoles de code.
Kernel - Actions de gestion des noyaux, qui sont des processus séparés pour exécuter du code.
Tabs - Une liste des documents ouverts et des activités dans le panneau du Dock.
Settings - Paramètres communs et un éditeur de paramètres avancés.
Help - Une liste de JupyterLab et des liens d'aide du noyau.

La barre latérale gauche affiche des boutons pour démarrer un nouveau lanceur, ajouter un dossier, télécharger un fichier et actualiser la liste de fichiers. Le volet de droite est la zone de travail principale où le notebook, la console et les terminaux sont affichés sous forme d'onglets.

Pour démarrer une nouvelle console, cliquez sur le symbole + dans la barre latérale gauche pour ouvrir un nouveau lanceur, puis cliquez sur l'option console. La console s'ouvrira dans un nouvel onglet sur le volet droit.

Notez que la cellule d'entrée est en bas, mais lorsqu'elle est exécutée, la cellule et sa cellule de sortie correspondante apparaissent dans la partie supérieure de l'onglet de la console.

Le lanceur vous permet également d'ouvrir un éditeur de texte et un terminal dans lequel le shell IPython peut être appelé.

Project Jupyter prend désormais en charge les noyaux d'environnements de programmation. Nous allons maintenant voir comment installer le noyau R dans la distribution anaconda.

Dans la fenêtre d'invite Anaconda, entrez la commande suivante -