Initiation à la programmation sous Python

pour le calcul scientifique (partie 2)

Partie I : Manipulation des matrices

Nous importons le module numpy qui permet de manipuler les vecteurs, entre autres
les matrices, et qui contient de

différentes fonctions mathématiques.

Le contenu de ce package est donné par la commande dir(numpy) après l'avoir

importé bien évidemment.

In [1]: import numpy as np

#dir(np)

# L'appelation des fonctions se fait en tappant np.le_nom_de_la_fonction

Déclaration et affichage d'une matrice

1. Déclarer la matrice suivante:
$$A=\begin{pmatrix}
4 & 3 & 3 & 3 \\
2 & 4 & 3 & 3 \\
2
& 2 & 4 & \pi \\
2 & 2 & 2 & 0.5\\
\end{pmatrix}$$

$\Rightarrow$ Pour déclarer la matrice $A$, on utilise np.array(liste[listes]) ,

chaque liste est une ligne de la matrice $A$.

In [2]: #réponse

A=np.array([[4,3,3,3],[2, 4, 3, 3],[2,2,4,np.pi], [2, 2, 2, 0.5]]) # une

1. Afficher la matrice $A$ anisi que son type.

In [3]: print(A, type(A))

[[4. 3. 3. 3. ]

[2. 4. 3. 3. ]

[2. 2. 4. 3.14159265]

[2. 2. 2. 0.5 ]] <class 'numpy.ndarray'>

1. Afficher la dimension de $A$ en utilsiant la commande shape() puis par

np.shape()

In [4]: #réponse

#print(A.shape)

#ou bien on utilise

#np.shape(A)

Opérations sur les matrices

 1. Afficher les élements $0$, $0.5$ et $\pi$ de la matrice $A$.

In [5]: #Executer et commenter

print(A[0,0])

print(A[2,3])

print(A[3,3])

4.0

3.141592653589793

0.5

Remarque :

Les compteurs des lignes et des colonnes commencent par 0.

1. Afficher $V$ la sous matrice de $A$ formée par la deuxième colonne de $A$.

A[:,n:m] est une sous matrice de $A$ avec : represente toutes les lignes et
n:m represente les colonnes de $n$ à $m-1$.

In [5]: #Completer et executer

V=A[:,1:2]

print(V)

[[3.]
[4.]
[2.]
[2.]]

1. Afficher $W$ la sous matrice de $A$ formée par la deuxième et la troisième colonne
de $A$.

In [6]: #Completer et executer

W=A[:,1:3]

print(W)

[[3. 3.]

[4. 3.]

[2. 4.]

[2. 2.]]

1. Créer la matrice $B$, une copie de $A$, puis l'afficher.

In [8]: B=A.copy()

print(B)

[[4. 3. 3. 3. ]

[2. 4. 3. 3. ]

[2. 2. 4. 3.14159265]

[2. 2. 2. 0.5 ]]

Remarque

B=A.copy() entraine la création d'une nouvelle matrice B et laisser la matrice

A intact.
B=A entraine que toute modification sur B enjendre la même modification sur A .
 1. Remplacer $\pi$ dans la matrice $B$ par $e$ puis afficher la nouvelle matrice.

In [9]: #Completer et executer

B[2,3]=np.e

print(B)

[[4. 3. 3. 3. ]

[2. 4. 3. 3. ]

[2. 2. 4. 2.71828183]

[2. 2. 2. 0.5 ]]

1. Remplacer la quatrième ligne de la matrice $B$ par le vecteur $[1,1,1,1]$ puis

afficher la nouvelle matrice.

In [11]: #Completer et executer

B[3,:]=[1,1,1,1]

print(B)

[[4. 3. 3. 3. ]

[2. 4. 3. 3. ]

[2. 2. 4. 2.71828183]

[1. 1. 1. 1. ]]

1. Afficher la diagonale de $A$.

In [11]: print(np.diag(A))

[4. 4. 4. 0.5]

1. Afficher la première sous diagonale de $A$.

