SlideShare une entreprise Scribd logo
LES BASES DE LA PROGRAMMATION AVEC PYTHON 3
Plateforme ANACONDA : Programmation avec l’EDI Spyder et
les bibliothèques scientifiques Scipy
Support de cours est rédigé par Dr. Emeric Tapachès. C’est une compilation de tutoriels disponibles
sur http://pythonhosted.org/spyder/ et http://www.scipy-lectures.org/index.html
Algorithmique et
Programmation
Partie III
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
1 | P a g e E m e r i c T a p a c h è s
CONTENU
Préambule ............................................................................................................................................... 2
1 Syper : Environnement de Développement Intégré ....................................................................... 2
2 Les bibliothèques scientifiques ScyPY............................................................................................. 3
3 NumPy ............................................................................................................................................. 4
3.1 Création de matrice à partir de fonctions............................................................................... 4
3.1.1 La fonction array() :......................................................................................................... 4
3.1.2 Les fonctions arange() et linspace() :............................................................................... 5
3.1.3 Autres fonctions permettant de créer des matrices....................................................... 6
3.2 Manipulation des matrices...................................................................................................... 6
3.2.1 Indexation........................................................................................................................ 6
3.2.2 Redimensionnement ....................................................................................................... 8
3.2.3 Calculs sur élément ......................................................................................................... 9
3.2.4 Calculs sur les lignes et les colonnes ............................................................................. 10
3.2.5 Calculs matriciels........................................................................................................... 11
4 Matplotlib...................................................................................................................................... 13
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
2 | P a g e E m e r i c T a p a c h è s
PREAMBULE
Tout d’abord, dans la première partie de ce cours l’histoire de l’informatique, l’architecture d’un
ordinateur, la représentation de l’information et l’abstraction du langage machine ont été abordées.
Ensuite, la deuxième partie a été consacrée aux bases de la programmation en Python « pure » à
partir de l’invite de commande de Windows. Enfin, cette troisième partie du cours est consacrée à la
programmation dans l’Environnement de Développement Intégré (IDE) Spyder et à la découverte des
bibliothèques scientifiques SciPy. Pour suivre ce cours, il faut au préalable installer la plateforme
ANACONDA (voir partie II du cours).
1 SYPER : ENVIRONNEMENT DE DEVELOPPEMENT INTEGRE
D’après https://fr.wikipedia.org/wiki/Environnement_de_d%C3%A9veloppement ,
http://pythonhosted.org/spyder/.
Un Environnement de Développement Intégré (EDI), ou IDE (Integrated Development Environment)
est un ensemble d'outils destinés à programmer dans un langage donné, qui sont distribués
ensemble. Il permet de manipuler les outils de programmation depuis une interface graphique
simplifiée.
Un EDI comporte au moins:
 Une interface graphique qui permet notamment de sélectionner les fichiers, définir les
options, lancer les opérations.
 Un éditeur de code source avec coloration syntaxique.
 La configuration d'un compilateur.
 D'un éditeur de liens.
 Un constructeur (outil make intégré). Il passe les commandes au compilateur et à l'éditeur de
lien avec les fichiers sources ou les modules objets en paramètres.
 Un outil de déboguage.
Spyper est un EDI pour langage Python dédié aux calculs scientifiques. Certaines bibliothèques
scientifiques de SciPy sont importées par défaut au lancement de l’EDI :
 Numpy : import numpy as np
 Matplotlib : from matplotlib import pyplot as plt / import matplotlib.pyplot as plt
Vous pouvez tapez help(np) et help(plt) pour découvrir les fonctions associées à ces modules. Dans la
suite de ce cours nous allons apprendre à utiliser certaines de ces fonctions.
Par défaut, lors de son ouverture l’interface graphique de Spyder se compose de trois volets. Il a y :
 L’éditeur de scripts Pyhton qui permet l’élaboration de programme de façon assisté (syntaxe
automatique, identification des erreurs de syntaxe, aide dynamique, coloration spécifique du
code, indentation automatique, analyse du code, débogage…).
 L’explorateur qui permet d’explorer :
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
3 | P a g e E m e r i c T a p a c h è s
o Les variables en mémoires en indiquant leur nom, leur type, leur taille et leur
contenu.
o Les fichiers et gérer leur emplacement.
 La console ou l’invite de commande qui permet d’écrire les instructions à exécuter. La
console IPython est proposée par défaut. Cette invite commande améliorée offre des
possibilités de programmation assistée similaire à l’éditeur de scripts.
FIGURE 1 : INTERFACE GRAPHIQUE DE SPYDER
2 LES BIBLIOTHEQUES SCIENTIFIQUES SCYPY
Les bibliothèques sont en fait des modules comme vu dans la partie II de ce cours. Ces modules ou
bibliothèques regroupent des fonctions optimisées liées à un même domaine. Ces modules ont été
créés par d’autres développeurs avant vous. Cela permet d’utiliser et de ne pas réécrire des
morceaux de code qui ont déjà écrit, très souvent, mieux par d’autres.
D’après https://openclassrooms.com/courses/apprenez-a-programmer-en-python/qu-est-ce-que-
python.
Scipy est une communauté de développeurs qui ont décidé de réunir dans des packages des
bibliothèques dédiées spécifiquement aux domaines des mathématiques, des sciences et de
l’ingénierie.
Scipy propose six packages principaux :
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
4 | P a g e E m e r i c T a p a c h è s
FIGURE 2 : PRINCIPAUX PACKAGES DE SCIPY
 NumPy est dédié principalement à l’algèbre linéaire et plus particulièrement aux calculs
matriciels.
 SciPy library est dédié à l’analyse. Ce package regroupe des outils permettant de faire, par
exemple, du traitement de signal, de l’optimisation, des statistique…
 Matplotlib offre de nombreux outils pour la visualisation/représentation de données en 2D
et 3D.
 Pandas offre des outils pour gérer et analyser des quantités importantes de données en les
structurant de façon efficace.
 SymPy permet de faire du calcul formel.
 IPython : invite de commande interactive.
