Deux documents pouvant être utiles :
Construction d'une liste en extension :
lst1 = [0,2,4,6]
lst1
Construction d'une liste en compréhension :
lst2 = [2*i+1 for i in range(4)]
lst2
Index et slicing :
lst2[0]
lst2[-1]
lst2[1:3]
Et plein d'autres choses à découvrir...
Nous devons importer le module numpy qui propose des tableaux multi-dimensionnels mais aussi des fonctions mathématiques :
import numpy as np # on préfixera toutes les fonctions de numpy avec np
Construction à partir d'une liste :
tab1 = np.array(lst1)
tab1
Il s'agit d'un tableau numpy
type(tab1)
à une dimension possédant 4 éléments
tab1.shape
tous de même type (entier 32 bits ici)
tab1.dtype
Attention au typage dynamique !
tab2 = tab1/2
tab2
La division par 2 fournit des flottants (avez-vous remarqué le point ?) malgré la parité des dividendes
tab2.dtype
Les opérations se font avec le plus grand type (une belle relation d'ordre)
tab1+tab2
Avez-vous remarqué que les opérations sur les tableaux se font terme à terme ? D'où l'efficacité de ce type...
2+tab1
2*tab1
tab1*tab2
tab1**2
np.cos(tab1)
Construction à partir d'une liste (de listes) :
lst3 = [lst1,lst2]
tab1 = np.array(lst3)
print(lst3)
tab1
Il s'agit d'un tableau numpy à deux dimensions avec :
tab1.shape
Attention à l'indexation double !
lst3[0][2]
tab1[0][2]
tab1[0,2]
lst3[0,2]
Construction en compréhension :
def maFct(i,j):
return(i+j)
tab2 = np.fromfunction(maFct,(4,4))
tab2
Construction à partir d'un tableau de dimension 1 :
tab3 = tab2[:,0:2] # on prend une partie de tab2 pour en faire un tableau 2D avec 4 lignes et 2 colonnes
print('tab3 : \n',tab3,'\n') # on notera la différence d'affichage selon que l'on utilise ou pas la fonction print
tab4 = tab3.flatten() # on "applatit" tab3 pour en faire un tableau 1D avec 8 éléments
print('tab4 : \n',tab4,'\n')
tab5 = tab4.reshape(2,4) # on redimensionne tab4 pour en faire un tableau 2D avec 2 lignes et 4 colonnes
print('tab5 : \n',tab5,'\n')
numpy propose aussi des tableaux prédéfinis...
I = np.eye(4)
print('I : \n',I,'\n')
J = np.ones((4,4))
print('J : \n',J,'\n')
N = np.zeros((4,4))
print('N : \n',N,'\n')
... que l'on peut modifier, notamment avec des boucles :
tab6 = np.zeros((4,4))
for i in range(4):
for j in range(4):
tab6[i,j]=(j+1)**i
print('tab6 : \n',tab6,'\n')
tab7 = np.zeros((4,4))
for i in range(4):
for j in range(4):
tab7[i,j]=j*j + i/(j+1)
print('tab7 : \n',tab7)
La plupart des "traitements matriciels" sont disponibles sur les tableaux
np.transpose(tab5)
Certains nécessitent le sous module linalg
from numpy import linalg
print('Le déterminant : ',linalg.det(tab6),'\n')
print('La matrice inverse : \n',linalg.inv(tab6))
print('Le déterminant : ',linalg.det(tab7),'\n')
print('La matrice inverse : \n',linalg.inv(tab7))
Ne pas confondre la multiplication terme à terme et la multiplication matricielle !!!
print('Un produit terme à terme :\n',tab1*tab5,'\n')
print('Un produit matriciel :\n',np.dot(tab1,tab3))
np.dot(tab1,tab5) # produit matriciel non valide
Pour la multiplication matricielle, on pourra aussi utiliser le raccourci @
tab1 @ tab3
Pour les "traitements matriciels", il existe aussi le type matrix
mat1 = np.matrix(lst3) # on peut construire une matrice à partir d'une liste (de listes)
mat1
Il s'agit bien d'une matrice
type(mat1)
Le symbole * prend alors le sens de produit matriciel !!!
mat3 = np.matrix(tab3) # on peut évidemment construire une matrice à partir d'un tableau
print('Un produit matriciel :\n',mat1*mat3)
Attention, numpy et scipy ("extension" de numpy) sont des modules de calcul numérique (approché) alors que sympy est un module de calcul formel (exact avec éventuellement des variables/paramètres non valués). L'utilisation de numpy nécessite donc un certain esprit critique !!!
from sympy import *
init_session()
mat6 = Matrix(tab6)
mat6
mat7 = Matrix(tab7)
mat7
mat6.det()
mat6.inv()
mat7.det() # à comparer avec le résultat obtenu précédemment !
mat7.inv() # à comparer avec le résultat obtenu précédemment !
L'objectif est de (re)faire cet exercice avec numpy et sympy.
On considère les matrices $ A=\left(\begin{array}{cccc} 1 & 2 & -1 & 3 \\ 3 & 0 & 1 & -4 \\ 5 & 4 & -1 & 2 \end{array}\right) $ et $ B=\left(\begin{array}{ccc} 1 & 2 & 1 \\ 3 & 4 & 1 \\ 5 & 6 & 1 \\ 7 & 8 & 1 \end{array}\right) $.
Calculer $C=AB$.
Calculer $\det(C-I)$ où $I$ désigne la matrice identité d'ordre 3.
En déduire que $C-I$ est inversible et déterminer son inverse.
L'objectif est de (re)faire cet exercice avec numpy et sympy.
On considère $f$ l'application linéaire de $\mathbb R^3$ dans $\mathbb R^3$ associée à $A= \left(\begin{array}{ccc} 9 & -6 & 10 \\ -5 & 2 & -5 \\ -12 & 6 & -13 \end{array}\right) $ et les vecteurs $u,v,w\in\mathbb R^3$ définis par : $$u=(2,-1,-2),\ v=(1,0,-1),\ w=(-2,1,3)$$
Montrer que la famille $\big(u,v,w\big)$ est une base de $\mathbb R^3$.
On notera $\mathcal B$ la base canonique de $\mathbb R^3$ et $\mathcal B'=\big(u,v,w\big)$.
Déterminer $P$ la matrice de passage de $\mathcal B$ à $\mathcal B'$ (attention à l'ordre), puis la matrice de passage de $\mathcal B'$ à $\mathcal B$.
En déduire les coordonnées de $(1,2,3)$ dans la base $\mathcal B'$.
A partir du diagramme de décomposition de $f$, déterminer $D=\mathcal M\big(f,\mathcal B'\big)$.