1. Import du module¶
On importe le module :
import numpy as np
2. Fonction zeros() et ones()¶
On crée une matrice nulle à n lignes et m colonnes avec l'instruction A = np.zeros((n,m)).
Attention il faut dédoubler les parenthèses.
A = np.zeros((3,4)) # matrice nulle avec 3 lignes et 4 colonnes
print(A)
[[0. 0. 0. 0.] [0. 0. 0. 0.] [0. 0. 0. 0.]]
A = np.zeros(3,4) # on oublie de dédoubler les parenthèses
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[3], line 1 ----> 1 A = np.zeros(3,4) # on oublie de dédoubler les parenthèses TypeError: Cannot interpret '4' as a data type
On crée une matrice à n lignes et m colonnes dont toules coefficients sont égaux à $1$ avec l'instruction A = np.ones((n,m)).
Attention il faut dédoubler les parenthèses.
On n'obtient pas la matrice identité.
A = np.ones((3,4)) # matrice de 1 avec 3 lignes et 4 colonnes
print(A)
[[1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.]]
3. Création d'un tableau Numpy avec la fonction array() et une liste de listes¶
Il suffit d'appliquer la fonction array().
B = np.array( [[3,4,10], [1,8,7]] )
print(B)
[[ 3 4 10] [ 1 8 7]]
4. Taille d'un tableau Numpy avec la méthode shape()¶
Deux syntaxes sont possibles.
B.shape
(2, 3)
np.shape(B)
(2, 3)
5. Accès aux éléments d'un tableau Numpy¶
On accède à l'élément de la ligne i colonne j avec l'instruction A[i,j].
Attention avec des listes des listes cela aurait été
A[i][j].
print(B[1,2])
7
print(B[1,0])
1
On peut modifier une case du tableau.
print(B)
[[ 3 4 10] [ 1 8 7]]
B[1,2] = -1234
print(B)
[[ 3 4 10] [ 1 8 -1234]]
Pour accéder à toute la ligne i on utilise la syntaxe B[i,:] (on obtient encore un tableau Numpy).
Avec une liste de liste la syntaxe est différente: ce serait
B[i].
print(B[0,:])
[ 3 4 10]
Pour accéder à toute la colonne j on utilise la syntaxe B[:,j] (on obtient un tableau Numpy unidimensionnel).
Avec une liste de liste la syntaxe est différente: ce serait avec une liste par compréhension
[ B[i][j] for i in range(len(B)) ].
print(B[:,2])
[ 10 -1234]
6. Création d'un tableau Numpy avec une boucle¶
On ne peut pas partir d'un tableau vide qu'on agrandit avec
append()(cette méthode ne fonctionne pas).
Il faut donc définir dès le début un tableau à la bonne taille avec zeros() puis modifier les coefficients un par un dans une double boucle for. La structure du code est la suivante :
T = np.zeros((n,p)) # les variables n et p ont été définies avant
for i in range(n) :
for j in range(p) :
T[i,j] = ...... # à compléter en fonction de la question posée
Par exemple si on veut définir la matrice de Hilbert $H=((h_{i,j}))_{1\leq i,j\leq n}$ définie par $h_{i,j}=\dfrac{1}{i+j-1}$ avec $n=100$ :
n = 100
H = np.zeros((n,n))
for i in range(n) :
for j in range(n) :
H[i,j] = 1/(i+j+1) # +1 et non -1 car les indices commencent à 0 en Python (piège habituel)
7. Création d'une liste Numpy pour subdiviser un intervalle¶
Si on divise un intervalle $[a,b]$ en $n$ points (donc $n-1$ sous-intervalles), la longueur de chaque sous-intervalle est $h=(b-a)/(n-1)$.
On peut le faire en précisant le nombre de points avec linspace(a,b,n) ou en précisant le pas avec arange(a,c,h).
T = np.linspace(0,1,11)
print(T)
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
T = np.arange(0,1.1,0.1) # attention on s'arrête strictement avant la borne de droite donc on met 1.1 et non 1.
print(T)
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
On voit que l'équivalent de
linspace(a,b,n)n'est pasarange(a,b,h)maisarange(a,b+h,h).
Quelle est la différence entre range(a,c,h) et arange(a,c,h) ? Avec la fonction arange() le pas peut être de type float.
range(0,1.1,0.1) # pas possible
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[17], line 1 ----> 1 range(0,1.1,0.1) # pas possible TypeError: 'float' object cannot be interpreted as an integer
np.arange(0,1.1,0.1)
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
8. Calcul avec les tableaux Numpy¶
Les calculs se font coefficients par coefficients, même avec + ou exp.
A = np.arange(0,1.1,0.1)
print(A)
B = np.arange(2,3.1,0.1)
print(B)
C = A+B
print(C)
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ] [2. 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3. ] [2. 2.2 2.4 2.6 2.8 3. 3.2 3.4 3.6 3.8 4. ]
D = np.exp(A) # on applique la fonction directement au tableau, sans boucle for
print(D)
[1. 1.10517092 1.22140276 1.34985881 1.4918247 1.64872127 1.8221188 2.01375271 2.22554093 2.45960311 2.71828183]
E = np.sin(B)
print(E)
[0.90929743 0.86320937 0.8084964 0.74570521 0.67546318 0.59847214 0.51550137 0.42737988 0.33498815 0.23924933 0.14112001]
Le module Numpy propose toutes les fonctions et constantes mathématiques habituelles np.sin, np.log, np.log10, np.pi ...
Les fonctions s'utilisent directement sur les tableaux, sans boucle for.
On n'a donc pas besoin de charger en plus le module
math(d'autant plus que les fonctions de ce module ne s'appliquent pas sur des tableaux).
9. Tirages aléatoires (par exemple pour la méthode de Monte Carlo)¶
Les fonctions permettant de simuler des variables aléatoires sont dans le sous-module numpy.random. Il est chargé en même temps que Numpy.
Pour simuler des valeurs prises au hasard équiprobablement entre $a$ et $b$ on utilise np.random.uniform(a,b,n) où $n$ est le nombre de valeurs souhaitées.
np.random.uniform(0,1,10)
array([0.35577815, 0.68251838, 0.70486492, 0.11069955, 0.20654663,
0.43287058, 0.70595432, 0.41436817, 0.05280487, 0.05495861])
Pour simuler des valeurs prises selon une loi normale (= de Gauss) de moyenne m et d'écart-type s (donc de
variance $s^2$) on utilise np.random.normal(m,s,n) où $n$ est le nombre de valeurs souhaitées.
np.random.normal(2.2,0.8,10)
array([2.03068515, 0.77214535, 2.66179601, 0.6133071 , 2.27208912,
3.1395112 , 3.40043117, 3.85516661, 2.44549625, 2.09226337])