3 NUMPY
D’après http://www.scipy-lectures.org/intro/numpy/index.html.
La bibliothèque NumPy est déjà importée par défaut à l’ouverture de Spyder. Toutefois, si vous devez
importer NumPy l’instruction courante est :
>>> import numpy as np
Les fonctions NumPy permettent de manipuler de façon optimisée des tableaux à n-dimension de
nombres (entiers, décimaux, complexes…).
3.1 CREATION DE MATRICE A PARTIR DE FONCTIONS
3.1.1 LA FONCTION ARRAY() :
1-dimension :
>>> a = np.array([0, 1, 2, 3])
>>> a
array([0, 1, 2, 3])
>>> print(a)
[0 1 2 3]
>>> a.ndim
1
>>> a.shape
(4,)
>>> a.dtype
dtype('int32')
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
5 | P a g e E m e r i c T a p a c h è s
ndim permet de connaitre la dimension du tableau (la matrice). shape permet de connaitre la taille
de la du tableau (la matrice). dtype permet de connaitre le type des éléments du tableau.
2-dimension :
>>> b = np.array([[0., 1., 2.], [3., 4., 5.]])
>>> b
array([[ 0., 1., 2.],
[ 3., 4., 5.]])
>>> print(b)
[[ 0. 1. 2.]
[ 3. 4. 5.]]
>>> b.ndim
2
>>> b.shape
(2, 3)
>>> b.dtype
dtype('float64')
3-dimension :
>>> c = np.array([ [ [1,1] , [2,2] ] , [ [3,3] , [4,4] ] , [ [5,5] ,
[6,6] ] ])
>>> c
array([[[1, 1],
[2, 2]],
[[3, 3],
[4, 4]],
[[5, 5],
[6, 6]]])
>>> c.ndim
3
>>> c.shape
(3, 2, 2)
3.1.2 LES FONCTIONS ARANGE() ET LINSPACE() :
arange() est analogue à la fonction range() (voir partie II du cours). Cette fonction permet de générer
une progression arithmétique sous forme d’un vecteur.
>>> a = np.arange(10)
>>> print(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> b = np.arange(1, 9, 2) # début, fin (exclu), pas
>>> print(b)
[1, 3, 5, 7]
linspace() permet de générer un nombre fini de points régulièrement espacés entre deux bornes.
>>> c = np.linspace(0, 1, 6
>>> print(c)
[0. , 0.2, 0.4, 0.6, 0.8, 1. ]
>>>
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
6 | P a g e E m e r i c T a p a c h è s
>>> d = np.linspace(0, 1, 5, endpoint=False) #5 éléments, hormis la
borne de fin
>>> print(d)
[ 0. , 0.2, 0.4, 0.6, 0.8]
3.1.3 AUTRES FONCTIONS PERMETTANT DE CREER DES MATRICES
ones() permet de générer une matrice remplie avec la valeur 1 en format float.
>>> a = np.ones((3, 3))
>>> print(a)
[[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]]
zeros() permet des générer une matrice remplie avec la valeur 0 en format float.
>>> b = np.zeros((2, 2))
>>> print(b)
[[ 0. 0.]
[ 0. 0.]]
eyes() permet de générer une matrice identité (matrice carrée par conséquent).
c = np.eye(3)
>>> print(c)
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
diag() permet de générer une matrice diagonale (matrice carrée par conséquent).
>>> d = np.diag(np.array([1, 2, 3, 4]))
>>> print(d)
[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]
random.rand() permet de générer un vecteur avec des nombres aléatoires entre 0 et 1 selon une loi
uniforme.
>>> a = np.random.rand(4)
>>> a
[ 0.95799151, 0.14222247, 0.08777354, 0.51887998]
3.2 MANIPULATION DES MATRICES
3.2.1 INDEXATION
>>> a = np.arange(10)
>>> print(a)
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
7 | P a g e E m e r i c T a p a c h è s
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[0], a[2], a[-1]
(0, 2, 9)
>>>
>>> a[2:9:3] # [début:fin:pas]
array([2, 5, 8])
>>>
>>> a[:4]
array([0, 1, 2, 3])
>>>
>>> a[1:3]
array([1, 2])
>>>
>>> a[::2]
array([0, 2, 4, 6, 8])
>>>
>>> a[3:]
array([3, 4, 5, 6, 7, 8, 9])
Même logique que pour les chaines de caractères (voir partie II) du cours.
>>> a = np.diag(np.arange(3))
>>> print(a)
[[0 0 0]
[0 1 0]
[0 0 2]]
>>> a[1, 1] # élément de la deuxième ligne, deuxième colonne
1
>>> a[2, 1] = 10 # modification de l’élément en troisième ligne,
deuxième colonne
>>>
>>> print(a)
[[ 0, 0, 0],
[ 0, 1, 0],
[ 0, 10, 2]]
>>>
>>> a[1] # deuxième ligne
[0, 1, 0]
Exemple par l’image :
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
8 | P a g e E m e r i c T a p a c h è s
FIGURE 3 : INDEXATION DE TABLEAU (SOURCE : SCIPY)
3.2.2 REDIMENSIONNEMENT
Passez d’une matrice à un vecteur avec la fonction ravel() :
>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> print(a)
[[1 2 3]
[4 5 6]]
>>>
>>> a.ravel()
array([1, 2, 3, 4, 5, 6])
>>> print(a) #la fonction ravel ne modifie pas les
dimension de a
[[1 2 3]
[4 5 6]]
>>>
>>> a = a.ravel() #a a été passé en vecteur
>>> print(a)
[1 2 3 4 5 6]
Modifiez les dimensions d’une matrice avec la fonction reshape() :
>>> a = np.array( [[1,2,3],[4,5,6]] )
>>> a.shape
(2, 3)
>>> print(a)
[[1 2 3]
[4 5 6]]
>>> print(a.reshape(3,2))
[[1 2]
[3 4]
[5 6]]
>>> print(a.reshape(6,1))
[[1]
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
9 | P a g e E m e r i c T a p a c h è s
[2]
[3]
[4]
[5]
[6]]
Concaténer des matrices avec la fonction np.concatenate() :
>>> a
array([[1, 1],
[1, 1]])
>>> b
array([[2, 2],
[2, 2]])
>>>
>>> c = np.concatenate((a,b),axis=1)
>>> print(c)
[[1 1 2 2]
[1 1 2 2]]
>>> c = np.concatenate((a,b),axis=0)
>>> print(c)
[[1 1]
[1 1]
[2 2]
[2 2]]
3.2.3 CALCULS SUR ELEMENT
Opération sur les éléments :
>>> a = np.array([1, 2, 3, 4])
>>> a + 1
array([2, 3, 4, 5])
>>> 2**a
array([ 2, 4, 8, 16])
>>> b = np.ones(4) + 1
>>> a - b
array([-1., 0., 1., 2.])
>>> a * b
array([ 2., 4., 6., 8.])
>>> a = np.arange(5)
>>> print(np.sin(a))
[ 0. , 0.84147098, 0.90929743, 0.14112001, -0.7568025 ]
>>>
>>> print(np.log(a))
[ -inf, 0. , 0.69314718, 1.09861229, 1.38629436]
>>>
>>> print(np.exp(a))
[ 1. , 2.71828183, 7.3890561 , 20.08553692, 54.59815003]
Test sur les éléments:
La fonction nonzeros() est très utile pour tester les éléments d’une matrice. Cette fonction retourne
l’indice des éléments qui satisfassent la condition :
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
10 | P a g e E m e r i c T a p a c h è s
>>> a = np.random.rand(25).reshape(5,5)
>>> print(a)
[[ 0.12069897 0.35463466 0.22703164 0.49814117 0.55222531]
[ 0.01628109 0.84083704 0.0994604 0.47515089 0.70177187]
[ 0.79003425 0.96155964 0.73164089 0.04653678 0.60433922]
[ 0.71714583 0.49786245 0.11338165 0.10164041 0.28502373]
[ 0.46506279 0.3845595 0.75339083 0.99563566 0.3884443 ]]
>>>
>>> ind = np.nonzero( a >= 0.5 )
>>>
>>> print(ind)
(array([0, 1, 1, 2, 2, 2, 2, 3, 4, 4], dtype=int64), array([4, 1, 4, 0,
1, 2, 4, 0, 2, 3], dtype=int64))
>>>
>>> a[ind[0], ind[1]]
array([ 0.55222531, 0.84083704, 0.70177187, 0.79003425, 0.96155964,
0.73164089, 0.60433922, 0.71714583, 0.75339083,
0.99563566])
Autre solution : l’indexation conditionnelle.
>>> a = np.random.rand(25).reshape(5,5)
>>> print(a)
[[ 0.12069897 0.35463466 0.22703164 0.49814117 0.55222531]
[ 0.01628109 0.84083704 0.0994604 0.47515089 0.70177187]
[ 0.79003425 0.96155964 0.73164089 0.04653678 0.60433922]
[ 0.71714583 0.49786245 0.11338165 0.10164041 0.28502373]
[ 0.46506279 0.3845595 0.75339083 0.99563566 0.3884443 ]]
>>>
>>> ind = np.nonzero( a >= 0.5 )
>>>
>>> a[(a>=0.5)]
array([ 0.55222531, 0.84083704, 0.70177187, 0.79003425, 0.96155964,
0.73164089, 0.60433922, 0.71714583, 0.75339083,
0.99563566])
>>>
>>> a >= 0.5
array([[False, False, False, False, True],
[False, True, False, False, True],
[ True, True, True, False, True],
[ True, False, False, False, False],
[False, False, True, True, False]], dtype=bool)
3.2.4 CALCULS SUR LES LIGNES ET LES COLONNES
Somme :
>>> a = np.arange(25).reshape((5,5))
>>> print(a)
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]
[20 21 22 23 24]]
>>>
>>> np.sum(a)
300
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
11 | P a g e E m e r i c T a p a c h è s
>>>
>>> np.sum(a, axis=0)
array([50, 55, 60, 65, 70])
>>> np.sum(a, axis=1)
array([ 10, 35, 60, 85, 110])
La syntaxe est la même pour les fonctions suivantes :
 max() retourne le plus grand nombre d’une matrice ou de chaque ligne ou de chaque
