Numpy & Matplotlib LSE3
1. Introduction à NumPy
La bibliothèque NumPy ([Link] permet d'effectuer des
calculs numériques avec Python. Elle introduit une gestion facilitée des
tableaux de nombres.
Pour utiliser NumPy, vous devez au préalable vous placer dans un
environnement qui comprend cette bibliothèque, voir Introduction à Python.
Il faut au départ importer le package numpy avec l’instruction suivante :
import numpy as np
2. Variables prédéfinies
Exemple : variable Pi
NumPy permet d’obtenir la valeur de pi.
import numpy as np
print([Link])
Résultat:
3.141592653589793
3. Création des Tableaux
Les tableaux (en anglais, array) peuvent être créés avec [Link](). On
utilise des crochets pour délimiter les listes d’éléments dans les tableaux.
#Ex1 [Link]
import numpy as np
f= [Link]([1,2,3,4,5])
4. Affichage des Tableaux
Hammadi Oumaima
Numpy & Matplotlib LSE3
f= [Link]([1,2,3,4,5])
print(f)
print(type(f))
5. Accès aux éléments d'un tableau
f= [Link]([1,2,3,4,5])
print(f[0])
print(f[3])
print(f[1])
6. Création du Tableau 2D
Il est possible de créer un tableau 2D en utilisant une liste de listes au moyen
de crochets imbriqués.
Les listes internes correspondantes aux lignes du tableau.
b= [Link]([[1,2,3],[4,5,6]])
7. Affichage du Tableau 2D
print(b)
type(b)
Résultat :
array([[1, 2, 3],
[4, 5, 6]])
<class '[Link]'>
8. Accès aux éléments d'un tableau 2D
On utilise une syntaxe avec deux indices. Le premier indice est l’indice de la
ligne du tableau.
print(b[0,1])
Hammadi Oumaima
Numpy & Matplotlib LSE3
Résultat :
2
print(b[1,2])
Résultat :
6
9. [Link]
La fonction [Link]() est une fonction de la bibliothèque NumPy en
Python, qui permet de créer un tableau (ou une matrice) rempli de zéros.
[Link](shape, dtype=float, order='C')
x=[Link](6)
print(x)
10. [Link]
La méthode [Link]() est une fonction de la bibliothèque NumPy en
Python qui permet de créer un tableau (ou une matrice) rempli de valeurs
égales à un.
[Link](shape, dtype=Aucun, order='C', *, like=Aucun)
Renvoie un nouveau tableau de forme et de type donnés, rempli de ceux-ci.
x=[Link](4)
print(x)
11. Shape & ndim
La fonction [Link]() (forme, en anglais) renvoie la taille du tableau.
La fonction [Link]() est une fonction fournie par la bibliothèque NumPy
en Python. Elle est utilisée pour déterminer le nombre de dimensions d'un
Hammadi Oumaima
Numpy & Matplotlib LSE3
tableau (ou tableau multidimensionnel). En d'autres termes, elle renvoie le
nombre d'axes ou de dimensions présentes dans le tableau.
y=[Link]([[1, 2], [3, 4]])
print([Link])
print([Link])
12. array & matplotlib
Matplotlib est une bibliothèque Python open source permettant de créer des
visualisations de données.
import numpy as np
import [Link] as plt
x = [Link]([1, 3, 4, 6])
y = [Link]([2, 3, 5, 1])
[Link](x, y)
[Link]() # affiche la figure a l'ecran
13. [Link]
La fonction [Link]() permet d’obtenir un tableau 1D allant d’une
valeur de départ à une valeur de fin avec un nombre donné d’éléments.
x = [Link](-2, 2,3)
y1 = 2*x + 10
y2 = 3*x
[Link](x, y1)
[Link](x, y2)
[Link]()
Hammadi Oumaima
Numpy & Matplotlib LSE3
Figure 1
print(x)
Résultat : array([-2., 0., 2.])
print(y1)
Résultat : array([ 6., 10., 14.])
print(y2)
Résultat: array([-6., 0., 6.])
x = [Link](1, 10, 10)
y = 2*x**2+6*x #y=2x^2+6x
[Link](x,y)
[Link]()
Hammadi Oumaima
Numpy & Matplotlib LSE3
Figure 2
print(x)
Résultat : array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
print(y)
Résultat :array([ 8., 20., 36., 56., 80., 108., 140., 176., 216., 260.])
print(len(y))
Résultat :10
print(len(x))
Résultat :10
x = [Link](-1,4,10)
y = 3*[Link](x)+[Link](x) #y=3*cos(x)+sin(x)
[Link](x,y)
[Link]()
Hammadi Oumaima
Numpy & Matplotlib LSE3
Figure 3
print(x)
Résultat :
array([-1. , -0.44444444, 0.11111111, 0.66666667, 1.22222222,
1.77777778, 2.33333333, 2.88888889, 3.44444444, 4.])
print(y)
Résultat :
array([ 0.77943593, 2.27859264, 3.09238315, 2.97603159,
1.96453473,0.36213554, -1.34918854, -2.65469711, -3.16171295,2.71773336])
print(len(y))
Résultat :10
print(len(x))
Résultat :10
Hammadi Oumaima
Numpy & Matplotlib LSE3
14. [Link]
La fonction [Link]() calcule la moyenne arithmétique, ou en termes
simples - moyenne, du tableau donné le long l’axe spécifié.
[Link](arr, axis=None, dtype=float64)
axis = 0 signifie moyenne arithmétique calculée le long de la colonne,
axis = 1 signifie moyenne arithmétique le long de la ligne.
15. [Link]() avec tableau 1-D
import numpy as np
arr = [10, 20, 30]
print("1-D array :", arr)
print("Mean of arr is :", [Link](arr))
Résultat:
1-D array : [10, 20, 30]
Mean of arr is : 20.0 (c’est a dire La fonction [Link]() fait ça :
(10+20+30)/3 = 20 )
16. [Link]() avec tableau 2-D
import numpy as np
arr = [[10, 20, 30], [3, 50, 5], [70, 80, 90], [100, 110, 120]]
print("Two Dimension array :", arr)
print("Mean with no axis :", [Link](arr))
print("Mean with axis along column :", [Link](arr, axis=0))
Résultat :
Two Dimension array : [[10, 20, 30], [3, 50, 5], [70, 80, 90], [100, 110, 120]]
Mean with no axis : 57.333333333333336
Mean with axis along column : [45.75 65. 61.25]
Hammadi Oumaima
Numpy & Matplotlib LSE3
(c’est-à-dire [((10+3+70+100)/4),((20+50+80+110)/4),((30+5+90+120)/4)]
=[45.75,65,61.25])
print("Mean with axis along row :", [Link](arr, axis=1))
Mean with axis along row : [ 20. 19.33333333 80. 110. ]
17. [Link]() avec dtype spécifié
import numpy as np
arr = [10.12, 20.3, 30.28]
print("1-D Array :", arr)
print("Mean of arr :", [Link](arr))
print("Mean of arr with int data :", [Link](arr, dtype=int))
print("Mean of arr with float32 data :", [Link](arr, dtype=np.float32))
print("Mean of arr with float64 data :", [Link](arr, dtype=np.float64))
Résultat:
1-D Array : [10.12, 20.3, 30.28]
Mean of arr : 20.233333333333334
Mean of arr with int data : 20
Mean of arr with float32 data : 20.233332
Mean of arr with float64 data : 20.233333333333334
Note: Si le paramètre dtype est donné dans la fonction [Link](), il
utilise le type de données spécifié lors du calcul de la moyenne arithmétique.
Le résultat a une résolution inférieure si nous utilisons le type de données
float32 plutôt que le float64 par défaut.
18. [Link]
La fonction [Link]() renvoie le carré élément par élément de l'entrée.
Hammadi Oumaima
Numpy & Matplotlib LSE3
[Link](x[, out]) = <ufunc 'carré'>
Paramètres :
x : tableau d'entrée
out: ndarray
si out est donné, le résultat sera stocké dans out. out devrait avoir la
même forme que tableau d'entrée.
Retour:
Il retourne un tableau du carré de chaque élément du tableau
d’entrée, même si out est donné
out: ndarray
import numpy as np
arr = [1, 3, 5, 7]
arr_sq = [Link](arr)
print(arr_sq)
Résultat :
[ 1 9 25 49]
Exemples de codes : [Link]() avec le paramètre out
import numpy as np
arr = [1, 3, 5, 7]
out_arr = [Link](4)
arr_sq = [Link](arr, out_arr)
print(out_arr)
print(arr_sq)
Résutat:
[ 1. 9. 25. 49.]
[ 1. 9. 25. 49.]
out_arr a la même forme que arr, et le carré de arr y est enregistré.
Hammadi Oumaima
Numpy & Matplotlib LSE3
Et la méthode [Link]() retourne également le tableau carré, comme
indiqué ci-dessus.
Si out n’a pas la même forme que arr, il déclenche une ValueError.
import numpy as np
arr = [1, 3, 5, 7]
out_arr = [Link](3)
arr_sq = [Link](arr, out_arr)
print(out_arr)
print(arr_sq)
Traceback (most recent call last):
File "d:\tp_image_MBio1\test_tp\explication_tp2.py", line 68, in <module>
arr_sq = [Link](arr, out_arr)
^^^^^^^^^^^^^^^^^^^^^^^
ValueError : les opérandes n'ont pas pu être diffusés avec les formes (4,) (3,)
Note :
Opérande : Quantité, donnée qui entre dans une opération arithmétique,
une instruction informatique.
Exemples de code : [Link]() avec des nombres négatifs
import numpy as np
arr = [-1, -3, -5, -7]
arr_sq = [Link](arr)
print(arr_sq)
Résultat :
[ 1 9 25 49]
Exemples de codes : [Link]() avec des nombres complexes
import numpy as np
arr = [1 + 2j, -2 - 1j, 2 - 3j, -3 + 4j]
arr_sq = [Link](arr)
Hammadi Oumaima
Numpy & Matplotlib LSE3
print(arr_sq)
Résultat :
[-3. +4.j 3. +4.j -5.-12.j -7.-24.j]
C’est-à-dire : [(1+2j)2, (-2-1j)2, (2-3j)2, (-3+4j)2]
=[(12+2*2j+(2j)2), ((-2)2-2*(-2)j+j2) , (22-2*2*3j+(3j)2), ((-3)2-3*2*4j+(4j)2)]
=[(1+4j-2),(4+4j-1),(4-12j-9),(9-24j-16)
=[(-3+4j),(3+4j),(-5-12j),(-7-24j)]
Note:
[Link](x[, out])
x : tableau d'entrée
Retour:
out: ndarray
x*x par élément, de même forme et type que x. Renvoie un scalaire si x
est un scalaire.
x=[Link]([-1j, 1])
print(x)
Résultat :
[-1.+0.j 1.+0.j]
19. [Link] & [Link]
La fonction [Link]() renvoie des valeurs régulièrement espacées dans
un intervalle donné.
[Link]() peut être appelé avec un nombre variable d'arguments de
position :
[Link](stop) : les valeurs sont générées dans l'intervalle semi-
ouvert [0, stop) (en d'autres termes, l'intervalle incluant le début mais
excluant l'arrêt).
exemple :
Hammadi Oumaima
Numpy & Matplotlib LSE3
x1 = [Link](6)
print(x1)
Résultat:
[0 1 2 3 4 5]
[Link](start, stop) : les valeurs sont générées dans l'intervalle
semi-ouvert [start, stop).
Exemple :
m = [Link](3, 15)
print(m)
Résultat :
[ 3 4 5 6 7 8 9 10 11 12 13 14]
[Link](start, stop, step) : Les valeurs sont générées dans
l'intervalle semi-ouvert [start, stop), avec un espacement entre les
valeurs donné par étape.
Exemple :
m = [Link](3, 15, 2)
print(m)
print(type(m))
Résultat :
[ 3 5 7 9 11 13]
<class '[Link]'>
Notez la différence entre [Link]() et range() :
[Link]() renvoie un objet de type [Link].
range() retourne un objet de type range.
n = range(3, 15, 2)
print(n)
Hammadi Oumaima
Numpy & Matplotlib LSE3
print(type(n))
Résultat :
range(3, 15, 2)
<class 'range'>
Il est possible d’obtenir des listes en combinant list et range().
Y=list(range (3, 15, 2))
print(Y)
Résultat :
[3, 5, 7, 9, 11, 13]
x1 = [Link](6)
print(x1)
x2= [Link](x1, 3)
print(x2)
Résultat:
[0 1 2 3 4 5]
[ 0 1 8 27 64 125]
20. [Link] & [Link]
La fonction [Link]() : Renvoie le plus petit élément du tableau .
La fonction [Link]() : Renvoie le plus grand élément du tableau .
a = [Link](2,10)
print(a)
b=[Link](a)
print(b)
c=[Link](a)
print(c)
Résultat :
[2 3 4 5 6 7 8 9]
9
2
21. [Link] & [Link]
Hammadi Oumaima
Numpy & Matplotlib LSE3
Les fonctions [Link](...) et [Link](...) permettent de connaitre la
position (indice) de la valeur min et max dans un tableau.
a=[Link]([10,2,8,50,9])
print(a)
b=[Link](a)
print(b)
c=[Link](a)
print(c)
a = [Link](1,10)
print(a)
b=[Link](a)
print(b)
c=[Link](a)
print(c)
a=[Link]([[10, 11, 12],
[13, 14, 15]])
print([Link])
b=[Link](a)
print(b)
c=[Link](a)
print(c)
22. [Link]
La fonction [Link]() trie(ou la classification ) un tableau à N dimensions de
tout type de données. Par défaut, la fonction trie le tableau par ordre croissant.
a = [Link]([[1,4,2],[3,1,0]])
print("a:",a)
b=[Link](a)
print("b:",b)
Résultat :
a: [[1 4 2]
[3 1 0]]
b: [[1 2 4]
[0 1 3]]
Hammadi Oumaima
Numpy & Matplotlib LSE3
Exercices :
import numpy as np
a = [Link]((2,6))
print("a initial:",a)
print([Link]) #=>(2, 3)
print("dimension du tableau:",[Link])
print("[Link][0]:",[Link][0])
print("[Link][1]:",[Link][1])
print("range([Link][0]):",range([Link][0]))
print("range([Link][1]):",range([Link][1]))
for i in range([Link][0]):
for j in range([Link][1]):
a[i, j] = (i+1)*(j +1)
# print(i)
# print(j)
print ("a final:",a)
Résultat:
a initial: [[0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0.]]
(2, 6)
dimension du tableau: 2
[Link][0]: 2
[Link][1]: 6
range([Link][0]): range(0, 2)
range([Link][1]): range(0, 6)
a final: [[ 1. 2. 3. 4. 5. 6.]
[ 2. 4. 6. 8. 10. 12.]]
Représenter les fonctions suivantes sur un intervalle x :
Hammadi Oumaima
Numpy & Matplotlib LSE3
f(x)=5x2+4cos(2x)
g(x)=tan(x)
y(x)=sin(x)+cos(x)
d(x)=e(x)
z(x)=e2x+1
b(x)=log(x)
x= [Link](0,10)
y=5*x**2+4*[Link](2*x)
[Link](x,y)
[Link]()
Hammadi Oumaima
Numpy & Matplotlib LSE3
Figure 4
x= [Link](0,10)
y=[Link](x)
[Link](x,y)
[Link]()
Hammadi Oumaima
Numpy & Matplotlib LSE3
Figure 5
x= [Link](0,10)
y=[Link](x)+[Link](x)
[Link](x,y)
[Link]()
Hammadi Oumaima
Numpy & Matplotlib LSE3
Figure 6
x= [Link](0,10)
y=[Link](x)
[Link](x,y)
[Link]()
Hammadi Oumaima
Numpy & Matplotlib LSE3
Figure 7
x= [Link](0,10)
y=[Link](2*x+1)
[Link](x,y)
[Link]()
Hammadi Oumaima
Numpy & Matplotlib LSE3
Figure 8
x= [Link](1,10)
y=[Link](x)
[Link](x,y)
[Link]()
Hammadi Oumaima
Numpy & Matplotlib LSE3
Figure 9
Hammadi Oumaima