In [12]: print(np.diag(A,-1) )

#print(A)

[2. 2. 2.]

1. Afficher la deuxième sur diagonale de $A$.

In [13]: print(np.diag(A,2) )

print(A)

[3. 3.]

[[4. 3. 3. 3. ]

[2. 4. 3. 3. ]

[2. 2. 4. 3.14159265]

[2. 2. 2. 0.5 ]]

1. Afficher la matrice triangulaire inférieure associée à $A$.

In [15]: print(np.tril(A)) # l=lower

[[4. 0. 0. 0. ]

[2. 4. 0. 0. ]

 [2. 2. 4. 0. ]

[2. 2. 2. 0.5]]

1. Afficher la matrice triangulaire supérieure associée à $A$.

In [16]: print(np.triu(A)) #u=upper

[[4. 3. 3. 3. ]

[0. 4. 3. 3. ]

[0. 0. 4. 3.14159265]

[0. 0. 0. 0.5 ]]

1. Calculer les produits matriciels $A*V$, $A*W$ et $A^2$.

In [17]: A.dot(V)# A*V

-------------------------------------------------------------------------
--

NameError Traceback (most recent call las

t)

<ipython-input-17-1e7670d91200> in <module>

----> 1 A.dot(V)# A*V

NameError: name 'V' is not defined

In [ ]: A.dot(W)#A* W

In [18]: A**2# la matrice contenant les carrés des élmenents de A.

array([[16. , 9. , 9. , 9. ],

Out[18]:
[ 4. , 16. , 9. , 9. ],

[ 4. , 4. , 16. , 9.8696044],

[ 4. , 4. , 4. , 0.25 ]])

1. Afficher la matrice transposée de $A$.

In [19]: # 1ére méthode

print(A.transpose())

[[4. 2. 2. 2. ]

[3. 4. 2. 2. ]

[3. 3. 4. 2. ]

[3. 3. 3.14159265 0.5 ]]

In [20]: #2 ème méthode

print(A.T)

[[4. 2. 2. 2. ]

[3. 4. 2. 2. ]

[3. 3. 4. 2. ]

[3. 3. 3.14159265 0.5 ]]

1. Construire une matrice diagonale $C$ contenant le vecteur $[-2,1,2]$ sur la

diagonale.

In [21]: U= [-2,1,2]

C=np.diagflat(U)

print(C)

 [[-2 0 0]

[ 0 1 0]

[ 0 0 2]]

1. Construire $D$ une matrice diagonale dont sa diagonale est celle de la matrice
$A$.

In [22]: D=np.diagflat(np.diag(A))

print(D)

[[4. 0. 0. 0. ]

[0. 4. 0. 0. ]

[0. 0. 4. 0. ]

[0. 0. 0. 0.5]]

Activité (asynchrone)

Exécuter et commenter

In [24]: #np.trace(A)

#np.sum(A)

#np.argmax(A,axis=1)

#print(np.triu(A,2))

#print(B/2)
#print(B-4)
#print(B*2)
#print(np.sqrt(B))

#print(-B)

Matrices particulières

1. Matrice identité:

In [25]: #1 ére méthode

I=np.identity(4)

print(I)

[[1. 0. 0. 0.]

[0. 1. 0. 0.]

[0. 0. 1. 0.]

[0. 0. 0. 1.]]

In [26]: # 2 ème méthode

J= np.eye(3)

print(J)

[[1. 0. 0.]

[0. 1. 0.]

[0. 0. 1.]]

1. Matrice nulle d'ordre $n*p$.

In [27]: O=np.zeros((3,2),int) # nombre de ligne, nombre de colonnes et de type en

print(O)

[[0 0]

[0 0]

 [0 0]]

1. Matrice composée des $1$ d'ordre $n*p$.

In [28]: U=np.ones((4,5),float)# nombre de ligne, nombre de colonnes et de type fl

print(U)

[[1. 1. 1. 1. 1.]

[1. 1. 1. 1. 1.]

[1. 1. 1. 1. 1.]

[1. 1. 1. 1. 1.]]