colonne,
 min() retourne le plus petit nombre d’une matrice ou de chaque ligne ou de chaque
colonne,
 mean() retourne la moyenne d’une matrice ou de chaque ligne ou de chaque colonne,
 median() retourne la médiane d’une matrice ou de chaque ligne ou de chaque colonne,
 std() retourne l’écart-type d’une matrice ou de chaque ligne ou de chaque colonne,
 argmin() retourne l’indice de la valeur minimum d’une matrice ou de chaque ligne ou de
chaque colonne,
 argmax() retourne l’indice de la valeur maximum d’une matrice ou de chaque ligne ou de
chaque colonne.
3.2.5 CALCULS MATRICIELS
Exercice : A l’aide de boucle « for », créer une fonction permettant de faire le produire de deux
matrices et de retourner le résultat de ce produit.
La fonction permettant de faire le produit matriciel existe déjà dans NumPy, c’est la fonction
np.dot() :
>>> a = np.arange(6).reshape(2,3)
>>> print(a)
[[0 1 2]
[3 4 5]]
>>>
>>> b = np.arange(15).reshape(3,5)
>>> print(b)
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
>>>
>>> c = np.dot(a,b)
>>> print(c)
[[ 25 28 31 34 37]
[ 70 82 94 106 118]]
>>>
>>> c = a.dot(b) #autre syntaxe
>>> print(c)
[[ 25 28 31 34 37]
[ 70 82 94 106 118]]
>>>
>>> c = b.dot(a)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: shapes (3,5) and (2,3) not aligned: 5 (dim 1) != 2 (dim 0)
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
12 | P a g e E m e r i c T a p a c h è s
La transposé d’une matrice s’obtient avec la fonction np.tanspose() ou a.T :
>>> a = np.arange(15).reshape(3,5)
>>> print(a)
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
>>>
>>> a.T
array([[ 0, 5, 10],
[ 1, 6, 11],
[ 2, 7, 12],
[ 3, 8, 13],
[ 4, 9, 14]])
>>>
>>> a
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
>>>
>>> np.transpose(a)
array([[ 0, 5, 10],
[ 1, 6, 11],
[ 2, 7, 12],
[ 3, 8, 13],
[ 4, 9, 14]])
>>>
>>> a
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
Le déterminant d’une matrice s’obtient avec la fonction np.linalg.det() :
>>> a = np.arange(4) + 1
>>> a = a.reshape(2,2)
>>> print(a)
[[1 2]
[3 4]]
>>> np.linalg.det(a)
-2.0000000000000004
L’inverse d’une matrice inversible s’obtient avec la fonction np.linalg.inv() :
>>> a = np.arange(4) + 1
>>> a = a.reshape(2,2)
>>> print(a)
[[1 2]
[3 4]]
>>> np.linalg.inv(a)
array([[-2. , 1. ],
[ 1.5, -0.5]])
Résolution d’un système matriciel : Par exemple, résolution du système suivant :
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
13 | P a g e E m e r i c T a p a c h è s
0 1
0 1
3 9
(S)
2 8
x x
a x b
x x
  
  
  
>>> a = np.array([[3,1], [1,2]])
>>> b = np.array([9,8])
>>> x = np.linalg.solve(a, b)
>>> x
array([ 2., 3.])
D’où 0 2.0x  et 1 3.0x  .
4 MATPLOTLIB
Matplotlib offre plusieurs fonctionnalités pour créer des graphiques 2-D et 3-D.
L’instruction pour appeler ce package est :
from matplotlitb import pyplot as plt
Tracer une courbe revient à tracer une série de points repérés par des coordonnées. Traçons les
fonctions sinus et cosinus entre –PI et PI. D’abord, il faut définir le vecteur correspondant aux
abscisses (première dimension).
X = np.linspace(-np.pi, np.pi, 100) #vecteur de 100 éléments entre –PI
et PI
Puis, l’on créé le vecteur correspondant aux ordonnées (deuxième dimension), tel que X  cos(X) et
X  sin(X) :
C, S = np.cos(X), np.sin(X) #C, S sont deux vecteurs de 100 éléments
Ensuite, nous utilisons la fonction plt.plot() pour tracer les valeurs des ordonnées en fonction des
valeurs des abscisses, tel que :
>>> plt.plot(X, C)
>>> plt.plot(X, S)
La figure suivante doit apparaitre :
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
14 | P a g e E m e r i c T a p a c h è s
La figure apparait avec des paramètres d’affichage par défaut (taille, couleur, épaisseurs des traits…).
Il est possible de modifier ces paramètres d’affichage. Changez la couleur, l’épaisseur et le style du
trait…
>>> plt.plot(X, C, color="black", linewidth=2.5, linestyle="-")
>>> plt.plot(X, S, color="red", linewidth=4, linestyle="-")
Pour changer l’affichage des courbes, il faut changer les valeurs des paramètres par défaut à l’aide de
mots-clés. Voici la liste des mots-clés :
FIGURE 4 : PROPRIÉTÉS D'AFFICHAGE DES LIGNES
Il y a plusieurs styles de lignes. Pour y accéder il faut indiquer l’un des symboles présentés sur la
première ligne de la figure suivante :
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
15 | P a g e E m e r i c T a p a c h è s
FIGURE 5 : STYLE DE LIGNE
De même pour les marqueurs :
FIGURE 6 : LES MARQUEURS
Il est possible de modifier les limites d’affichage, par exemple :
>>> plt.xlim(0,np.pi)
>>> plt.ylim(0,1)
>>>
>>> # ou
>>>
>>> plt.xlim(X.min() * 1.1, X.max() * 1.1)
>>> plt.ylim(C.min() * 1.1, C.max() * 1.1)
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
16 | P a g e E m e r i c T a p a c h è s
Il est possible de contrôler les valeurs affichées en abscisse et en ordonnées :
>>> plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi])
>>> plt.yticks([-1, 0, +1])
ou de mettre du texte :
>>> plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
[r'$-pi$', r'$-pi/2$', r'$0$', r'$+pi/2$', r'$+pi$'])
>>>
>>> plt.yticks([-1, 0, +1],
[r'$-1$', r'$0$', r'$+1$'])
Il est possible de modifier la position des axes :
>>> ax = plt.gca() # gca stands for 'get current axis'
>>> ax.spines['right'].set_color('none')
>>> ax.spines['top'].set_color('none')
>>> ax.xaxis.set_ticks_position('bottom')
>>> ax.spines['bottom'].set_position(('data',0))
>>> ax.yaxis.set_ticks_position('left')
>>> ax.spines['left'].set_position(('data',0))
Pour ajouter une légende, il faut d’abord associer à chaque courbe une chaine de caractères à la
propriété « label » :
plt.plot(X, C, color="blue", linewidth=2.5, linestyle="-",
label="cosinus")
plt.plot(X, S, color="red", linewidth=2.5, linestyle="-",
label="sinus")
Ensuite, il faut appeler la fonction « legend » :
plt.legend(loc='upper left')
Le paramètre « loc » pour « location » permet d’indiquer la position de la légende.
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
17 | P a g e E m e r i c T a p a c h è s
L’on peut afficher plusieurs graphiques sur une même figure à l’aide de la fonction plt.subplot(), par
exemple pour :
>>> def f(t):
... return np.exp(-t) * np.cos(2*np.pi*t)
...
>>> t1 = np.arange(0.0, 5.0, 0.1)
>>> t2 = np.arange(0.0, 5.0, 0.02)
>>>
>>> plt.figure(1)
>>> plt.subplot(211)
>>> plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')
>>>
>>> plt.subplot(212)
>>> plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
>>> plt.show()
>>>
L’on obtient :
Disposition des graphiques avec plt.subplot() :
La fonction plt.imshow() permet d’afficher une fonction à deux variables ou les valeurs d’un tableau,
par exemple :
>>> def f(x, y):
... return (1 - x / 2 + x ** 5 + y ** 3) * np.exp(-x ** 2 - y ** 2)
...
>>> n = 10
>>> x = np.linspace(-3, 3, 4 * n)
>>> y = np.linspace(-3, 3, 3 * n)
A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I
18 | P a g e E m e r i c T a p a c h è s
>>> X, Y = np.meshgrid(x, y)
>>> plt.imshow(f(X, Y))
>>> plt.show()
L’on obtient :
D’autres exemples de graphiques sont présentés sur le lien suivant : http://www.scipy-
lectures.org/intro/matplotlib/matplotlib.html#other-types-of-plots-examples-and-exercises

