# Tutoriel-notebooks-Jupyter-a-Didapro-8-Lille-fevrier-2020
Introduction aux notebooks Jupyter
[](https://mybinder.org/v2/gh/Naereen/Tutoriel-notebooks-Jupyter-a-Didapro-8-Lille-fevrier-2020/master)
Ce tutoriel durera 55 minutes, durant la journée de mercredi 05 février, à la [conférence Didapro 8](https://www.didapro.org/8/programme/#atelier), à Lille.
- Suivez d'abord la présentation, puis il y a aura une activité à faire par vous même, avant de terminer par plusieurs démonstrations.
- Ces ressources sont disponibles en ligne sur [`frama.link/Atelier-Jupyter-Didapro8`](https://frama.link/Atelier-Jupyter-Didapro8)
## Présentation de Jupyter
- Qu'est-ce que Jupyter ?
- Qu'est-ce qu’un notebook Jupyter ?
- Qu'est-ce que l’écosystème Jupyter ?
- Quels problèmes résolvent les notebooks Jupyter ?
### Qu’est-ce que Jupyter ?
Un environnement de développement intégré (IDE) "WYSIWYG" (What-you-see-is-what-you-get) pour (presque) tous les langages de programmation, que l'on utilise depuis un navigateur Internet.
Par exemple, il peut être utilisé pour des langages dynamiques interprétés, tels que Python, OCaml, Julia ou Bash, mais aussi pour des langages compilés, tels que C/C++ etc.
C'est un ensemble de logiciels libres et gratuits, installables sur n'importe quel ordinateur moderne et qui sont faciles à prendre en main.
### Qu’est-ce qu’un notebook Jupyter ?
C'est un fichier, à l'extension `.ipynb` (*ipy*thon *n*ote*b*ook), qui est un format de texte brut de type [JSON](https://www.json.org/).
Ce fichier peut être converti en présentation (slide show) comme celle utilisée aujourd'hui, en page web statique (HTML), en document prêt à être imprimé (PDF), en script (Python ou autre)
Le format de fichier, et tous les logiciels de l'environnement Jupyter, sont gratuits et sous licence libre, comme Python.
Un document contient des cellules de texte (en Markdown ↑), et de code ↓.
```python
!file "Introduction aux notebooks Jupyter.ipynb"
!head "Introduction aux notebooks Jupyter.ipynb"
!grep "texte brut" "Introduction aux notebooks Jupyter.ipynb" | head -n1
```
Introduction aux notebooks Jupyter.ipynb: HTML document, UTF-8 Unicode text, with very long lines
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "skip"
},
"toc": "true"
},
"C'est un fichier, à l'extension `.ipynb` (*ipy*thon *n*ote*b*ook), qui est un format de texte brut de type [JSON](https://www.json.org/).\n",
### Qu'est-ce que l’écosystème Jupyter ?
Il a commencé sous le nom ipython il y a environ 15 ans, conçu pour être utilisé uniquement pour le langage de programmation Python, et de nos jours il a évolué en un écosystème open-source mature.
*Jupyter* est nommé d'après Jupiter, et pour *Ju*lia, *pyt*hon, et *R*, les trois premiers langages pour lesquels Jupyter était disponible.
Il est utilisé par des centaines de milliers de scientifiques du monde entier, allant d'étudiants au lycée, en prépa et à l'université en France et ailleurs, aux meilleures équipes utilisant les sciences des données et du numérique.
Les notebooks Jupyter sont une alternative gratuite et open-source à l’EDI inclus dans les logiciels propriétaires et payants qui dominent le marché, comme MATLAB, Wolfram's Mathematica et MapleSoft's Maple.
Parmi ses récentes utilisations réussies, on peut noter la toute première image d’un trou noir obtenue par Katie Bouman et ses collaborateurs, ou pour l'analyse de données par des lauréats de prix Nobel, comme Paul Romer.
- Voir par exemple http://www.nationalgeographic.com/science/2019/04/first-picture-black-hole-revealed-m87-event-horizon-telescope-astrophysics/ et http://www.bbc.com/news/science-environment-47891902.
- Voir http://paulromer.net/jupyter-mathematica-and-the-future-of-the-research-paper/
### Quels problèmes résolvent les notebooks Jupyter ?
Pourquoi c'est un outil puissant, à la fois facile à apprendre et à utiliser pour les débutants et puissant pour les utilisateurs experts.
- Un outil unique pour rédiger du code, sa documentation, les résultats de l'exécution du code, des figures etc,
- Facilité de conversion vers d'autres formats (scripts, HTML, PDF etc),
- Stocké comme des fichiers textes, compatibilité avec les gestionnaires de version tels que `git`.
---
## Comment installer Jupyter
En suivant le tutoriel en ligne depuis https://jupyter.org/install.html, il est facile d’installer tout l’écosystème Jupyter sur tout ordinateur avec Python et pip ou conda installés.
Sur Windows ou Mac OS X, ou même la plupart des systèmes GNU/Linux, un installeur gratuit appelé Anaconda (https://www.anaconda.com/distribution/) installe tout ça en un clic !
## Comment utiliser Jupyter pour écrire des documents simples
Je vais vous montrer l'interface utilisateur graphique des notebooks Jupyter, et nous allons voir ensemble comment éditer des cellules de texte ou de code, et exécuter des cellules.
Ceci est une cellule de texte. On peut *utiliser* [Markdown](http://commonmark.org/) ! Et $\LaTeX$
|-
```python
```
---
## Des exemples en Python
1. Premier contact avec Python,
2. Manipulation de tableaux numpy et affichage avec Matplotlib,
3. Widgets interactifs avec `ipywidgets`,
4. Un exemple plus impressionnant : pavage de Penrose.
### Premier contact avec Python
Deux exemples d'utilisation de Python, venant de la page d'accueil du site https://www.python.org/ :
```python
nombres = [2, 4, 6, 8]
produit = 1
for nombre in nombres:
produit *= nombre
print("Le produit de ces", len(nombres), "nombres est", produit)
```
Le produit de ces 4 nombres est 384
```python
import datetime
print("Date actuelle :")
print(datetime.datetime.now())
```
Date actuelle :
2020-01-29 17:40:30.384708
```python
def fib(n):
""" Affiche les premières valeurs de la suite de Fibonacci <= n."""
a, b = 0, 1
while a < n:
print(a, end=' ')
a, b = b, a+b
print()
fib(1000)
```
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
Depuis un notebook Jupyter, la documentation de n'importe quelle valeur peut être affichée avec la touche tab, ou en utilisant :
```python
fib?
```
### Manipulation de tableaux numpy et affichage avec Matplotlib
Cet exemple est tiré d'un exercice d'oral de CentraleSupélec pour PSI (166 officiel de la Taupe 2019).
Sur un plateau style Monopoly à 12 cases, un pion part de la case 0, et on joue au dé (à 6 faces) pour avancer à chaque coup de $x$ case (où $x\sim\mathcal{U}(1,\dots,6)$.
L'exercice demande de simuler la variable aléatoire $Y_n$ représentant la case sur laquelle le pion se trouve après $n$ déplacements.
```python
import numpy as np
import numpy.random as rd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(context="notebook", style="whitegrid", palette="hls", font="sans-serif", font_scale=1.3)
```
```python
case_max = 12
univers = list(range(case_max))
def prochaine_case(case):
return (case + rd.randint(1, 6+1)) % case_max
def Yn(duree, depart=0):
case = depart
for coup in range(duree):
case = prochaine_case(case)
return case
```
Avant de s'en servir pour simuler plein de trajectoirs, on peut vérifier que en un coup, on avance pas plus de 6 cases :
```python
[Yn(1) for _ in range(10)]
```
[4, 4, 6, 6, 1, 6, 2, 1, 4, 5]
On peut ensuite réaliser des histogrammes des 12 valeurs possibles pour $Y_n$, avec par exemple 10000 répétitions iid.
```python
def histogramme(duree, repetitions=10000):
cases = [Yn(duree) for _ in range(repetitions)]
frequences = np.bincount(cases, minlength=case_max)
# aussi a la main si besoin
frequences = [0] * case_max
for case in cases:
frequences[case] += 1
return frequences / np.sum(frequences)
```
```python
n = 0
plt.figure(figsize=(10,7))
plt.bar(np.arange(case_max), histogramme(n))
plt.title("Histogramme de cases visitées en " + str(n) + " coups")
plt.show()
```
Text(0.5, 1.0, 'Histogramme de cases visitées en 0 coups')
```python
n = 1
plt.figure(figsize=(10,7))
plt.bar(np.arange(case_max), histogramme(n))
plt.title("Histogramme de cases visitées en " + str(n) + " coups")
plt.show()
```
Text(0.5, 1.0, 'Histogramme de cases visitées en 1 coups')
```python
n = 10
plt.figure(figsize=(10,7))
plt.bar(np.arange(case_max), histogramme(n))
plt.title("Histogramme de cases visitées en " + str(n) + " coups")
plt.show()
```
Text(0.5, 1.0, 'Histogramme de cases visitées en 10 coups')
```python
n = 500
plt.figure(figsize=(10,7))
plt.bar(np.arange(case_max), histogramme(n))
plt.title("Histogramme de cases visitées en " + str(n) + " coups")
plt.show()
```
Text(0.5, 1.0, 'Histogramme de cases visitées en 500 coups')
Cela montre qu'avec une trajectoire assez longue, le pion a une probabilité identique de terminer sur chaque position.
### Widgets interactifs avec `ipywidgets`
```python
%matplotlib notebook
from ipywidgets import *
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 2 * np.pi)
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
line, = ax.plot(x, np.sin(x))
def update(w = 1.0):
line.set_ydata(np.sin(w * x))
fig.canvas.draw()
interact(update);
```
interactive(children=(FloatSlider(value=1.0, description='w', max=3.0, min=-1.0), Output()), _dom_classes=('wi…
```python
%matplotlib notebook
from ipywidgets import interactive
import matplotlib.pyplot as plt
import numpy as np
def f(m, b):
plt.figure()
x = np.linspace(-10, 10, num=1000)
plt.plot(x, m * x + b)
plt.ylim(-5, 5)
plt.show()
interactive_plot = interactive(f, m=(-2.0, 2.0), b=(-3, 3, 0.5))
output = interactive_plot.children[-1]
output.layout.height = '350px'
interactive_plot
```
interactive(children=(FloatSlider(value=0.0, description='m', max=2.0, min=-2.0), FloatSlider(value=0.0, descr…
### Pavage de Penrose avec un joli programme
Ce petit code (qui n'est pas de moi) [Penrose tiling](https://en.wikipedia.org/wiki/Penrose_tiling) (infinite pattern) to a PNG image, of resolution 2000×2000 :
```python
%%time
from functools import reduce
_ =\
"""if!
1:"e,V=200
0,(0j-1)**-.2;
v,S=.5/ V.real,
[(0,0,4 *e,4*e*
V)];w=1 -v"def!
E(T,A, B,C):P
,Q,R=B*w+ A*v,B*w+C
*v,A*w+B*v;retur n[(1,Q,C,A),(1,P
,Q,B),(0,Q,P,A)]*T+[(0,C ,R,B),(1,R,C,A)]*(1-T)"f
or!i!in!_[:11]:S =sum([E (*x)for !x!in!S],[])"imp
ort!cair o!as!O; s=O.Ima geSurfac
e(1,e,e) ;c=O.Con text(s); M,L,G=c.
move_to ,c.line_to,c.s et_sour
ce_rgb a"def!z(f,a) :f(-a.
imag,a. real-e-e)"for!T,A,B,C!in[i !for!i!
in!S!if!i[""";exec(reduce(lambda x,i:x.replace(chr
(i),"\n "[34-i:]), range( 35),_+"""0]]:z(M,A
);z(L,B);z (L,C); c.close_pa
th()"G (.4,.3 ,1);c.
paint( );G(.7 ,.7,1)
;c.fil l()"fo r!i!in
!range (9):"! g=1-i/
8;d=i/ 4*g;G(d,d,d, 1-g*.8
)"!def !y(f,a):z(f,a+(1+2j)*( 1j**(i
/2.))*g)"!for!T,A,B,C!in!S:y(M,C);y(L,A);y(M
,A);y(L,B)"!c.st roke()"s.write_t
o_png('figs/ penrose.png')
""" ))
```
CPU times: user 4.49 s, sys: 0 ns, total: 4.49 s
Wall time: 4.5 s
---
## Présentant ma propre utilisation de notebooks Jupyter
Je souhaite vous montrer différents cas d'utilisation des cahiers Jupyter au quotidien pour mes activités d’enseignement, durant les trois dernières années.
Je présenterai principalement des exemples de ressources produites à partir d’un notebook Jupyter, et comment convertir des notebooks en HTML.
### Quelques micro exemples très pratiques
```python
# Dans Python avec Jupyter, on a accès au shell/terminal de l'environnement facilement :
!ls -larth paper/*.png figs/*.png
```
-rw-r--r-- 1 lilian lilian 45K oct. 22 09:58 paper/apercu_ENS_agreg_1.png
-rw-r--r-- 1 lilian lilian 51K oct. 22 09:58 paper/apercu_ENS_agreg_2.png
-rw-r--r-- 1 lilian lilian 87K oct. 22 09:58 paper/apercu_ENS_agreg_3.png
-rw-r--r-- 1 lilian lilian 125K oct. 22 09:58 paper/apercu_ENS_agreg_4.png
-rw-r--r-- 1 lilian lilian 108K oct. 22 09:58 paper/interactive_Turing_Machine_simulator_1.png
-rw-r--r-- 1 lilian lilian 94K oct. 22 09:58 paper/interactive_Turing_Machine_simulator_2.png
-rw-r--r-- 1 lilian lilian 41K janv. 29 11:27 figs/introspection_in_ocaml.png
-rw-rw-r-- 1 lilian lilian 342K janv. 29 16:55 figs/git_diff_for_jupyter_notebooks.png
-rw-rw-r-- 1 lilian lilian 105K janv. 29 16:56 figs/installing_jupyter.png
-rw-rw-r-- 1 lilian lilian 215K janv. 29 16:58 figs/installing_jupyter_with_Anaconda.png
-rw-rw-r-- 1 lilian lilian 2,5M janv. 29 17:02 figs/penrose.png
-rw-rw-r-- 1 lilian lilian 122K janv. 29 17:48 figs/apercu_prepa.png
-rw-rw-r-- 1 lilian lilian 181K janv. 29 17:49 figs/apercu_prepa2.png
```python
# Quelle est mon adresse IP ?
!wget --quiet -O - http://monip.org/ | html2text
```
IP : 131.254.100.11
lbesson-p.irisa.fr
Pas de proxy détecté - No Proxy detected
### Correction interactive de TP en prépa (PSI)
J'ai écrit les solutions pour les sessions pratiques données en tant qu’entraı̂nement pour l'examen oral “Mathématiques avec Python” du concours CentraleSupélec (CPGE), avec des notebooks Jupyter, afin de les partager facilement avec les étudiants, de les exposer et de travailler dessus pendant les sessions pratiques. Voir https://perso.crans.org/besson/notebooks/Oraux_CentraleSupelec_PSI__Juin_2019.html, avec Python et des maths, pour les étudiants d'une classe du PSI (CPGE) en juin 2017, 2018 et 2019.
### Entraînement à l'oral de modélisation d'agrégation (maths option info)
J'ai utilisé des notebooks Jupyter pour écrire les sujets et les solutions des sessions pratiques utilisées pour entraı̂ner nos étudiants à l'examen oral de modélisation de l’agrégation. Voir https://nbviewer.jupyter.org/github/Naereen/notebooks/tree/master/agreg/TP_Programmation_2017-18/, avec le langage OCaml, pour des étudiants de M2.
### Cours d'algorithmique en L3 informatique
J'ai écrit des implémentations propres et détaillées de structures de données et d’algorithmes, pour un cours d’algorithmique à l'automne 2019, avec des notebooks Jupyter. Voir https://github.com/Naereen/ALGO1-Info1-2019/, avec le langage Python, pour des étudiants de L3.
---
## Conclusion : conseils pour devenir un-e expert-e en Jupyter
- Comment utiliser un dépôt GitHub/Bitbucket/GitLab pour héberger des notebooks Jupyter, et les afficher en ligne en utilisant le site https://nbviewer.jupyter.org/.
+ https://nbviewer.jupyter.org/github/Naereen/Tutoriel-notebooks-Jupyter-a-Didapro-8-Lille-fevrier-2020
+ Voir https://github.com/Naereen/ALGO1-Info1-2019/ et https://github.com/Naereen/notebooks/ pour des exemples.
- Utilisez Binder, Google Colab ou d’autres outils gratuits en ligne, pour ajouter un lien afin que tout utilisateur consultant vos notebooks Jupyter puisse démarrer un environnement interactif, directement depuis son navigateur Web, pour interagir avec le notebook sans rien avoir à installer.
+ https://mybinder.org/repo/Naereen/Tutoriel-notebooks-Jupyter-a-Didapro-8-Lille-fevrier-2020
- Utilisez les extensions Jupyter pour améliorer l'EDI. Voir https://jupyter-contrib-nbextensions.readthedocs.io/en/latest/.
+ par exemple pour ajouter automatiquement une table des matières,
+ ou afficher une présentation interactive dynamiquement générée depuis le notebook (comme pour ce tutoriel).
- Suivez les meilleurs exemples, par exemple le célèbre Peter Norvig (chef de la recherche chez Google) publie des notebooks très intéressants sur son projet https://github.com/norvig/pytudes, depuis 5 ans.
- Partagez vos notebooks en ligne, avec vos étudiants et collègues, et recevez leurs commentaires.
- Utilisez https://github.com/jupyter/nbgrader pour facilement utiliser les notebooks comme support d'évaluation (évaluation automatique du rendu de vos élèves !).
---
## Références et liens
### Liens
- Ce tutoriel en ligne : https://frama.link/Atelier-Jupyter-Didapro8 (https://github.com/Naereen/Tutoriel-notebooks-Jupyter-a-Didapro-8-Lille-fevrier-2020)
- Langage Python : https://www.python.org/
- Projet jupyter : https://www.jupyter.org/
- Installeur Anaconda : https://www.anaconda.com/distribution/
- Des bons tutoriels : https://plot.ly/python/v3/ipython-notebook-tutorial/ et https://www.dataquest.io/blog/advanced-jupyter-notebooks-tutorial/
- Documentation : https://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/what_is_jupyter.html#id4
### Publications universitaires
- Thomas Kluyver et al. Jupyter Notebooks - a publishing format for reproducible computational workflows. In F. Loizides and B. Schmidt, editors, Positioning and Power in Academic Publishing: Players, Agents and Agendas, pages 87–90. IOS Press, 2016. http://www.jupyter.org/
- Python Software Foundation. Python Language Reference, version 3.6, October 2017. http://www.python.org/.
- Fernando Pérez and Brian E. Granger. IPython: a System for Interactive Scientific Computing. Computing in Science and Engineering, 9(3):21–29, May 2007. ISSN 1521-9615. http://ipython.org/.
interactive(children=(FloatSlider(value=1.0, description='w', max=3.0, min=-1.0), Output()), _dom_classes=('wi…
```python
%matplotlib notebook
from ipywidgets import interactive
import matplotlib.pyplot as plt
import numpy as np
def f(m, b):
plt.figure()
x = np.linspace(-10, 10, num=1000)
plt.plot(x, m * x + b)
plt.ylim(-5, 5)
plt.show()
interactive_plot = interactive(f, m=(-2.0, 2.0), b=(-3, 3, 0.5))
output = interactive_plot.children[-1]
output.layout.height = '350px'
interactive_plot
```
interactive(children=(FloatSlider(value=0.0, description='m', max=2.0, min=-2.0), FloatSlider(value=0.0, descr…
