Introduction à l'utilisation des notebooks Jupyter

In [1]: %matplotlib inline

import numpy as np
import matplotlib.pyplot as plt
from IPython.core.display import HTML
from IPython.display import display,Image
#
from IPython.display import display, Markdown, clear_output
def printmd(string):
display(Markdown(string))
# test si numero étudiant spécifier
try: NUMERO_ETUDIANT
except NameError: NUMERO_ETUDIANT = None
if type(NUMERO_ETUDIANT) is not int :
printmd("## ERREUR: numéro d'étudiant non spécifié!!!")
NUMERO_ETUDIANT = 1234
NOM = "toto"
PRENOM = "toto"
#raise AssertionError("NUMERO_ETUDIANT non défini")
# parametres spécifiques
_uid_ = NUMERO_ETUDIANT
np.random.seed(_uid_)
printmd("## Etudiant {} {} id={}".format(NOM,PRENOM,NUMERO_ETUDIANT))

ERREUR: numéro d'étudiant non spécifié!!!

Etudiant toto toto id=1234

Ressources en ligne à consulter

Int roduct ion à Pyt hon & Jupyt er (ht t ps://perso.univ-lyon1.fr/marc.buffat /2020/Pyt hon/index.ht ml) vidéo
d'int roduct ion à l'environnement numérique pyt hon avec les not ebooks jupyt er
COURS InProS (ht t ps://perso.univ-lyon1.fr/marc.buffat /COURS/INPROS.ht ml) ''Int roduct ion à la
Programmat ion Scient ifique avec Pyt hon''
ht t ps://nbviewer.jupyt er.org/git hub/ipyt hon/ipyt hon/blob/4.0.x/examples/Index.ipynb
(ht t ps://nbviewer.jupyt er.org/git hub/ipyt hon/ipyt hon/blob/4.0.x/examples/Index.ipynb) int roduct ion to
ipyt hon
ht t ps://nbviewer.jupyt er.org/ (ht t ps://nbviewer.jupyt er.org/) examples de not ebooks Jupyt er
ht t ps://jakevdp.git hub.io/Pyt honDat aScienceHandbook/
(ht t ps://jakevdp.git hub.io/Pyt honDat aScienceHandbook/) Pyt hon Dat a Science Handbook
Introduction :
Vous allez au cours de ce T P vous familiariser avec Pyt hon, mat plot lib et le format not ebook.
Pyt hon est un langage de programmat ion t rès générique et ut ilisé dans beaucoup de cont ext e différent .
Pour le calcul scient ifique, nous allons surtout ut iliser les modules Mat plot lib, numpy, Scipy

Python
Pyt hon est un language de programmat ion moderne de haut niveau, logiciel libre, généralist e, mult i-
plat eformes, mult i-archit ect ure, mult i-OS (linux, windows, MacOS,..). Un programme pyt hon peut s'exécut er
sur un tout pet it raspberry Pi à 30€ (ARM), sur des smart phones, des port ables, des PC jusqu'aux super-
calculat eurs HPC avec 109 coeurs de calcul.

historique

Guido Von Rossum, un informat icien hollandais, crée en 1989 un nouveau langage de programmat ion, qu'il
décide de part ager avec la communaut é int ernat ionale sous une licence de logiciel libre. Fan de la série
t élévisée Monty Python's Flying Circus, il décide de bapt iser ce projet Pyt hon. Les Mont y Pyt hon ont eu une
grande influence sur l'informat ique puisqu'ils sont aussi à l'origine du t erme spam (nom ut iliser dans un de
leurs sket chs).

Le langage Pyt hon est devenu l'un des langages de programmat ion le plus ut ilisé au monde et est géré par la
Python Software Foundation (PSF), une associat ion sans but lucrat if fondée en 2001.
Bases d'un notebook

Not ebook
Le not ebook est une int erface web riche qui permet d'associer du code, la réponse du code et du t ext e.
Le document que l'on t ravaille est composé de cellules.
Pour chaque cellule, il faut indiquer à l'avance comment le not ebook doit l'int erprét er.

Les différent s t ypes de cellule

code

L'int erprét at ion par défaut est en code, c'est à dire que le programme int erprèt e le cont enu de la cellule
comme s'il s'agissait d'un code en pyt hon. Pour changer cela, il faut select ionner la cellule puis ut iliser le
menu déroulant de la barre d'out ils en haut .

t ext e (markdown)

Une cellule peut êt re int erprét ée comme du t ext e, selon un langage spécifique, le markdown. Il s'agit de t ext e
enrichi de quelques règles supplément aires qui permet t et une mise en page sommaire (mais efficace) du
t ext e. Nous allons en voir quelques exemples.

cellules non modifiables : cellules avec une clé que vous ne pouvez pas modifier.
cellules avec des quest ions et des t est s

cellule de code contenant votre réponse (noté)

ces cellules de code permet t ent de rent rer une ou plusieurs ligne de code pyt hon. Elles affichent :

# YOUR CODE HERE

raise NotImplementedError()

Il faut effacer ces 2 lignes pour les remplacer par les lignes de code pour répondre à la quest ion posée.

Dans la cellule suivant e, vous avez un t est qui permet de valider la réponse et vérifier si celle-ci est correct e.
Si vot re réponse est correct e elle affiche Validation OK

cellule de texte pour rentrez vos commentaires et analyses demandées (noté)

Ces cellules de t ext e cont iennent le t ext e suivant :

YOUR ANSWER HERE

qu'il faut remplacer par vot re réponse au format markdown (voir plus loin)

Exercice :

dans la cellule de code évalué suivant e ent rée la ligne de code suivant e (sans espace avant )

x = np.sqrt(2)/2.

√2
qui calcule la valeur approchée de 2
. Dans la cellule de t ext e suivant e expliquée pourquoi ce n'est pas la
valeur exact e. On pourra analyser le résult at de x2 = x ∗ x .

In [2]: # calculer la valeur approchée dans la variable x

x = 0
### BEGIN SOLUTION
x = np.sqrt(2)/2
### END SOLUTION
 In [3]: print("x=",x)
print("x*x=",x*x)
assert (np.abs(x-0.70710678118654)<1.e-14)
printmd("### Validation OK")

x= 0.7071067811865476
x*x= 0.5000000000000001

Validat ion OK

Quelques commandes de base :

exécuter une cellule : bouton run (ou raccourci shift+enter)
créer une nouvelle cellule : bouton + (ou raccourci alt+entrer)
changer le type de la cellule : : menu déroulant

Attention

Il faut bien veiller à exécut er le not ebook dans l'ordre, en commençant à la première cellule.

astuce : ut iliser le menu Noyau -> Redemmarer & tout exécuter ou Kernel -> Restart & Run all pour
execut er tout le not ebook sans effet de bord

Exercice :
Ajout ez à la suit e cet t e cellule avec le bouton + deux cellules, une en code et une en markdown.
Dans la première cellule de code, écrivez ' a=1;print(a); ' (sans les guillemet s), puis execut ez.
Dans la deuxième cellule, en markdown, comment er le résult at . (1 ligne maximum)

In [ ]:
Règles de format t age du t ext e
Il est possible de met t re en page (un minimum) le t ext e dans une cellule markdown.
Ces règles sont assez sommaires, mais suffisent en général pour ce qu'on veut écrire. Pour une mise en
page plus complèt e, il faudra ut iliser des logiciels t iers (Latex, openoffice, et c...)

italique, gras :
On ut ilise le caract ère * pour met t re du t ext e en :

it alique : *t ext e* --> texte

gras : **t ext e** --> texte

Saut de ligne, nouveau paragraphe : Pour commencer une nouvelle ligne, il faut ajout er deux espaces à la fin
d'une ligne.
Pour commencer un nouveau paragraphe, il faut saut er deux lignes.

Titres Pour inclure un t it re, il faut ut iliser le caract ère # en début de ligne. Tout le rest e de la ligne sera alors
format é comme un t it re (grande police, gras).
Si on ut ilise plusieurs caract ères en début de ligne, le niveau de t it re diminue :

# --> t it re principal
## --> sous-t it re
### --> sous-sous-t it re
et c...

Exercice :
Format t er le t ext e suivant suivant e en ut ilisant :

it alique
gras
saut de ligne
paragraphe
un t it re de second niveau

Un peu d’histoire Ce language a ét é créé en 2004 par John Gruber et Aaron Swart z et n’a pas évolué depuis.
Même si de nombreuses ext ensions et “ext ras” sont venues se greffer au projet originel. Le projet init ial avec
sa document at ion est sur daringfireball. Dès le départ , Gruber a écrit un script Perl pour convert ir du t ext e
markdown en XHT ML. C’est tout l’int érêt du syst ème : édit er un fichier t ext e simple avec quelques
caract ères spéciaux supplément aires, puis le faire passer dans un script qui va l’enrichir des balises requises
pour l’afficher mise en forme dans le navigat eur.
Equat ions
Il est possible d'inclure des équat ions mat hémat iques dans une cellule markdown. C'est même d'ailleurs là
un de ses int érêt s principaux.
Les équat ions sont écrit es suivant une synt axe Lat ex (simplifiée). On ut ilise pour cela le symbole dollar ($) de
la façon suivant e :

équat ion dans la même ligne: 1x($) soit `textedel′ é quation`

équat ion avec retour à la ligne: 2x($) soit ` t ext e de l'équat ion `

Le t ext e de l'équat ion suit aussi la synt axe lat ex. Celle-ci est t rès riche et ne peut pas êt re expliquée en
quelques minut es, vous êt es invit és à consult er des t utoriels sur int ernet . Voici quelques indicat ions de
synt axe de base :

exposant : \^{t ext e}

indice : _ {t ext e}
fract ion : \frac{numérat eur}{denominat eur}
grec : \pi, \alpha, \lambda, et c...
racine carrée : \sqrt {t ext e}

Exemple :
La formule d'euler relie les nombres les plus import ant s des mat hémat iques :
iπ
e + 1 = 0

avec e = 2.71828182846... et π = 3.14159265359...

Attention :
Markdown n'est pas prévu pour ut iliser tout e la richesse de Lat ex. En part iculier, il est impossible (ou t rès
difficile...) d'inclure des packages permet t ant des caract ères qui ne sont pas prévus dans le lat ex de base. Il
est recommandé de simplifier au maximum les équat ions.

Exercice :
écrire dans la cellule suivant e l'équat ion des gazs parfait s pour un fluide , en définissant chacun des t ermes.

Eléments de programmation avec Python

Nous allons maint enant nous concent rer sur le code en pyt hon, et ses applicat ions pour le calcul
scient ifique.

Bases : variables, t ypes, list es

Pour commencer, nous allons voir les variables en pyt hon. Pour définir une variable, la synt axe est simple :

In [4]: a=1
Nous venons de définir la variable 'a', et elle a pour valeur 1.
a est donc une variable.

Types des variables:

la valeur de a est 1, c'est une variable numérique. De plus, le nombre n'a pas de décimales : c'est un ent ier. On
peut le vérifier avec la fonct ion type :

In [5]: type(a)

Out[5]: int

Pour déinir une variable réelle à virgule flot t ant e, il faut lui met t re des décimales :

In [6]: b=1.0
type(b)

Out[6]: float

Il y a plusieurs t ypes de variables dans pyt hon ( int , float , string , ...), il y en a en plus dans les modules,
et il est même possible de créer de nouveaux t ypes de variables, mais nous ne rent rerons pas dans ce sujet
sans fin.
La principale difficult é que vous allez rencont rer est lors de l'associat ion de différent s t ypes, par exemple
dans une opérat ion mat hémat ique. Dans ce cas il faut parfois êt re vigilant .

Exercice :
Expliquez les différent s résult at s donnés par les opérat ions ci-dessous dans la dernière cellule de t ext e

In [7]: a=1;b=3;
print(a+b)
print(a//b)

4
0

In [8]: a=1.;b=3;
print(a/b)

0.3333333333333333

In [9]: a='1'; b='3';

print(a+b)

13
Réponse :

cellule 1
cellule 2
cellule 3

Test s, Boucles, fonct ions

En pyt hon, les st ruct ures (boucles, if, fonct ions, et c...) sont indiquées avec l'indentation. Il est donc
primordial de respect er l'indent at ion lors de l'écrit ure d'un programme !! La synt axe est en général :
for var in liste:
(action)

if (condition):
(action)

L'indentation et les deux points sont absolument nécessaire à l'éxecution du code !!

Exemple :

In [10]: for i in [0,1,2,3,4,5]:

print(i)

0
1
2
3
4
5

Pour imbriquer des st ruct ures les unes dans les aut res, il suffit d'ajout er un cran à l'indent at ion.

Attention à bien respecter l'indentation lors de la sortie d'une structure

 In [11]: for i in [0,1,2,3,4,5,6,7,8]:
if i<4: # première indentation
print(i) # deux indentations : on est dans le cas (if), lui
-même dans la boucle
print('done') # plus qu'une indentation : on est sorti du cas, m
ais pas de la boucle

0
done
1
done
2
done
3
done
done
done
done
done
done

Pour définir une fonct ion, la synt axe respect e aussi l'indent at ion. Tout ce qui est indent é sera execut é au
sein de la fonct ion.
Exemple :

In [12]: def my_func(a,b):

print(a)
print(b)
print('on va multiplier les deux')
return a*b

In [13]: my_func(3.,4.2)

3.0
4.2
on va multiplier les deux

Out[13]: 12.600000000000001

In [14]: b=my_func(1.3,1.8) # On remarque qu'il n'y a pas de retour de la cellul

e.
# Les commandes d'impression de la fonction, elles,
sont toujours appliquées lors de son appel.

1.3
1.8
on va multiplier les deux
Modules
Bien que déjà t rès riche, la version de base de Pyt hon ne suffit pas à faire proprement du calcul scient ifique.
Par exemple, il n'y a pas de fonct ion de base pour calculer la racinne carrée d'un nombre.
Il serait possible de tout définir de zéro, mais ce serait fast idieux, et surtout complèt ement inut ile car il y a
déjà beaucoup de codes déjà écrit s qui font le t ravail. Ces codes sont regroupés dans des bibliothèques,
appellées en pyt hon MODULES.

Pour charger un module, il y a plusieurs synt axes possibles en pyt hon.

Voyons quelques exemples avec le module numpy et la fonct ion sqrt qu'il cont ient .

In [15]: import numpy # importe le module math dans le notebook

numpy # Le nom du module lui-même ne nous avance pas trop...

Out[15]: <module 'numpy' from '/usr/local/lib/python3.8/dist-packages/numpy/__init_

_.py'>

Pour accéder aux fonct ions cont enues dans le module, il faut les appeler avec le nom du module suivi d'un
point :

In [16]: numpy.sqrt(2)

Out[16]: 1.4142135623730951

Notons que sqrt seul ne suffit pas :

Il est parfois fast idieux de devoir t aper le nom de tout le module à chaque ut ilisat ion. Il est possible alors de
lui donner un nom plus court :

In [17]: import numpy as np # np est le nom classique donné au module numpy

np.array([1,2,3,4])

Out[17]: array([1, 2, 3, 4])

Pour connaît re la list e des fonct ions disponibles dans un module, on peut ut iliser dir :

dir(np)

ou consult er l'aide en ligne (Aide -> Numpy)

Aide dans le not ebook :

Si on veut connaît re les dét ails d'une fonct ion, on peut ut iliser le point d'int errogat ion ?
Si on ne connait pas à l'avance la fonct ion à ut iliser, le plus simple est une recherche sur int ernet .
Exercice :
t aper dans google 'pyt hon numpy renverser'. En déduire comment renverser un array numpy.

In [18]: A=np.array([1,2,3,4,5,6,7,8]);
#B = # écrire ici la définition de B
#print(B)

Remarques: Dans les exercices de programmat ion, les commandes d'import at ion des modules nécessaires
seront déjà écrit es dans la première cellule.

Numpy et matplotlib
Le format de base des t ableaux dans pyt hon est les list es. Pour cert aines raisons, il n'est pas adapt é au
calcul scient ifique.

In [19]: A=[1,2,3,4,5] # une liste A

B=[1,1,1,1,1] # une liste B
print(A+B)

[1, 2, 3, 4, 5, 1, 1, 1, 1, 1]

Pour cela, il est plus prat ique d'ut iliser la bibliot hèque numpy et le format de base qui lui est associé : les
arrays

In [20]: import numpy as np

A=np.array([1,2,3,4,5]) # une liste A
B=np.array([1,1,1,1,1]) # une liste B
print(A+B)

[2 3 4 5 6]

Pour générer un array, il exist e plusieurs mét hodes :

np.array([une liste]) t ransforme une list e en array

np.zeros(n) créée une list e de zeros de t aille n
np.arange(x1,x2,dx) créée un t ableau qui va de x1 à x2 tous les dx. x2 n'est PAS inclus
np.linspace(x1,x2,num=n) créée un t ableau de t aille n qui va de x1 à x2. x2 est inclus.
B = fonction_mathematique(A) crée un t ableau B de même t aille que A, où tous les élément s de B
sont le résult at de la fonct ion pour les élément s de A (exemple : exp, log, t an, cos, ...)

Il y a d'aut res façons de faire (import er un fichier t ext e, et c...)

Exemple :
 In [21]: A=np.zeros(14)+1 # zeros(n) : crée un tableau rempli de zeros, de tail
le n
B=np.arange(0,1,1./14) # arange(a,b,dx) : va de a à b tous les dx (b
n'est PAS inclus !!)
A+B
C=np.linspace(-100,100,num=14) # linspace(a,b,num=n) : place n valeurs e
ntre deux bornes a et b, inclues.
print(A)
print(B)
print(C)

[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[0. 0.07142857 0.14285714 0.21428571 0.28571429 0.35714286
0.42857143 0.5 0.57142857 0.64285714 0.71428571 0.78571429
0.85714286 0.92857143]
[-100. -84.61538462 -69.23076923 -53.84615385 -38.46153846
-23.07692308 -7.69230769 7.69230769 23.07692308 38.46153846
53.84615385 69.23076923 84.61538462 100. ]

Pour accéder à un élément d'un array en position i, on ut ilise la synt axe :

A[i]

Attention !

La numérot at ion commence à 0 , et finit à n − 1

In [22]: B[3]

Out[22]: 0.21428571428571427

Il est possible de représent er graphiquement un t ableau (array) en fonct ion d'un aut re de même t aille grâce à
mat plot lib. Pour cela, on ut ilise la fonct ion plt.plot(A,B) de mat plot lib

In [23]: %matplotlib inline

# cette ligne est nécessaire si on veut afficher les graphes entre les
cellules
import numpy as np
import matplotlib as mp
import matplotlib.pyplot as plt
 In [24]: X=np.linspace(0,2*np.pi,400) # On crée un tableau X, de taille 40
0, qui va de 0 à 2 pi
# Attention, pi n'est pas connu d'ava
nce par matplotlib
Y=np.tanh(X) # On crée un tableau Y avec les tange
ntes hyperboliques des valeurs de X
plt.plot(X,Y) # On trace la courbe Y(X), avec des t
raits reliant les couples de points formés
# par les éléments de X et Y

Out[24]: [<matplotlib.lines.Line2D at 0x7f67fd37f1f0>]

AT TENTION ! Un graphe qui n'a pas de titre aux axes, pas de légende, pas d'explication, n'est pas un bon
graphe !

S'il est admissible de faire un graphe sans rien lorsqu'on recherche la bonne visualisat ion, il faut à la fin
PENSER à mettre un titre, à nommer les axes et à mettre une légende !!!

L'ensemble des modificat ions possibles pour un graphe est assez ét endu, voici un exemple sommaire mais
déjà suffisant .

In [25]: x=np.arange(0,2*np.pi,.03) # définition des tableaux à tracer

y=np.tanh(x)
yy=np.cos(x)
 In [26]: plt.figure(0, figsize=(12,7)) # Crée la figure 0, de taille 7(hori
z.) x 5(vert.)
plt.plot(x,y) # Trace y vs x
plt.plot(x,yy, '--', color='red') # Trace yy en fonction de x, en ligne
--, de couleur rouge
plt.ylim(-1.1,1.1) # Change l'échelle en y
plt.xlim(0,7) # change l'échelle en x

plt.xlabel('temps (s)', fontsize=14) # titre de l'axe x,

en taille de font 14
plt.ylabel("amplitude d'oscillation", fontsize=14) # Idem axe y
plt.title('Exemple de graphe commente', fontsize=18) # Titre du graphe
plt.legend(['tan. hyperb.','cosinus'],loc='lower right', fontsize = 12)
# ici une liste dea courbes
# DANS l"ORDRE D'APPARITION
# loc : pour situer la légende dans le graphe

Out[26]: <matplotlib.legend.Legend at 0x7f67fd2f4610>

Galleries de graphes de mat plot lib (t rès ut iles)

Les examples :

ht t ps://mat plot lib.org/examples/index.ht ml (ht t ps://mat plot lib.org/examples/index.ht ml)

Une gallerie d'images - quand on clique dessus, on a accès au code !!!!
ht t ps://mat plot lib.org/gallery.ht ml (ht t ps://mat plot lib.org/gallery.ht ml)
 In [27]: from IPython.display import HTML
HTML('<iframe src=https://matplotlib.org/gallery.html width=800 height=500
></iframe>')

/usr/local/lib/python3.8/dist-packages/IPython/core/display.py:717: UserWa
rning: Consider using IPython.display.IFrame instead
warnings.warn("Consider using IPython.display.IFrame instead")

Out[27]:
You are reading an old version of the documentation (v2.0.2). For the lates
https://matplotlib.org/stable/

home | examples | gallery | pyplot | docs »

Click on any image to see f ull size image and source code
De ps
Gallery Trav

Lines, bars, and markers Rela

Shapes and collect ions
St at ist ical plot s Docu
Images, contours, and fields
Quic
Pie and polar chart s
Color
Text , labels, and annot at ions Go
T icks and spines
Axis scales
Subplot s, axes, and figures
St yle sheet s

FIN