1. La fonction .reshape(n,m) permet de transformer une matrice de dimension

(p,k) en une matrice de dimension (n,m) à condition que p*k=n*m

In [29]: mat=np.array([[1,2,3,4],[2,3,0,6]])

print(mat)

Mat=mat.reshape(4,2)

print(Mat)

[[1 2 3 4]
[2 3 0 6]]

[[1 2]

[3 4]

[2 3]

[0 6]]

Remarque

Pour calculer un déterminant, inverser une matrice, résoudre un système d'équations

linéaires, etc $\dots$,

nous faisons appel au sous module .linalg de numpy

Exercice (10): Résolution d'un système de Cramer.

Soit le système d'équations linéaires suivant : $MX=b$, avec :

$$M=\begin{pmatrix}
4 & -1 & -1 & 0 \\
-1 & 4 & 0 & -1 \\
-1 & 0 & 4 & -1 \\
0 & -1 & -1 &
4\\
\end{pmatrix}, \; X=\begin{pmatrix}
x_1 \\
x_2 \\
x_3 \\
x_4\\
\end{pmatrix},\; \mbox{et}
\; b=\begin{pmatrix}
50 \\
30 \\
70 \\
50\\
\end{pmatrix},$$

1. Ecrire les matrices $M$ et $b$.

In [12]: #saisie par utilisation des matrices particulieres

M=5*np.eye(4)-np.ones((4,4))

[M[0,3],M[1,2],M[2,1],M[3,0]]=np.zeros(4)

b=np.array([50,30,70,50])

M,b

(array([[ 4., -1., -1., 0.],

Out[12]:
[-1., 4., 0., -1.],

[-1., 0., 4., -1.],

[ 0., -1., -1., 4.]]),

array([50, 30, 70, 50]))

 1. Montrer que le système est de Cramer.

In [13]: #on vérifie que det(A)#0

np.linalg.det(M)

192.0
Out[13]:

1. Résoudre le système

In [14]: # X=M^-1 b

X=np.linalg.inv(M).dot(b)

array([25., 20., 30., 25.])

Out[14]:

Remarque:

Parfois, il est utile d'identifier le type des élements de la matrice pour effectuer certaines
opérations.
Revenons à exercice 11 :

In [15]: #Problème

Mp=np.array([[4,-1,-1,0],[-1,4,0,-1],[-1,0,4,-1],[0,-1,-1,4]])

b=np.array([50,30,70,50])

np.linalg.inv(Mp).dot(b)

array([25., 20., 30., 25.])

Out[15]:

In [17]: #Solution

Ms=np.array([[4,-1,-1,0],[-1,4,0,-1],[-1,0,4,-1],[0,-1,-1,4]],float)

b=np.array([50,30,70,50])

np.linalg.inv(Ms).dot(b)

array([25., 20., 30., 25.])

Out[17]:

np.arange() et np.linspace

Les fonctions np.arange() et np.linspace retournent un objet de type

numpy.ndarray .

np.arange(n,m) permet d’obtenir un tableau 1D de la valer de départ n à la

valeur de fin m-1 avec un pas 1 .

In [38]: #np.arange(2,8)

np.arange(m) permet d’obtenir un tableau 1D de la valer de départ 0 à la

valeur de fin m-1 avec un pas 1 .

In [39]: #np.arange(8)

np.arange(n,m,p) permet d’obtenir un tableau 1D de la valer de départ n à la

 valeur de fin m-1 avec un pas p .

In [40]: #np.arange(2,8,2)

np.linspace(n,m,p) permet d’obtenir un tableau 1D allant d’une valeur de

départ n à une valeur de fin m avec un pas p.

In [41]: #np.linspace(-1,1,0.2)

Exercice(11) : (synchrone)

Ecrire une fonction def_mat qui prend à l’entrée un entier $n≥2$ et affiche la
matrice $A$ définie par $A=(a_{ij})_{i,j}$ tel que