Contenu connexe

Tendances

Chap XIII : calcul scientifique avec python
Chap XIII : calcul scientifique avec pythonChap XIII : calcul scientifique avec python
Chap XIII : calcul scientifique avec python
Mohammed TAMALI
 
Atelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El HassaniAtelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El Hassani
Shellmates
 
Formation iPhone ENSI by (Orange Tunisie)
Formation iPhone ENSI by (Orange Tunisie)Formation iPhone ENSI by (Orange Tunisie)
Formation iPhone ENSI by (Orange Tunisie)
Farouk Mezghich
 

Tendances (20)

Chap1 Introduction à python
Chap1 Introduction à pythonChap1 Introduction à python
Chap1 Introduction à python
 
La programmation modulaire en Python
La programmation modulaire en PythonLa programmation modulaire en Python
La programmation modulaire en Python
 
Python avancé : Lecture et écriture de fichiers
Python avancé : Lecture et écriture de fichiersPython avancé : Lecture et écriture de fichiers
Python avancé : Lecture et écriture de fichiers
 
Chap XIII : calcul scientifique avec python
Chap XIII : calcul scientifique avec pythonChap XIII : calcul scientifique avec python
Chap XIII : calcul scientifique avec python
 
Chap3 programmation modulaire en python
Chap3 programmation modulaire en pythonChap3 programmation modulaire en python
Chap3 programmation modulaire en python
 
Python
PythonPython
Python
 
Atelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El HassaniAtelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El Hassani
 
TP4 Atelier C++ /GL2 INSAT / Tunisie
TP4 Atelier C++ /GL2 INSAT / TunisieTP4 Atelier C++ /GL2 INSAT / Tunisie
TP4 Atelier C++ /GL2 INSAT / Tunisie
 
Formation python
Formation pythonFormation python
Formation python
 
C1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieC1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partie
 
Python avancé : Gestion d'erreurs et mécanisme d'exception
Python avancé : Gestion d'erreurs et mécanisme d'exceptionPython avancé : Gestion d'erreurs et mécanisme d'exception
Python avancé : Gestion d'erreurs et mécanisme d'exception
 
Interception de signal avec dump de la pile d'appel
Interception de signal avec dump de la pile d'appelInterception de signal avec dump de la pile d'appel
Interception de signal avec dump de la pile d'appel
 
Python For Data Science - French Course
Python For Data Science - French CoursePython For Data Science - French Course
Python For Data Science - French Course
 
Développement informatique : Programmation graphique
Développement informatique : Programmation graphiqueDéveloppement informatique : Programmation graphique
Développement informatique : Programmation graphique
 
Cours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMACours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMA
 
Développer en natif avec C++11
Développer en natif avec C++11Développer en natif avec C++11
Développer en natif avec C++11
 
C++11 en 12 exemples simples
C++11 en 12 exemples simplesC++11 en 12 exemples simples
C++11 en 12 exemples simples
 
Johnny-Five : Robotique et IoT en JavaScript
Johnny-Five : Robotique et IoT en JavaScriptJohnny-Five : Robotique et IoT en JavaScript
Johnny-Five : Robotique et IoT en JavaScript
 
Python avancé : Qualité de code et convention de codage
Python avancé : Qualité de code et convention de codagePython avancé : Qualité de code et convention de codage
Python avancé : Qualité de code et convention de codage
 
Formation iPhone ENSI by (Orange Tunisie)
Formation iPhone ENSI by (Orange Tunisie)Formation iPhone ENSI by (Orange Tunisie)
Formation iPhone ENSI by (Orange Tunisie)
 

En vedette

La guerre d'algérie en images
La guerre d'algérie en imagesLa guerre d'algérie en images
La guerre d'algérie en images
Dande1941
 

En vedette (20)

Rendez votre code Python plus beau !
Rendez votre code Python plus beau !Rendez votre code Python plus beau !
Rendez votre code Python plus beau !
 
Python packaging
Python packagingPython packaging
Python packaging
 
SGBDR - ACCESS
SGBDR - ACCESSSGBDR - ACCESS
SGBDR - ACCESS
 
Python et les bases de données non sql
Python et les bases de données non sqlPython et les bases de données non sql
Python et les bases de données non sql
 
Base NoSql et Python
Base NoSql et PythonBase NoSql et Python
Base NoSql et Python
 
Bonnes pratiques de developpement en PHP
Bonnes pratiques de developpement en PHPBonnes pratiques de developpement en PHP
Bonnes pratiques de developpement en PHP
 
Algorithmique et programmation en Pascal (résumé)
Algorithmique et programmation en Pascal (résumé)Algorithmique et programmation en Pascal (résumé)
Algorithmique et programmation en Pascal (résumé)
 
La guerre d'algérie en images
La guerre d'algérie en imagesLa guerre d'algérie en images
La guerre d'algérie en images
 
