Pour lancer Jupyter, il faut, dans un terminal, lancer la commande
jupyter-notebook
Cela ouvrira automatiquement un navigateur Web dans lequel on peut travailler. L'onglet principal représente l’arborescence des fichiers depuis le fichier où la commande à été lancé.
Les notebooks sont composés de cellules contenant du code (en python) ou du texte (simple ou formaté avec les balisages Markdown). Ces notebooks permettent de faire des calculs interactifs en Python, et constituent un outil de choix pour l'enseignement.
On peut éditer une cellule en double-cliquant dessus, et l’évaluer en tapant Ctrl+Entrée (on utilisera aussi souvent Maj.+Entrée pour évaluer et passer à la cellule suivante). Les boutons dans la barre d’outil vous seront très utiles, survolez-les pour faire apparaître une infobulle si leur pictogramme n’est pas assez clair. N’oubliez pas de sauvegarder de temps en temps votre travail, même si Jupyter fait des sauvegardes automatiques régulières.
Exercice : Cliquer sur Help -> User Interface Tour
Exercice : Supprimer la cellule suivante (On pourra regarder Help -> Keyboard Shortcuts) :
----- Supprimer moi !!! ------------
Le Markdown est un format de texte qui accepte un minimum de formattage. Il permet de rapidement :
Fun fact : L'application WhatsApp reconnaît le Markdown.
Exercice : Transformer ce mot de italique à gras (indice : double cliquer sur la cellule précédente).
La cellule suivante est une cellule python. On peut l'évaluer avec Maj.+Entrée.
# Ceci est un commentaire Python
# On prendra l'habitude de commenter son code :
# Un code doit être lisible et compréhensible par d'autres utilisateurs
#
a = 8
print("a =", a, "et 2*a =", 2*a)
a = 8 et 2*a = 16
**Exercice 4** : Cette cellule doit être formaté en Markdown, pas en Python...
File "<ipython-input-3-6b6e384a1705>", line 1 **Exercice 4** : Cette cellule doit être formaté en Markdown, pas en Python... ^ SyntaxError: invalid syntax
On peut obtenir de l’aide interactivement avec Jupyter. Par exemple, si on veut connaître ce que fait une fonction (par exemple abs
), on peut taper soit help(abs)
, soit abs?
, ou encore abs
, puis Maj+Tab ou Maj+2xTab. Cette dernière option permet aussi de connaître les différents arguments que prend la fonction.
Exercice : Que prend en entrée str()
? Quelle est la différence entre 2
et str(2)
?
str?
Au début de chaque TP, on commencera toujours par valider la cellule
%pylab inline
Cette cellule permet de charger toutes les fonctions mathématiques (librairie numpy) et d'affichage (librairie matplotlib) de Python.
%pylab inline
Populating the interactive namespace from numpy and matplotlib
N = 10
print("J'ai", N, "morceaux de chocolat")
for i in range(N):
# Boucle for, l'indentation commence après les deux points
if i < 2:
#Boucle if. De nouveau les deux points
print("Si je mange", i, "morceau de chocolat,")
else:
#else, au même niveau d'indentation que if
print("Si je mange", i, "morceaux de chocolat,") # Pluriel !!!
# On revient à l'indentation précédente, on est encore dans la boucle for
print(" il en reste", N-i, ".")
# On revient à l’indentation précédente, on quitte la boucle for
print("On est sorti de la boucle for")
J'ai 10 morceaux de chocolat Si je mange 0 morceau de chocolat, il en reste 10 . Si je mange 1 morceau de chocolat, il en reste 9 . Si je mange 2 morceaux de chocolat, il en reste 8 . Si je mange 3 morceaux de chocolat, il en reste 7 . Si je mange 4 morceaux de chocolat, il en reste 6 . Si je mange 5 morceaux de chocolat, il en reste 5 . Si je mange 6 morceaux de chocolat, il en reste 4 . Si je mange 7 morceaux de chocolat, il en reste 3 . Si je mange 8 morceaux de chocolat, il en reste 2 . Si je mange 9 morceaux de chocolat, il en reste 1 . On est sorti de la boucle for
Exercice : La cellule suivante a des erreurs de code. Corrigez les ! (On lira attentivement les messages d'erreurs).
for i in [12,15,6,20]
if i > 12:
print(i,"est vraiment plus grand que 12")
else:
print("12 est plus grand que",i)
print("Bravo")
File "<ipython-input-5-e420052f0c11>", line 1 for i in [12,15,6,20] ^ SyntaxError: invalid syntax
a, b = 3, 4 #Raccourci pour a = 3 puis b = 4
print("a = ", a, "et b = ", b)
a, b = b, a #Pas besoin de variables temporaires
print("a = ", a, "et b = ", b)
a = 3 et b = 4 a = 4 et b = 3
Python connait plusieurs types (cf cellule suivante). nous reviendrons sur les types plus tard.
#Entier
a = 4
print("a = ", a, "\t\t\t\t est de type", type(a))
# Floatant
a = 3.5
print("a = ", a, "\t\t\t est de type", type(a))
a = 1e7 # Raccourci pour 10^7, --> float
print("a = ", a, "\t\t est de type", type(a))
a = pi # Python connait certaines variables standards
print("a = ", a, "\t\t est de type", type(a))
# Boolean
a = True
print("a = ", a, "\t\t\t est de type", type(a))
# String
a = "Hello World!"
print("a = ", a, "\t\t est de type", type(a))
# Listes (taille variable)
a = [1,2,3]
print("a = ", a, "\t\t\t est de type", type(a))
# Tuples (taille fixe)
a = (1.5, [1,2], "coucou")
print("a = ", a, "\t est de type", type(a))
a = 4 est de type <class 'int'> a = 3.5 est de type <class 'float'> a = 10000000.0 est de type <class 'float'> a = 3.141592653589793 est de type <class 'float'> a = True est de type <class 'bool'> a = Hello World! est de type <class 'str'> a = [1, 2, 3] est de type <class 'list'> a = (1.5, [1, 2], 'coucou') est de type <class 'tuple'>
En plus de ces types de base, nous travaillons avec la librairie numpy, qui introduit le type array (= matrice)
# Array (matrices)
a = array([[1,2], [90,4]])
print("a = \n", a, "\t\t\t est de type", type(a))
a = [[ 1 2] [90 4]] est de type <class 'numpy.ndarray'>
Python connait les opérations +,-,/,*
, et plein d'autres encore. Voici quelques astuces et pièges
print("sqrt{2} = ", 2**.5) # La puissance se fait avec **
print("17 modulo 3 = ", 17%3) # Avec %
print("3/2 = ", 3/2, "est un float")
a = 4
print("a = ", a)
a += 2 #Raccourci pour a = a+2 (marche aussi avec *=, /=, etc.)
print("a = ", a)
sqrt{2} = 1.4142135623730951 17 modulo 3 = 2 3/2 = 1.5 est un float a = 4 a = 6
La fonction print
permet d'afficher des chaines de charactères (string), et les valeurs des variables.
print("On peut mettre les arguments à la suite : pi =", pi, "et e = ", e)
#On peut formatter une ligne avec le symbole %
print("C'est (presque) équivalent au formattage : pi = %f et e = %f"%(pi, e))
#%f pour float, %d pour int, %s pour string, etc.
print("Le formattage permet d'afficher seulement 3 chiffres : pi = %.3f, et e =%.3f"%(pi, e))
print("Le print d'une liste est la liste des prints : ", ["pi", pi])
print("\n On peut faire des sauts à la ligne avec \n et des tabulations avec \t.")
On peut mettre les arguments à la suite : pi = 3.141592653589793 et e = 2.718281828459045 C'est (presque) équivalent au formattage : pi = 3.141593 et e = 2.718282 Le formattage permet d'afficher seulement 3 chiffres : pi = 3.142, et e =2.718 Le print d'une liste est la liste des prints : ['pi', 3.141592653589793] On peut faire des sauts à la ligne avec et des tabulations avec .
Les booleans ont la valeur True ou False. La commande if prend un boolean en entrée. Voici quelques astuces
a = 2
if a == 2: # Attention, 2 signes == pour créer un boolean
print("cette phrase est lue")
if not (a != 2): # la négation se fait avec not, != signifie "n'est pas égale à"
print("celle là aussi")
# l'assertion permet d'arréter un code si une hypothèse n'est pas vérifiée
assert (a == 2) and (1 < 0), "Attention, il y a un problème"
cette phrase est lue celle là aussi
--------------------------------------------------------------------------- AssertionError Traceback (most recent call last) <ipython-input-13-4a39ac2fe6b8> in <module>() 7 8 # l'assertion permet d'arréter un code si une hypothèse n'est pas vérifiée ----> 9 assert (a == 2) and (1 < 0), "Attention, il y a un problème" AssertionError: Attention, il y a un problème
Le code en Python se veut très lisible, voici les choses à connaître :
#La liste vide
L = []
print("La liste vide : L =", L, "\n")
# range(n) ou range(0, n) renvoie la liste (0, 1, ..., n-1) sous forme "compacte"
print("range(5) = ", range(5))
print("mais aussi")
print("range(5) =", [i for i in range(5)], "\n")
# Création de liste par compréhension (plus lisible ET plus rapide !)
puissanceDe2 = [2**n for n in range(0,11)]
print("Les puissances de 2 sont", puissanceDe2)
# Ajouter un élément à une liste avec .append()
puissanceDe2.append(2**11)
print("Les puissances de 2 sont", puissanceDe2, "\n")
# Connaitre la taille de la liste avec len
print("Il y a", len(puissanceDe2),"éléments dans cette liste.")
La liste vide : L = [] range(5) = range(0, 5) mais aussi range(5) = [0, 1, 2, 3, 4] Les puissances de 2 sont [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] Les puissances de 2 sont [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048] Il y a 12 éléments dans cette liste.
On accède à un élément d'une liste avec des crochets.
Remarque : En Python,
On rappele que les indices commencent à 0 en Python.
L = [1,2,3,4,5]
print("L =", L)
print("Le premier élément est", L[0])
print("Le dernier élément est", L[-1]) #raccourci pour le dernier élément !
# On peut aussi accéder à une sous liste
print("L contient la sous liste", L[1:4]) # Ici, [1:4] est un raccourci pour range(1,4), et vaut [1, 2, 3]
L = [1, 2, 3, 4, 5] Le premier élément est 1 Le dernier élément est 5 L contient la sous liste [2, 3, 4]
Nous attaquons maintenant le calcul matriciel, les liste de Python ne conviennent pas (cf exemple suivant). Le bon type à utiliser est l'array. Celui-ci se trouve dans la librarie numpy
, qu'on a déjà chargé avec notre commande %pylab inline
.
L = [1,2,3]
Larray = array(L)
print("L =", L, "\t\t\t\t Larray =", Larray)
print("2*L =", 2*L, "\t\t 2*Larray =", 2*Larray)
L = [1, 2, 3] Larray = [1 2 3] 2*L = [1, 2, 3, 1, 2, 3] 2*Larray = [2 4 6] 2
Comme pour les listes, on accède aux éléments avec des crochets. Cependant, pour une matrice, il faut maintenant 2 paires de crochets !
A = array([[1, 2, 3], [4, 5, 6], [7,8,9]])
print("A = \n", A)
print("L'élément au milieu du bas est", A[2][1]) # de la forme A[i][j]
A = [[1 2 3] [4 5 6] [7 8 9]] L'élément au milieu du bas est 8
# Creation à partir d'une liste
x = array([1,2,3]) #Ici, une seule dimension --> un vecteur
# On obtient une matrice avec une liste de liste
# Dans ce cas, les matrices sont définies "lignes par lignes"
A = array([[1,2,3], [4,5,6], [7,8,9]])
print("A = \n", A, "\n\net\n\nA.transpose() = \n", A.transpose())
# On peut aussi définir "par compréhension" (plus lisible et plus rapide)
# Ici, une matrice de Vandermonde
A = array([[i**j for j in range(3)] for i in range(1,4)])
print("\n A = \n", A)
A = [[1 2 3] [4 5 6] [7 8 9]] et A.transpose() = [[1 4 7] [2 5 8] [3 6 9]] A = [[1 1 1] [1 2 4] [1 3 9]]
Python connait un certain nombre de matrices de référence. Nous utiliserons souvent les matrices suivantes.
# La matrice nulle prend des dimensions en entrée :
A = zeros([2,3]) #de taille 2 x 3.
print ("A = \n", A)
# La matrice avec que des 1 :
B = ones([2,3])
print ("\nB = \n", B)
# La matrice identité est carrée et ne prend qu'un seul paramètre :
A = eye(3)
print("\n A = \n", A)
A = [[0. 0. 0.] [0. 0. 0.]] B = [[1. 1. 1.] [1. 1. 1.]] A = [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]
ATTENTION, le produit de base de Python est le produit terme à terme, alors que le produit matriciel se fait avec dot.
x = array([1,2,3])
y = array([4,5,6])
print ("x =", x, "y =", y, ", x*y =", x*y, "et dot(x,y) =", dot(x,y))
x = [1 2 3] y = [4 5 6] , x*y = [ 4 10 18] et dot(x,y) = 32
ATTENTION Python fait la différence entre 1 et la matrice identité.
A = eye(3)
print("A + 1 =\n", A + 1)
A + 1 = [[ 2. 1. 1.] [ 1. 2. 1.] [ 1. 1. 2.]]
Python connait les fonctions "usuelles", à savoir déterminant, trace, norm, inv, ... On peut aussi résoudre des systèmes avec solve.
A = array([[(i-j)**2 for j in range(3)] for i in range(3)])
b = array([0,0,1])
x = solve(A,b) # La solution de Ax = b
print("On a bien | Ax - b | = ", norm(dot(A,x) - b))
On a bien | Ax - b | = 0.0
Exercice : Que vaut exp(eye(3)) ? Comment créer l'exponentielle de eye(3) ?
On utilise matplotlib pour tracer les graphiques. Là aussi, les fonctions sont directement accessible grâce à la directive %pylab
initiale.
La commande de base est plot(x,y)
où $x$ et $y$ sont des listes/array de même taille. En pratique, si on veut que $x$ représente l'intervalle $[a,b]$, on pourra utiliser la commande linspace
.
linspace?
Voici un exemple complet pour afficher le graphe d'une fonction $f$.
def f(x) : return x**4 - cos(2*pi*x) # La fonction f
xx=linspace(-1,1,100) # 100 points entre -1 et 1
plot(xx, f(xx), 'r') # 'r' pour red
axis('equal') # pour avoir la même échelle dans les deux axes
title("le graphe de $f$") # Les titres acceptent le Latex !
legend("f")
xlabel("x")
Text(0.5,0,'x')
Remarque : Ici, j'utilise la convention xx
pour désigner l'intervalle dans lequel vit x
. C'est une convention personnelle : pour moi, une variable doublée signifie toujours l'espace dans lequel vit la variable non doublée.
On peut aussi tracer facilement des courbes paramétrées. Pour tracer la courbe $$ c(t) = (\sin^3(t), \cos(t) - \cos^4(t)), $$ on peut utiliser le code suivant.
tt = linspace(0, 2*pi, 100)
xx = sin(tt)**3 # f(liste) = liste(f) !
yy = cos(tt) - cos(tt)**4
plot(xx,yy)
axis("equal")
title("Le coeur de Laporte (1993)")
<matplotlib.text.Text at 0x113e4f940>
Enfin, on peut tracer les courbes de niveau d'une fonction à deux variables avec contour
. Ici, on trace par exemple les courbes de niveau de
$$
f(x,y) = e^{-y^2} \sin(x-y)
$$
def f(x,y): return exp(-y**2)*sin(x-y)
xx =linspace(-3,3,150) # 150 points entre -3 et 3
yy =linspace(-2,2,100) # 100 points entre -2 et 2
Z = [[f(x,y) for x in xx] for y in yy] # Une liste de liste contenant les valeurs de f.
contour(xx,yy,Z,30) # Afficher 30 lignes de niveau
colorbar() # Si on veut une échelle des couleurs
<matplotlib.colorbar.Colorbar at 0x11409d2e8>
Note : ce Notebook a fortement été inspiré de celui d'Amic Frouvelle et de David Gontier (U. Paris-Dauphine)