Informatique algorithmique
Python : installation et prise en main
M1-GM
Base du présent support : cours Jean-Luc Charles & Eric Ducasse – ENSAM Bordeaux
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
· Python ne propose de base que le type list, conteneur dynamique hétérogène
puissant, mais pas orienté calcul numérique.
· Le module numpy propose un ensemble de classes, d’objets et de fonctions dédiés
aux calculs numériques.
· Le module scipy utilise numpy pour proposer une "boîte" à outil de calcul scien-
tifique très complète.
· L’utilisation des modules numériques et de tracé (numpy, scipy et matplolib)
avec l’IDE spyder fournit une solution puissante pour le calcul scientifique.
· Les docs complètes Numpy Reference Guide, Numpy User Guide et Scipy Reference
Guide sont sur [Link]
| | 2/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
· Le module numpy propose un ensemble de classes, d’objets et de fonctions dédiés
aux calculs numériques :
B classe ndarray (N dimensional array) : tableaux homogènes multi-dimensionnels ;
B [Link] : un module d’algèbre linéaire basique ;
B [Link] : un module pour les générateurs aléatoires, ;
B [Link] : un module basique de calculs FFT (Fast Fourier Transform).
· Le site web numpy est [Link].
La doc en ligne de numpy est [Link]/doc/numpy-1.7.0/reference/.
B NumPy for MATLAB© Users : [Link]/NumPy_for_Matlab_Users
| | 3/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
La classe ndarray
· Création d’objets ndarray :
>>> import numpy as np
>>> m1 = [Link]((2,2)) # float par défaut
>>> m1 #m1 pas initialisée par défaut!
array([[ 0.00000000e+000, 4.94944794e+173],
[ 1.93390228e-309, 4.43736710e-317]])
>>> m2 = [Link]((2,2), dtype=int) # dtype: float, int bool...
>>> m2
array([[140206981547944, 48604000],
[ 8981312, 50321888]])
· La fonction array convertit un objet list en objet ndarray :
>>> m1 = [Link]([1, 2, 3]) ; m1
array([1, 2, 3])
>>> m2 = [Link]([1, 2, 3], float) ; m2 # float, int bool...
array([ 1., 2., 3.])
>>> L2 = [4, 5, 6]
>>> m3 = [Link]([[1, 2, 3],[4, 5, 6]]) ; m3 # liste de listes : matrice
array([[1, 2, 3],
[4, 5, 6]])
| | 4/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
La classe ndarray
· Les fonctions numpy zeros et ones
>>> m1 = [Link](4) ; m1 # float par défaut
array([ 0., 0., 0., 0.])
>>> m2 = [Link](3, bool) ; m2
array([ True True True])
>>> m3 = [Link]((2,3),int) ; m3
array([[1, 1, 1],
[1, 1, 1]])
· Les fonctions linspace, logspace créent des vecteurs de float :
>>> [Link](0, 10, 5) # start, stop, number of points
array([ 0., 2.5, 5., 7.5, 10.])
>>> [Link](1, 2, 4) # 4 points between 10**1 and 10**2
array([ 10., 21.5443469, 46.41588834, 100.])
>>> [Link](1, 2, 4, base=2) # 4 points between 2**1 and 2**2
array([ 2. , 2.5198421, 3.1748021, 4.])
| | 5/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
La classe ndarray
· Les fonctions numpy eye et identity :
>>> [Link](3)
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> [Link](3,k=1)
array([[ 0., 1., 0.],
[ 0., 0., 1.],
[ 0., 0., 0.]])
>>> [Link](3,k=-1)
array([[ 0., 0., 0.],
[ 1., 0., 0.],
[ 0., 1., 0.]])
>>> [Link](3)
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
| | 6/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
La classe ndarray
B Copies et références d’objets ndarray
>>> m2 = [Link]([[ 1., 2., 3.],[ 4., 5., 6.]])
>>> m3 = m2 · L’affectation de m3 par l’opérateur =
>>> id(m2), id(m3), m2 is m3 crée une référence sur m2, pas une co-
array(20263504, 20263504, True)
>>> m3[1,1] = -1. ; m3 pie de m2
array([[ 1. 2. 3.]
[ 3. -1. 5.]])
>>> m2
array([[ 1. 2. 3.]
[ 3. -1. 5.]])
>>> m4 = [Link]() · Il faut utiliser explicitement la mé-
>>> id(m2), id(m4), m4 is m2
(20263504, 21073360, False) thode copie de la classe ndarray pour
>>> m4[1,1] = -2. ; m4 obtenir une copie (deep copy)
array([[ 1. 2. 3.]
[ 3. -2. 5.]])
>>> m2
array([[ 1. 2. 3.]
[ 3. -1. 5.]])
| | 7/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
La classe ndarray
· Les attributs de la classe ndarray :
>>> m3 = [Link]([[1, 2, 3],[4, 5, 6]]) # list of lists gives matrix
>>> m3
array([[1 2 3]
[4 5 6]])
>>> [Link] # the element type
dtype(’int64’)
>>> [Link] # the length of the array along each dimension
(2, 3) # 2 lines, 3 columns
>>> [Link] # the element size in bytes element type
8 # integer of 8 bytes (64 bits)
>>> [Link] # the number of elements
6
>>> [Link] # the number dimensions (axes)
2
>>> [Link] # the number of bytes used by array data
48 # 6 elements of 8 bytes each
| | 8/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
La classe ndarray
· La méthode tolist crée un objet list, copie de l’objet ndarray :
>>> [Link]()
[[1, 2, 3], [4, 5, 6]]
>>> L1 = [Link]()
>>> type(L1)
<class ’list’>
· La méthode copy permet de copier (deep copy) un objet ndarray :
>>> c = [Link]()
>>> c
array([[1 2 3]
[4 5 6]])
>>> id(m), id(c), c is m
(51720800, 69723584, False)
| | 9/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
La classe ndarray
· Opérations élémentaires avec les ndarray :
>>> a, b = [Link]([1, 2, 3, 4]), [Link]([2, 3, 4, 5])
>>> a+b
array([3, 5, 7, 9])
>>> a-b
array([-1, -1, -1, -1])
>>> a**2
array([ 1, 4, 9, 16])
>>> 4*a, a*4
(array([ 4, 8, 12, 16]), array([ 4, 8, 12, 16]))
>>> a*b
array([ 2, 6, 12, 20])
>>> A=[Link]([a,b])
>>> A
array([[1, 2, 3, 4],
[2, 3, 4, 5]])
>>> A*A # * fait une multiplication terme à terme
array([[ 1, 4, 9, 16],
[ 4, 9, 16, 25]])
| | 10/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
La classe ndarray
· Opérations élémentaires avec les ndarray :
>>> a < 3
array([ True, True, False, False], dtype=bool)
>>> a <= 3
array([ True, True, True, False], dtype=bool)
>>> a==2
array([False, True, False, False], dtype=bool)
>>> a <= 3
array([ True, True, True, False], dtype=bool)
>>> (a <= 3).all()
False
>>> (a <= 3).any()
True
>>> yes, no = np.ones_like(a), np.zeros_like(a)
>>> yes, no
(array([1, 1, 1, 1]), array([0, 0, 0, 0]))
>>> [Link](a % 3 == 0, yes, no)
array([0, 0, 1, 0])
| | 11/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
La classe ndarray
· Méthodes utiles de la classe ndarray :
>>> m = [Link](1,12,12).reshape((3,4)); m
array([[ 1. 2. 3. 4.]
[ 5. 6. 7. 8.]
[ 9. 10. 11. 12.]])
>>> [Link](), [Link](), [Link]() # somme, max, min de tous les éléments
(78.0, 1.0, 12.)
>>> [Link](axis=0) # somme des lignes
array([ 15., 18., 21., 24.])
>>> [Link](axis=0) # min des lignes
array([ 1., 2., 3., 4.])
>>> [Link](axis=0) # somme cumulée des lignes
array([[ 1., 2., 3., 4.],
[ 6., 8., 10., 12.],
[ 15., 18., 21., 24.]])
>>> [Link](axis=1) # somme cumulée des colonnes
array([[ 1., 3., 6., 10.],
[ 5., 11., 18., 26.],
[ 9., 19., 30., 42.]])
| | 12/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Les Ufunction (Universal functions)
· Les ufunc sont des fonctions mathématiques courantes (sin, cos, exp...) :
B qui s’appliquent à tous les éléments d’un objet ndarray ;
B qui renvoient l’objet ndarray résultant.
>>> m = [Link](1,6,6).reshape((2,3)); m
array([[ 1. 2. 3.]
[ 4. 5. 6.]])
>>> s = [Link](m); s
array([[ 1. , 1.41421356, 1.73205081],
[ 2. , 2.23606798, 2.44948974]])
>>> [Link](m)
array([[ 2.71828183, 7.3890561 , 20.08553692],
[ 54.59815003, 148.4131591 , 403.42879349]])
>>> m = [Link](30,180,6).reshape((2,3)); m
array([[ 30. 60. 90.]
[ 120. 150. 180.]])
>>> [Link](m)
array([[ 0.52359878, 1.04719755, 1.57079633],
[ 2.0943951 , 2.61799388, 3.14159265]])
>>> [Link]([Link](m))
array([[ 8.66025404e-01, 5.00000000e-01, 6.12323400e-17],
[ -5.00000000e-01, -8.66025404e-01, -1.00000000e+00]])
| | 13/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Algébre linéaire avec numpy et [Link]
· La doc en ligne du module [Link] est sur
[Link]
· Quelques exemples :
¸ [Link] multiplication matricielle
¸ [Link] produit scalaire de 2 vecteurs
¸ [Link] création matrice diagonale
¸ [Link] matrice transposée
¸ [Link] déterminant de la matrice
¸ [Link] inverse de la matrice
¸ [Link] résolution du sytème linéaire A x = B
¸ [Link] valeurs propres, vecteurs propres
¸ [Link] valeurs propres
| | 14/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Algébre linéaire avec numpy et le module [Link]
¼ Produit terme à terme et produit matriciel :
X
R = [Link](A, B) ! R[i, j] = A[i, k] B[k, j]
k
>>> A = [Link]([[1,1],[0,1]]); B = [Link]([[2,0],[3,4]])
>>> A*B # produit terme à terme
array([[2, 0],
[0, 4]])
>>> [Link](A,B) # produit matriciel
array([[5, 4],
[3, 4]])
>>> a, b = [Link]([1,2,3]), [Link]([0,1,0]) # 2 vectors
>>> [Link](a,b)
2
¼ Produit scalaire de 2 vecteurs :
>>> a, b = [Link]([1,2,3]), [Link]([0,1,0])
>>> [Link](a, b)
2
| | 15/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Algébre linéaire avec numpy et le module [Link]
¼ Matrices diagonales :
>>> [Link]([Link](3))
array([[0, 0, 0],
[0, 1, 0],
[0, 0, 2]])
>>> [Link]([Link](1,3),1)
array([[0, 1, 0],
[0, 0, 2],
[0, 0, 0]])
>>> [Link]([Link](1,3),-1)
array([[0, 0, 0],
[1, 0, 0],
[0, 2, 0]])
| | 16/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Algébre linéaire avec numpy et le module [Link]
¼ importation de tout numpy dans l’espace de nom courant :
>>> from numpy import *
>>> from [Link] import *
>>> m = [Link](4).reshape((2,2)); m
array([[ 0.57401918, 0.64990241],
[ 0.02683847, 0.01328225]])
>>> det(m)
-0.00981811548021
>>> [Link]() # ne modifie pas m
array([[ 0.57401918, 0.02683847],
[ 0.64990241, 0.01328225]])
>>> mi = inv(m); mi
array([[ -1.35283131 66.19421103]
[ 2.73356598 -58.46531103]])
>>> residu = dot(m, mi) - identity(2); residu
array([[ 0.00000000e+00 -7.10542736e-15]
[ 0.00000000e+00 -1.11022302e-16]])
>>> norm(residu)
7.1062946664058918e-15
| | 17/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Algébre linéaire avec numpy et le module [Link]
¼ importation de numpy et [Link] avec des alias :
>>> import numpy as np
>>> import [Link] as npl
>>> m = [Link](4).reshape((2,2)); m
array([[ 0.29983518, 0.24003911],
[ 0.63791418, 0.97157407]])
>>> [Link](m)
0.138187733609
>>> [Link]()
array([[ 0.29983518, 0.63791418],
[ 0.24003911, 0.97157407]])
>>> mi = [Link](m); mi
array([[ 7.03082713 -1.73705074]
[-4.6162866 2.16976696]]
>>> residu = [Link](m, mi) - [Link](2); residu
array([[ 4.44089210e-16 0.00000000e+00]
[ 0.00000000e+00 0.00000000e+00]])
>>> [Link](residu)
4.4408920985006262e-16
| | 18/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Algébre linéaire avec numpy et le module [Link]
¼ Algébre linéaire avec numpy :
>>> import numpy as np
>>> import [Link] as npl
>>> m = [Link](9).reshape((3,3)); m
array([[ 0.73377208, 0.26787043, 0.63561671],
[ 0.9495004 , 0.73684802, 0.01673223],
[ 0.08534191, 0.77328228, 0.700254 ]])
>>> y = [Link](3); y
array([ 0.92367858, 0.32060105, 0.64198517])
>>> x = [Link](m, y); x
array([ 0.42757753, -0.13899785, 1.01817263])
>>> [Link](m, x)
array([ 0.92367858, 0.32060105, 0.64198517])
>>> [Link](m, x) - y
array([ 1.11022302e-16, 0.00000000e+00, 0.00000000e+00])
| | 19/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Algébre linéaire avec numpy et le module [Link]
¼ Valeurs propres, vecteurs propres :
>>> [Link](m)
array([ 1.63893416+0.j , 0.26596997+0.5535386j, 0.26596997-0.5535386j])
>>> m = [Link](9).reshape((3,3)); m
array([[ 0.83998644, 0.24385328, 0.5285008 ],
[ 0.79324559, 0.42156439, 0.67233731],
[ 0.06364909, 0.97863566, 0.80485252]])
>>> vvp = eig(m)
>>> vvp[0]
array([-0.03068944, 0.30647658, 1.7906162 ])
>>> vvp[1]
array([[-0.27711595, -0.5789238 , 0.5012003 ],
[-0.61339946, -0.33980812, 0.59770115],
[ 0.73955923, 0.74120016, 0.62574084]])
>>> v0, v1, v2 = vvp[1][:,0], vvp[1][:,1], vvp[1][:,2]
>>> dot(m, v0) - vvp[0][0]*v0
array([ -2.08166817e-17, 4.51028104e-17, -4.16333634e-17])
>>> dot(m, v1) - vvp[0][1]*v1
array([ 1.94289029e-16, 8.32667268e-17, -1.66533454e-16])
>>> dot(m, v2) - vvp[0][2]*v2
array([ -6.66133815e-16, -2.22044605e-16, 0.00000000e+00])
| | 20/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Générateurs aléatoires avec [Link]
· La doc en ligne du module [Link] est disponible sur
[Link]
· Exemples de générateurs aléatoires uniformes :
¸ [Link] tirage uniforme continu dans [0,1[
¸ [Link] tirage uniforme continu dans [0,1[
¸ [Link] tirage uniforme discret dans [a, b[
¸ [Link].random_integers tirage uniforme discret dans [a, b]
¸ [Link] tirage gaussien dans [0,1[
· Générateurs aléatoires suivant des distributions classiques
¸ vaste catalogue (beta, binomial, chisquare, dirichlet, gamma...)
| | 21/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Générateurs aléatoires avec [Link]
¼ Générateurs aléatoires (loi uniforme) :
>>> import [Link] as npr
>>> [Link](3,2) # matrice 3X2, tirages uniformes dans [0,1[
array([[ 0.14022471, 0.96360618],
[ 0.37601032, 0.25528411],
[ 0.49313049, 0.94909878]])
>>> [Link](5,10, size=10)
array([6, 6, 8, 6, 6, 6, 5, 9, 7, 5])
>>> [Link](5, size=(2, 4)) # tuple pour donner la dimension
array([[4, 0, 2, 4],
[3, 3, 0, 3]])
>>> [Link].random_integers(1,5,10)# 10 values in [1,5]
array([2, 2, 3, 4, 4, 1, 2, 2, 3, 3])
>>> [Link]()
0.47108547995356098
>>> [Link]((5,)) # tuple pour donner la dimension (shape)
array([ 0.30220482, 0.86820401, 0.1654503 , 0.11659149, 0.54323428])
>>> 5 * [Link]((3, 2)) - 5 # 3 X 2 array of random reals
array([[-3.99149989, -0.52338984], # in [-5, 0[
[-2.99091858, -0.79479508],
[-1.23204345, -1.75224494]])
| | 22/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Générateurs aléatoires avec [Link]
¼ Générateurs aléatoires (loi normale) :
>>> [Link](3,2) # matrice 3X2, tirages uniformes dans [0,1]
array([[ 0.14022471, 0.96360618],
[ 0.37601032, 0.25528411],
[ 0.49313049, 0.94909878]])
>>> [Link].random_sample()
0.47108547995356098
>>> type([Link].random_sample())
<class ’float’>
>>> [Link].random_sample((5,))# tuple pour donner la dimension (shape)
array([ 0.30220482, 0.86820401, 0.1654503 , 0.11659149, 0.54323428])
>>> 5 * [Link].random_sample((3, 2)) - 5 # 3 X 2 array of random reals
array([[-3.99149989, -0.52338984], #in [-5, 0]
[-2.99091858, -0.79479508],
[-1.23204345, -1.75224494]])
| | 23/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Générateurs aléatoires avec [Link]
¼ Vaste catalogue de générateurs aléatoires disponible sur
[Link]/doc/numpy/reference/[Link]#distributions
| | 24/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Calculs FFT avec [Link]
· La doc en ligne est disponible sur
[Link]
| | 25/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Calculs de FFT avec [Link] [fft_sin100.py]
import numpy as np
import [Link] as plt
# 201 points, 100. Hertz
N, F0 = 201, 100
# Te, Fe : période, fréquence d'échantillonnage :
Fe = 20.*F0
Te, deltaF = 1./Fe, Fe/N
# vecteur temps, fréquence:
vT, vF = [Link](N)*Te, [Link](N)*deltaF
# échantillonnage du sinus :
Se = [Link](2*[Link]*F0*vT)
TF_Se = [Link](Se)
plt.subplots_adjust(hspace=0.5); [Link](211)
[Link](vT, Se, 'o-g')
[Link]('t (s)') ; [Link]([0, N*Te, -1.1, 1.1])
[Link](212)
[Link](vF[:N//2], abs(TF_Se[:N//2]))
[Link](-1, 1.1*max(abs(TF_Se[:N//2])))
[Link]('F (Hertz)') ; [Link](u'DSP sinus à 100 Hz')
[Link]()
| | 26/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Calculs de fft avec [Link]
| | 27/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Le module scipy [Link]
| | 28/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Le module Scipy
· Tutoriel complet : [Link]/doc/scipy-0.14.0/reference/tutorial/[Link]
| | 29/ 31
Numpy [Link] [Link] [Link] [Link] Scipy v1.2
Références bibliographiques
[Link]
[Link]/informatique/python/cours [Link]/informatique
a-programmer-en-python
Apprenez à programmer en Python
Vincent Le Goff Apprendre à programmer avec Python 3
Simple IT éd. (Le livre du zéro) Gérard Swinnen
ISBN 979-10-90085-03-9 Télécharger le PDF
: 25 ¤
:
Programmation en Python
Python Essential Reference
pour les mathématiques
David M. Beazley
A. Casamayou-Boucau
Addison Wesley
Dunod
ISBN 0-672-32978-4
ISBN 978-2-10-057422-3
Python Scripting for
Matplotlib for Python Developers
Computational Science
Sandro Tosi
T.J. Barth
PACTK publishing
Springer
ISBN 1847197906
ISBN 978-3-540-73915-9
| | 30/ 31
[Link]@[Link]
[Link]@[Link]