Développement de la personnalité : La désintégration positive
Développement de la personnalité : La désintégration positiveDéveloppement de la personnalité : La désintégration positive
Développement de la personnalité : La désintégration positive
 
Seminaire Borland UML (2003)
Seminaire Borland UML (2003)Seminaire Borland UML (2003)
Seminaire Borland UML (2003)
 
Algorithmique iv
Algorithmique ivAlgorithmique iv
Algorithmique iv
 
Algorithmique ii
Algorithmique iiAlgorithmique ii
Algorithmique ii
 
Algorithmique v
Algorithmique vAlgorithmique v
Algorithmique v
 
Algorithmique iii
Algorithmique iiiAlgorithmique iii
Algorithmique iii
 
Algorithmique
AlgorithmiqueAlgorithmique
Algorithmique
 
Info1 cours 3-codage-mi-sys num
Info1  cours 3-codage-mi-sys numInfo1  cours 3-codage-mi-sys num
Info1 cours 3-codage-mi-sys num
 
Codage cours 2-software-mi-
Codage  cours 2-software-mi-Codage  cours 2-software-mi-
Codage cours 2-software-mi-
 
Info1 cours 1-software-st&sm1-mi-
Info1  cours 1-software-st&sm1-mi-Info1  cours 1-software-st&sm1-mi-
Info1 cours 1-software-st&sm1-mi-
 
Wordpress : Attaque, Audit et Protection | Hackfest 2015
Wordpress : Attaque, Audit et Protection | Hackfest 2015Wordpress : Attaque, Audit et Protection | Hackfest 2015
Wordpress : Attaque, Audit et Protection | Hackfest 2015
 
1er cours
1er cours1er cours
1er cours
 

Similaire à Algorithmique_et_programmation_part3_V2

Projet1 mastermind 2010-2011
Projet1 mastermind 2010-2011Projet1 mastermind 2010-2011
Projet1 mastermind 2010-2011
nadi noura
 
Theme1 (1)
Theme1 (1)Theme1 (1)
Theme1 (1)
salmazen
 
Chapitre 1 (algorithme)
Chapitre 1 (algorithme)Chapitre 1 (algorithme)
Chapitre 1 (algorithme)
mahbouba
 
COURS C++ [Enregistrement automatique]Complet (1).pptx
COURS C++ [Enregistrement automatique]Complet (1).pptxCOURS C++ [Enregistrement automatique]Complet (1).pptx
COURS C++ [Enregistrement automatique]Complet (1).pptx
LuneSabsPericolo1
 

Similaire à Algorithmique_et_programmation_part3_V2 (20)

Mathématiques et Python
Mathématiques et PythonMathématiques et Python
Mathématiques et Python
 
Python.pptx
Python.pptxPython.pptx
Python.pptx
 
Support Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptxSupport Formation Samsung - Python - Session 1 - 2022.pptx
Support Formation Samsung - Python - Session 1 - 2022.pptx
 
Rapport Projet Module Complexité
Rapport Projet Module ComplexitéRapport Projet Module Complexité
Rapport Projet Module Complexité
 
Programmation en Python CPGE sup management
Programmation en Python CPGE sup managementProgrammation en Python CPGE sup management
Programmation en Python CPGE sup management
 
Tp python
Tp pythonTp python
Tp python
 
Tp python dauphine
Tp python dauphineTp python dauphine
Tp python dauphine
 
FormationPython2019.pptx
FormationPython2019.pptxFormationPython2019.pptx
FormationPython2019.pptx
 
Introduction&composants
Introduction&composantsIntroduction&composants
Introduction&composants
 
BigData_TP2: Design Patterns dans Hadoop
BigData_TP2: Design Patterns dans HadoopBigData_TP2: Design Patterns dans Hadoop
BigData_TP2: Design Patterns dans Hadoop
 
Projet1 mastermind 2010-2011
Projet1 mastermind 2010-2011Projet1 mastermind 2010-2011
Projet1 mastermind 2010-2011
 
Theme1 (1)
Theme1 (1)Theme1 (1)
Theme1 (1)
 
Chapitre 1 (algorithme)
Chapitre 1 (algorithme)Chapitre 1 (algorithme)
Chapitre 1 (algorithme)
 
Langage C
Langage CLangage C
Langage C
 
OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...
OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...
OSIS18_IoT: L'approche machine virtuelle pour les microcontrôleurs, le projet...
 
cours d'algorithmique et programmation 3sc final .pdf
cours d'algorithmique et programmation 3sc final .pdfcours d'algorithmique et programmation 3sc final .pdf
cours d'algorithmique et programmation 3sc final .pdf
 
Formation python 3
Formation python 3Formation python 3
Formation python 3
 
Monkey & Monkey Runner
Monkey & Monkey RunnerMonkey & Monkey Runner
Monkey & Monkey Runner
 
COURS C++ [Enregistrement automatique]Complet (1).pptx
COURS C++ [Enregistrement automatique]Complet (1).pptxCOURS C++ [Enregistrement automatique]Complet (1).pptx
COURS C++ [Enregistrement automatique]Complet (1).pptx
 
Fascicule tp programmation c
Fascicule tp programmation cFascicule tp programmation c
Fascicule tp programmation c
 