$$a_{ij}=\left \{
\begin{array}{rcl}
i+j+1 \quad \textrm{si} \quad i>j\\
i+j-1 \quad \textrm{si}
\quad i<j\\
i \quad \textrm{si } \quad i=j
\end{array}
\right.$$

In [20]: #Correction
import numpy as np

def def_mat(n):

a=np.zeros((n,n))

for i in np.arange(n):

for j in np.arange(n):

if i>j:

a[i,j]=i+j+1

elif i<j:

a[i,j]=i+j-1

else:

a[i,j]=i

return a

def_mat(2)

array([[0., 0.],

Out[20]:
[2., 1.]])

Partie II : Représentations graphiques

sous Python
Nous importons la bibliothèque matplotlib.pyplot

In [21]: import matplotlib.pyplot as plt

Tracer des lignes

Pour tracer des lignes, nous devons utiliser la commande plot du module pyplot. Elle
peut ne prendre aucun

argument. En effet, si nous lui passons une liste [a, b, c] en argument, elle reliera le
points A(0, a) au

point B(1, b) et ce point B au point C(2, c). En fait, nous fournissons les ordonnées dans
une liste, et les
 abscisses, elles, sont automatiquement générées et vont de 0 à len(liste) - 1. Ainsi, le
code suivant…

In [44]: plt.plot([0, 1, 2])

[<matplotlib.lines.Line2D at 0x1546f0484f0>]
Out[44]:

Permet d’obtenir la droite passant par les points A(0, 0), B(1, 1) et C(2, 2). Au contraire,
le code…

In [47]: plt.plot([1, 0, 2])

[<matplotlib.lines.Line2D at 0x1546f3f8f10>]
Out[47]:

permet d’obtenir les droites passants par les points A(0, 1), B(1, 0) et C(2, 2)

Tracer une figure

Cependant, on peut aussi passer deux listes en arguments à plot. La première liste
correspondra à la liste des

abscisses des points qu'on veule relier et la seconde à la liste de leurs ordonnées. Ainsi,
le code précédent

pourrait être le suivant.

In [48]: x = [0, 1, 2]

y = [1, 0, 2]

plt.plot(x, y)

[<matplotlib.lines.Line2D at 0x1546f45fa00>]
Out[48]:

Exercice (10)

dessiner le triangle ABC avec A(0, 0), B(1, 1) et C(-1, 1).

In [49]: x = [0, 1, -1, 0]

y = [0, 1, 1, 0]

plt.plot(x, y)

[<matplotlib.lines.Line2D at 0x1546f4cb1c0>]
Out[49]:

Tracer une fonction mathématique

Tracer la fonction sin() sur $[0,2\pi]$.

In [22]: import numpy as np

x = np.arange(0, 2 * np.pi, 0.01) # On crée un array qui va de 0 à 2pi ex

plt.plot(x, np.sin(x)) # On utilise plot avec l'array x et l'array cos(x)

[<matplotlib.lines.Line2D at 0x16bbfd51d60>]
Out[22]:
 Activité

Le code suivant trace la même courbe, essayer de le commenter en utilisant toute

source possible.

In [51]: x=np.arange(0,2*np.pi,0.01)#abcisses

y=np.sin(x) #ordonnées

plt.figure(figsize=(20,10)) #dimensions de la figure

plt.plot(x,y,'r--', linewidth=2, markersize=8) # tracer y en fonction de

plt.xlabel('x',fontsize=30) # lengende sur l'axe des abcisses

plt.legend(('sin(x)'),fontsize=30,loc = 0) # lengende sur l'axe des ordon

plt.xticks(fontsize=20)#taille de police sur les abcisses

plt.yticks(fontsize=20)#taille de police sur les ordonnées

plt.title('Ma première figure', fontsize=30)

plt.grid(True)

Références

[1] Kiusalaas, J. (2013). Numerical methods in engineering with Python 3. Cambridge

university press.

[2] Numpy Package

[3] Mathplotlib Package

[4] Jupyter markdowns