Algorithmique_et_programmation_part3_V2

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



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 :

https://fr.wikipedia.org/wiki/Environnement_de_d%C3%A9veloppement

http://pythonhosted.org/spyder/



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 :

https://openclassrooms.com/courses/apprenez-a-programmer-en-python/qu-est-ce-que-python

https://openclassrooms.com/courses/apprenez-a-programmer-en-python/qu-est-ce-que-python



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')



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. ]

>>>



>>> 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


>>> print(a)



[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 :



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]



[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.])


>>> 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 = 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



>>>

>>> 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)



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 :



0 1

0 1

3 9(S)

2 8

x xa 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 :



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 :



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)



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.



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)



>>> 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

http://www.scipy-lectures.org/intro/matplotlib/matplotlib.html#other-types-of-plots-examples-and-exercises

http://www.scipy-lectures.org/intro/matplotlib/matplotlib.html#other-types-of-plots-examples-and-exercises

Algorithmique_et_programmation_part3_V2

Documents

Transcript of Algorithmique_et_programmation_part3_V2