Algorithmique_et_programmation_part3_V2

  • 1. LES BASES DE LA PROGRAMMATION AVEC PYTHON 3 Plateforme ANACONDA : Programmation avec l’EDI Spyder et les bibliothèques scientifiques Scipy Support de cours est rédigé par Dr. Emeric Tapachès. C’est une compilation de tutoriels disponibles sur http://pythonhosted.org/spyder/ et http://www.scipy-lectures.org/index.html Algorithmique et Programmation Partie III
  • 2. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 1 | P a g e E m e r i c T a p a c h è s CONTENU Préambule ............................................................................................................................................... 2 1 Syper : Environnement de Développement Intégré ....................................................................... 2 2 Les bibliothèques scientifiques ScyPY............................................................................................. 3 3 NumPy ............................................................................................................................................. 4 3.1 Création de matrice à partir de fonctions............................................................................... 4 3.1.1 La fonction array() :......................................................................................................... 4 3.1.2 Les fonctions arange() et linspace() :............................................................................... 5 3.1.3 Autres fonctions permettant de créer des matrices....................................................... 6 3.2 Manipulation des matrices...................................................................................................... 6 3.2.1 Indexation........................................................................................................................ 6 3.2.2 Redimensionnement ....................................................................................................... 8 3.2.3 Calculs sur élément ......................................................................................................... 9 3.2.4 Calculs sur les lignes et les colonnes ............................................................................. 10 3.2.5 Calculs matriciels........................................................................................................... 11 4 Matplotlib...................................................................................................................................... 13
  • 3. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 2 | P a g e E m e r i c T a p a c h è s PREAMBULE Tout d’abord, dans la première partie de ce cours l’histoire de l’informatique, l’architecture d’un ordinateur, la représentation de l’information et l’abstraction du langage machine ont été abordées. Ensuite, la deuxième partie a été consacrée aux bases de la programmation en Python « pure » à partir de l’invite de commande de Windows. Enfin, cette troisième partie du cours est consacrée à la programmation dans l’Environnement de Développement Intégré (IDE) Spyder et à la découverte des bibliothèques scientifiques SciPy. Pour suivre ce cours, il faut au préalable installer la plateforme ANACONDA (voir partie II du cours). 1 SYPER : ENVIRONNEMENT DE DEVELOPPEMENT INTEGRE D’après https://fr.wikipedia.org/wiki/Environnement_de_d%C3%A9veloppement , http://pythonhosted.org/spyder/. Un Environnement de Développement Intégré (EDI), ou IDE (Integrated Development Environment) est un ensemble d'outils destinés à programmer dans un langage donné, qui sont distribués ensemble. Il permet de manipuler les outils de programmation depuis une interface graphique simplifiée. Un EDI comporte au moins:  Une interface graphique qui permet notamment de sélectionner les fichiers, définir les options, lancer les opérations.  Un éditeur de code source avec coloration syntaxique.  La configuration d'un compilateur.  D'un éditeur de liens.  Un constructeur (outil make intégré). Il passe les commandes au compilateur et à l'éditeur de lien avec les fichiers sources ou les modules objets en paramètres.  Un outil de déboguage. Spyper est un EDI pour langage Python dédié aux calculs scientifiques. Certaines bibliothèques scientifiques de SciPy sont importées par défaut au lancement de l’EDI :  Numpy : import numpy as np  Matplotlib : from matplotlib import pyplot as plt / import matplotlib.pyplot as plt Vous pouvez tapez help(np) et help(plt) pour découvrir les fonctions associées à ces modules. Dans la suite de ce cours nous allons apprendre à utiliser certaines de ces fonctions. Par défaut, lors de son ouverture l’interface graphique de Spyder se compose de trois volets. Il a y :  L’éditeur de scripts Pyhton qui permet l’élaboration de programme de façon assisté (syntaxe automatique, identification des erreurs de syntaxe, aide dynamique, coloration spécifique du code, indentation automatique, analyse du code, débogage…).  L’explorateur qui permet d’explorer :
  • 4. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 3 | P a g e E m e r i c T a p a c h è s o Les variables en mémoires en indiquant leur nom, leur type, leur taille et leur contenu. o Les fichiers et gérer leur emplacement.  La console ou l’invite de commande qui permet d’écrire les instructions à exécuter. La console IPython est proposée par défaut. Cette invite commande améliorée offre des possibilités de programmation assistée similaire à l’éditeur de scripts. FIGURE 1 : INTERFACE GRAPHIQUE DE SPYDER 2 LES BIBLIOTHEQUES SCIENTIFIQUES SCYPY Les bibliothèques sont en fait des modules comme vu dans la partie II de ce cours. Ces modules ou bibliothèques regroupent des fonctions optimisées liées à un même domaine. Ces modules ont été créés par d’autres développeurs avant vous. Cela permet d’utiliser et de ne pas réécrire des morceaux de code qui ont déjà écrit, très souvent, mieux par d’autres. D’après https://openclassrooms.com/courses/apprenez-a-programmer-en-python/qu-est-ce-que- python. Scipy est une communauté de développeurs qui ont décidé de réunir dans des packages des bibliothèques dédiées spécifiquement aux domaines des mathématiques, des sciences et de l’ingénierie. Scipy propose six packages principaux :
  • 5. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 4 | P a g e E m e r i c T a p a c h è s FIGURE 2 : PRINCIPAUX PACKAGES DE SCIPY  NumPy est dédié principalement à l’algèbre linéaire et plus particulièrement aux calculs matriciels.  SciPy library est dédié à l’analyse. Ce package regroupe des outils permettant de faire, par exemple, du traitement de signal, de l’optimisation, des statistique…  Matplotlib offre de nombreux outils pour la visualisation/représentation de données en 2D et 3D.  Pandas offre des outils pour gérer et analyser des quantités importantes de données en les structurant de façon efficace.  SymPy permet de faire du calcul formel.  IPython : invite de commande interactive. 3 NUMPY D’après http://www.scipy-lectures.org/intro/numpy/index.html. La bibliothèque NumPy est déjà importée par défaut à l’ouverture de Spyder. Toutefois, si vous devez importer NumPy l’instruction courante est : >>> import numpy as np Les fonctions NumPy permettent de manipuler de façon optimisée des tableaux à n-dimension de nombres (entiers, décimaux, complexes…). 3.1 CREATION DE MATRICE A PARTIR DE FONCTIONS 3.1.1 LA FONCTION ARRAY() : 1-dimension : >>> a = np.array([0, 1, 2, 3]) >>> a array([0, 1, 2, 3]) >>> print(a) [0 1 2 3] >>> a.ndim 1 >>> a.shape (4,) >>> a.dtype dtype('int32')
  • 6. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 5 | P a g e E m e r i c T a p a c h è s ndim permet de connaitre la dimension du tableau (la matrice). shape permet de connaitre la taille de la du tableau (la matrice). dtype permet de connaitre le type des éléments du tableau. 2-dimension : >>> b = np.array([[0., 1., 2.], [3., 4., 5.]]) >>> b array([[ 0., 1., 2.], [ 3., 4., 5.]]) >>> print(b) [[ 0. 1. 2.] [ 3. 4. 5.]] >>> b.ndim 2 >>> b.shape (2, 3) >>> b.dtype dtype('float64') 3-dimension : >>> c = np.array([ [ [1,1] , [2,2] ] , [ [3,3] , [4,4] ] , [ [5,5] , [6,6] ] ]) >>> c array([[[1, 1], [2, 2]], [[3, 3], [4, 4]], [[5, 5], [6, 6]]]) >>> c.ndim 3 >>> c.shape (3, 2, 2) 3.1.2 LES FONCTIONS ARANGE() ET LINSPACE() : arange() est analogue à la fonction range() (voir partie II du cours). Cette fonction permet de générer une progression arithmétique sous forme d’un vecteur. >>> a = np.arange(10) >>> print(a) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> >>> b = np.arange(1, 9, 2) # début, fin (exclu), pas >>> print(b) [1, 3, 5, 7] linspace() permet de générer un nombre fini de points régulièrement espacés entre deux bornes. >>> c = np.linspace(0, 1, 6 >>> print(c) [0. , 0.2, 0.4, 0.6, 0.8, 1. ] >>>
  • 7. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 6 | P a g e E m e r i c T a p a c h è s >>> d = np.linspace(0, 1, 5, endpoint=False) #5 éléments, hormis la borne de fin >>> print(d) [ 0. , 0.2, 0.4, 0.6, 0.8] 3.1.3 AUTRES FONCTIONS PERMETTANT DE CREER DES MATRICES ones() permet de générer une matrice remplie avec la valeur 1 en format float. >>> a = np.ones((3, 3)) >>> print(a) [[ 1. 1. 1.] [ 1. 1. 1.] [ 1. 1. 1.]] zeros() permet des générer une matrice remplie avec la valeur 0 en format float. >>> b = np.zeros((2, 2)) >>> print(b) [[ 0. 0.] [ 0. 0.]] eyes() permet de générer une matrice identité (matrice carrée par conséquent). c = np.eye(3) >>> print(c) [[ 1. 0. 0.] [ 0. 1. 0.] [ 0. 0. 1.]] diag() permet de générer une matrice diagonale (matrice carrée par conséquent). >>> d = np.diag(np.array([1, 2, 3, 4])) >>> print(d) [[1 0 0 0] [0 2 0 0] [0 0 3 0] [0 0 0 4]] random.rand() permet de générer un vecteur avec des nombres aléatoires entre 0 et 1 selon une loi uniforme. >>> a = np.random.rand(4) >>> a [ 0.95799151, 0.14222247, 0.08777354, 0.51887998] 3.2 MANIPULATION DES MATRICES 3.2.1 INDEXATION >>> a = np.arange(10) >>> print(a)
  • 8. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 7 | P a g e E m e r i c T a p a c h è s [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> a[0], a[2], a[-1] (0, 2, 9) >>> >>> a[2:9:3] # [début:fin:pas] array([2, 5, 8]) >>> >>> a[:4] array([0, 1, 2, 3]) >>> >>> a[1:3] array([1, 2]) >>> >>> a[::2] array([0, 2, 4, 6, 8]) >>> >>> a[3:] array([3, 4, 5, 6, 7, 8, 9]) Même logique que pour les chaines de caractères (voir partie II) du cours. >>> a = np.diag(np.arange(3)) >>> print(a) [[0 0 0] [0 1 0] [0 0 2]] >>> a[1, 1] # élément de la deuxième ligne, deuxième colonne 1 >>> a[2, 1] = 10 # modification de l’élément en troisième ligne, deuxième colonne >>> >>> print(a) [[ 0, 0, 0], [ 0, 1, 0], [ 0, 10, 2]] >>> >>> a[1] # deuxième ligne [0, 1, 0] Exemple par l’image :
  • 9. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 8 | P a g e E m e r i c T a p a c h è s FIGURE 3 : INDEXATION DE TABLEAU (SOURCE : SCIPY) 3.2.2 REDIMENSIONNEMENT Passez d’une matrice à un vecteur avec la fonction ravel() : >>> a = np.array([[1, 2, 3], [4, 5, 6]]) >>> print(a) [[1 2 3] [4 5 6]] >>> >>> a.ravel() array([1, 2, 3, 4, 5, 6]) >>> print(a) #la fonction ravel ne modifie pas les dimension de a [[1 2 3] [4 5 6]] >>> >>> a = a.ravel() #a a été passé en vecteur >>> print(a) [1 2 3 4 5 6] Modifiez les dimensions d’une matrice avec la fonction reshape() : >>> a = np.array( [[1,2,3],[4,5,6]] ) >>> a.shape (2, 3) >>> print(a) [[1 2 3] [4 5 6]] >>> print(a.reshape(3,2)) [[1 2] [3 4] [5 6]] >>> print(a.reshape(6,1)) [[1]
  • 10. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 9 | P a g e E m e r i c T a p a c h è s [2] [3] [4] [5] [6]] Concaténer des matrices avec la fonction np.concatenate() : >>> a array([[1, 1], [1, 1]]) >>> b array([[2, 2], [2, 2]]) >>> >>> c = np.concatenate((a,b),axis=1) >>> print(c) [[1 1 2 2] [1 1 2 2]] >>> c = np.concatenate((a,b),axis=0) >>> print(c) [[1 1] [1 1] [2 2] [2 2]] 3.2.3 CALCULS SUR ELEMENT Opération sur les éléments : >>> a = np.array([1, 2, 3, 4]) >>> a + 1 array([2, 3, 4, 5]) >>> 2**a array([ 2, 4, 8, 16]) >>> b = np.ones(4) + 1 >>> a - b array([-1., 0., 1., 2.]) >>> a * b array([ 2., 4., 6., 8.]) >>> a = np.arange(5) >>> print(np.sin(a)) [ 0. , 0.84147098, 0.90929743, 0.14112001, -0.7568025 ] >>> >>> print(np.log(a)) [ -inf, 0. , 0.69314718, 1.09861229, 1.38629436] >>> >>> print(np.exp(a)) [ 1. , 2.71828183, 7.3890561 , 20.08553692, 54.59815003] Test sur les éléments: La fonction nonzeros() est très utile pour tester les éléments d’une matrice. Cette fonction retourne l’indice des éléments qui satisfassent la condition :
  • 11. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 10 | P a g e E m e r i c T a p a c h è s >>> a = np.random.rand(25).reshape(5,5) >>> print(a) [[ 0.12069897 0.35463466 0.22703164 0.49814117 0.55222531] [ 0.01628109 0.84083704 0.0994604 0.47515089 0.70177187] [ 0.79003425 0.96155964 0.73164089 0.04653678 0.60433922] [ 0.71714583 0.49786245 0.11338165 0.10164041 0.28502373] [ 0.46506279 0.3845595 0.75339083 0.99563566 0.3884443 ]] >>> >>> ind = np.nonzero( a >= 0.5 ) >>> >>> print(ind) (array([0, 1, 1, 2, 2, 2, 2, 3, 4, 4], dtype=int64), array([4, 1, 4, 0, 1, 2, 4, 0, 2, 3], dtype=int64)) >>> >>> a[ind[0], ind[1]] array([ 0.55222531, 0.84083704, 0.70177187, 0.79003425, 0.96155964, 0.73164089, 0.60433922, 0.71714583, 0.75339083, 0.99563566]) Autre solution : l’indexation conditionnelle. >>> a = np.random.rand(25).reshape(5,5) >>> print(a) [[ 0.12069897 0.35463466 0.22703164 0.49814117 0.55222531] [ 0.01628109 0.84083704 0.0994604 0.47515089 0.70177187] [ 0.79003425 0.96155964 0.73164089 0.04653678 0.60433922] [ 0.71714583 0.49786245 0.11338165 0.10164041 0.28502373] [ 0.46506279 0.3845595 0.75339083 0.99563566 0.3884443 ]] >>> >>> ind = np.nonzero( a >= 0.5 ) >>> >>> a[(a>=0.5)] array([ 0.55222531, 0.84083704, 0.70177187, 0.79003425, 0.96155964, 0.73164089, 0.60433922, 0.71714583, 0.75339083, 0.99563566]) >>> >>> a >= 0.5 array([[False, False, False, False, True], [False, True, False, False, True], [ True, True, True, False, True], [ True, False, False, False, False], [False, False, True, True, False]], dtype=bool) 3.2.4 CALCULS SUR LES LIGNES ET LES COLONNES Somme : >>> a = np.arange(25).reshape((5,5)) >>> print(a) [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14] [15 16 17 18 19] [20 21 22 23 24]] >>> >>> np.sum(a) 300
  • 12. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 11 | P a g e E m e r i c T a p a c h è s >>> >>> np.sum(a, axis=0) array([50, 55, 60, 65, 70]) >>> np.sum(a, axis=1) array([ 10, 35, 60, 85, 110]) La syntaxe est la même pour les fonctions suivantes :  max() retourne le plus grand nombre d’une matrice ou de chaque ligne ou de chaque colonne,  min() retourne le plus petit nombre d’une matrice ou de chaque ligne ou de chaque colonne,  mean() retourne la moyenne d’une matrice ou de chaque ligne ou de chaque colonne,  median() retourne la médiane d’une matrice ou de chaque ligne ou de chaque colonne,  std() retourne l’écart-type d’une matrice ou de chaque ligne ou de chaque colonne,  argmin() retourne l’indice de la valeur minimum d’une matrice ou de chaque ligne ou de chaque colonne,  argmax() retourne l’indice de la valeur maximum d’une matrice ou de chaque ligne ou de chaque colonne. 3.2.5 CALCULS MATRICIELS Exercice : A l’aide de boucle « for », créer une fonction permettant de faire le produire de deux matrices et de retourner le résultat de ce produit. La fonction permettant de faire le produit matriciel existe déjà dans NumPy, c’est la fonction np.dot() : >>> a = np.arange(6).reshape(2,3) >>> print(a) [[0 1 2] [3 4 5]] >>> >>> b = np.arange(15).reshape(3,5) >>> print(b) [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]] >>> >>> c = np.dot(a,b) >>> print(c) [[ 25 28 31 34 37] [ 70 82 94 106 118]] >>> >>> c = a.dot(b) #autre syntaxe >>> print(c) [[ 25 28 31 34 37] [ 70 82 94 106 118]] >>> >>> c = b.dot(a) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: shapes (3,5) and (2,3) not aligned: 5 (dim 1) != 2 (dim 0)
  • 13. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 12 | P a g e E m e r i c T a p a c h è s La transposé d’une matrice s’obtient avec la fonction np.tanspose() ou a.T : >>> a = np.arange(15).reshape(3,5) >>> print(a) [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]] >>> >>> a.T array([[ 0, 5, 10], [ 1, 6, 11], [ 2, 7, 12], [ 3, 8, 13], [ 4, 9, 14]]) >>> >>> a array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14]]) >>> >>> np.transpose(a) array([[ 0, 5, 10], [ 1, 6, 11], [ 2, 7, 12], [ 3, 8, 13], [ 4, 9, 14]]) >>> >>> a array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14]]) Le déterminant d’une matrice s’obtient avec la fonction np.linalg.det() : >>> a = np.arange(4) + 1 >>> a = a.reshape(2,2) >>> print(a) [[1 2] [3 4]] >>> np.linalg.det(a) -2.0000000000000004 L’inverse d’une matrice inversible s’obtient avec la fonction np.linalg.inv() : >>> a = np.arange(4) + 1 >>> a = a.reshape(2,2) >>> print(a) [[1 2] [3 4]] >>> np.linalg.inv(a) array([[-2. , 1. ], [ 1.5, -0.5]]) Résolution d’un système matriciel : Par exemple, résolution du système suivant :
  • 14. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 13 | P a g e E m e r i c T a p a c h è s 0 1 0 1 3 9 (S) 2 8 x x a x b x x          >>> a = np.array([[3,1], [1,2]]) >>> b = np.array([9,8]) >>> x = np.linalg.solve(a, b) >>> x array([ 2., 3.]) D’où 0 2.0x  et 1 3.0x  . 4 MATPLOTLIB Matplotlib offre plusieurs fonctionnalités pour créer des graphiques 2-D et 3-D. L’instruction pour appeler ce package est : from matplotlitb import pyplot as plt Tracer une courbe revient à tracer une série de points repérés par des coordonnées. Traçons les fonctions sinus et cosinus entre –PI et PI. D’abord, il faut définir le vecteur correspondant aux abscisses (première dimension). X = np.linspace(-np.pi, np.pi, 100) #vecteur de 100 éléments entre –PI et PI Puis, l’on créé le vecteur correspondant aux ordonnées (deuxième dimension), tel que X  cos(X) et X  sin(X) : C, S = np.cos(X), np.sin(X) #C, S sont deux vecteurs de 100 éléments Ensuite, nous utilisons la fonction plt.plot() pour tracer les valeurs des ordonnées en fonction des valeurs des abscisses, tel que : >>> plt.plot(X, C) >>> plt.plot(X, S) La figure suivante doit apparaitre :
  • 15. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 14 | P a g e E m e r i c T a p a c h è s La figure apparait avec des paramètres d’affichage par défaut (taille, couleur, épaisseurs des traits…). Il est possible de modifier ces paramètres d’affichage. Changez la couleur, l’épaisseur et le style du trait… >>> plt.plot(X, C, color="black", linewidth=2.5, linestyle="-") >>> plt.plot(X, S, color="red", linewidth=4, linestyle="-") Pour changer l’affichage des courbes, il faut changer les valeurs des paramètres par défaut à l’aide de mots-clés. Voici la liste des mots-clés : FIGURE 4 : PROPRIÉTÉS D'AFFICHAGE DES LIGNES Il y a plusieurs styles de lignes. Pour y accéder il faut indiquer l’un des symboles présentés sur la première ligne de la figure suivante :
  • 16. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 15 | P a g e E m e r i c T a p a c h è s FIGURE 5 : STYLE DE LIGNE De même pour les marqueurs : FIGURE 6 : LES MARQUEURS Il est possible de modifier les limites d’affichage, par exemple : >>> plt.xlim(0,np.pi) >>> plt.ylim(0,1) >>> >>> # ou >>> >>> plt.xlim(X.min() * 1.1, X.max() * 1.1) >>> plt.ylim(C.min() * 1.1, C.max() * 1.1)
  • 17. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 16 | P a g e E m e r i c T a p a c h è s Il est possible de contrôler les valeurs affichées en abscisse et en ordonnées : >>> plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi]) >>> plt.yticks([-1, 0, +1]) ou de mettre du texte : >>> plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi], [r'$-pi$', r'$-pi/2$', r'$0$', r'$+pi/2$', r'$+pi$']) >>> >>> plt.yticks([-1, 0, +1], [r'$-1$', r'$0$', r'$+1$']) Il est possible de modifier la position des axes : >>> ax = plt.gca() # gca stands for 'get current axis' >>> ax.spines['right'].set_color('none') >>> ax.spines['top'].set_color('none') >>> ax.xaxis.set_ticks_position('bottom') >>> ax.spines['bottom'].set_position(('data',0)) >>> ax.yaxis.set_ticks_position('left') >>> ax.spines['left'].set_position(('data',0)) Pour ajouter une légende, il faut d’abord associer à chaque courbe une chaine de caractères à la propriété « label » : plt.plot(X, C, color="blue", linewidth=2.5, linestyle="-", label="cosinus") plt.plot(X, S, color="red", linewidth=2.5, linestyle="-", label="sinus") Ensuite, il faut appeler la fonction « legend » : plt.legend(loc='upper left') Le paramètre « loc » pour « location » permet d’indiquer la position de la légende.
  • 18. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 17 | P a g e E m e r i c T a p a c h è s L’on peut afficher plusieurs graphiques sur une même figure à l’aide de la fonction plt.subplot(), par exemple pour : >>> def f(t): ... return np.exp(-t) * np.cos(2*np.pi*t) ... >>> t1 = np.arange(0.0, 5.0, 0.1) >>> t2 = np.arange(0.0, 5.0, 0.02) >>> >>> plt.figure(1) >>> plt.subplot(211) >>> plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k') >>> >>> plt.subplot(212) >>> plt.plot(t2, np.cos(2*np.pi*t2), 'r--') >>> plt.show() >>> L’on obtient : Disposition des graphiques avec plt.subplot() : La fonction plt.imshow() permet d’afficher une fonction à deux variables ou les valeurs d’un tableau, par exemple : >>> def f(x, y): ... return (1 - x / 2 + x ** 5 + y ** 3) * np.exp(-x ** 2 - y ** 2) ... >>> n = 10 >>> x = np.linspace(-3, 3, 4 * n) >>> y = np.linspace(-3, 3, 3 * n)
  • 19. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 18 | P a g e E m e r i c T a p a c h è s >>> X, Y = np.meshgrid(x, y) >>> plt.imshow(f(X, Y)) >>> plt.show() L’on obtient : D’autres exemples de graphiques sont présentés sur le lien suivant : http://www.scipy- lectures.org/intro/matplotlib/matplotlib.html#other-types-of-plots-examples-and-exercises