Memento numpy¶

La bibliothèque numpy est capable de gérer des variables de typé array. Une variable du type array peut être vue comme une liste dont les éléments sont toujours du même type. C’est cette catégorie de variable que nous avons choisi d’utiliser pour représenter des vecteurs et des matrices.

Création de vecteurs et matrices¶

Après avoir chargé la bibliothèque numpy par la commande :

import numpy as np

La création d’un tel objet est réalisé comme suit

a=np.array([[1,2,3],[4,5,6]],float)
b=np.array([1,2,3])
bb=b.copy() # Copie du tableau dans une autre variable

Lors de la création d’une variable array, un secon argument optionnel permet de spécifier le type des éléments qu’elle contient.

Commandes	Utilité
`np.array([elt1,elt2,...,eltn])`	Création d’un vecteur ligne
`np.array([[elt1],[elt2],...,[eltn]])`	Création d’un vecteur colonne
`copy()`	Méthode pour copier une variable de type `array`
`x.size`	Taille du vecteur x sous la forme d’un tuple
`A.shape`	Taille de la matrice A sous la forme d’un tuple
`np.linspace(debut,fin,N)`	Vecteur ligne avec `N` valeur équiréparties entre début et fin
`np.linspace(debut,fin)`	Vecteur ligne avec 50 valeurs équiréparties entre début et fin
`np.arange(N)`	Vecteur ligne avec le `N` entiers de 0 à `N-1`
`np.arange(a,b,pas)`	Vecteur ligne avec les valeurs variant de `a` à `b` exclus distantes de `pas`
`np.zeros(n)`	Vecteur ligne nul de taille `n`
`np.zeros((n,p))`	Matrice nulle de taille `n*p`
`np.zeros_like(A)`	Matrice nulle de même dimension que la matrice `A`
`np.eye(n)`	Matrice de taille `n*n` avec des 1 sur la diagonale
`np.ones(n)`	Vecteur ligne ne contenant que la valeur 1, de taille `n`
`np.ones((n,p))`	Matrice de taille `n*p` dont tous les éléments sont égaux à 1
`np.eye(n,p)`	Matrice de taille `n*p` avec des 1 sur la diagonale
`np.diag(v)`	Matrice diagonale dont la diagonale est le vecteur v
`np.diag(v,k)`	Matrice diagonale dont la diagonale décalée de \(k ∈ \mathbb{Z}\) est le vecteur v

Opérations usuelles¶

Commandes	Utilité
`A+B`	Addition de deux matrices de même dimension
`v+w`	Addition de deux vecteur de même dimension
`2+A(resp.2+v)`	Ajout d’un scalaire à chaque coefficient d’un vecteur (resp. d’une matrice)
`2A(resp.2v)`	Multiplication d’un vecteur (resp. d’une matrice) par un scalaire
`A*3(resp.v3)`	Matrice (resp. vecteur) dont tous les coefficients sont élevés au cube
`1/A(resp.1/v)`	Matrice (resp. vecteur) dont tous les coefficients sont donnés par \(x→\frac{1}{x}\)
`np.sin(A)`	Sinus de tous les termes de la matrice A

Opérations d’algèbre linéaire¶

Commandes	Utilité
`np.dot(A,B)`	Produit matriciel de AB
`np.dot(A,v)`	Produit de Av
`np.dot(v,A)`	Produit de v \(^T\) A
`np.vdot(v,w)`	Produit scalaire < v , w > = v \(^T\) w
`A.transpose()`	A \(^T\) transposée de la matrice A

Pour inverser une matrice, il faut appeler la méthode inv de la bibliothèque linalg de numpy. Dans le préambule, il faut donc ajouter:

import numpy.linalg as linalg

L’inversion d’une matrice peut s’obtenir à l’aide du code ci-après

A=np.array([[1,0,0],[0,1,2],[0,2,1]])
linalg.inv(A)

Autres opérations utiles¶

Commandes	Utilité
`x.max()` (resp. x.min())	Plus grand (resp. plus petit) élément du vecteur x
`A.max()` (resp. A.min())	Plus grand (resp. plus petit) élément de la matrice `A`
`A.max(0)` (resp. A.min(0))	Plus grands (resp. plus petits) éléments de chaque colonne de la matrice `A`
`A.max(1)` (resp. A.min(1))	Plus grands (resp. plus petits) éléments de chaque ligne de la matrice `A`
`x.mean()` (resp. A.mean())	Moyenne des éléments du vecteur x (resp. de la matrice `A` )
`x.std()` (resp. A.std())	Écart-type des éléments du vecteur x (resp. de la matrice `A` )
`x.sum()` (resp. A.sum())	Somme des éléments du vecteur x (resp. de la matrice `A` )
`x.prod()` (resp. A.prod())	Produit des éléments du vecteur x (resp. de la matrice `A` )
`x.cumsum()` (resp. A.cumsum())	Somme cumulée des éléments du vecteur x (resp. de la matrice `A` )
`A[(A>1)]`	Éléments de la matrice `A` strictement supérieur à 1
`A[((A>1) & (A<=3))]`	Éléments de la matrice`` A`` strictement supérieur à 1 et inférieurs ou égaux à 3

Redimensionnement¶

Avertissement

Numpy propose le redimentsionnement d’un tableau avec la fonction reshape avec la condition suivante :

Le nombre d’éléments doit être inchangé.

Tester le code suivant:

a=np.arange(12)
print(a)
b=a.reshape(3,4)
print(b)
c=a.reshape(2,6)
print(c)

Concaténantion¶

Numpy permet d’assembler les vecteurs et les matrices ( on parle de concaténation). Par défaut, l’assemblage se fait selon les lignes (l’axe horizontal), mais on peut aussi signifier que l’assemblage doit se faire selon les colonnes (l’axe vertical) avec l’otpion axis=1.

Tester le code suivant :

a=np.linspace(2,21,20).reshape(4,5)
print(a)
b=np.linspace(10,29,20).reshape(4,5)
print(b)
print(np.concatenate((a,b)))
print(np.concatenate((a,b),axis=1))

Accès aux termes d’une matrice¶

En tenant compte du fait que les lignes et les colonnes sont numérotées à partir de 0, on peut utiliser les commandes suivantes:

Commandes	Utilité
`A[i,j]`	Accès à l’élément de A en i-ième ligne et j-ième colonne
`A[i,:]`	Ligne de i de A
`A[:,j]`	Colonne de j de A (résultat sous forme d’un vecteur ligne)
`A[i1:i2,j1:j2]`	Sous-matrice de la ligne i1 à i2 exclue et de la colonne j1 à j2 exclue
`x[-1]`	Retourne le dernier élément du vecteur x
`A[-1,-1]`	Retourne l’élément situé sur la dernière ligne et dernière colonne de la matrice A
`A[-1]`	Retourne la dernière ligne de la matrice A

Exercices¶

Exercice 10 - Manipulations de vecteurs

On donne:

\(u_1=\begin{bmatrix}1\\ 2\\ 3\end{bmatrix}\) \(u_2=\begin{bmatrix}-5\\ 2\\ 1\end{bmatrix}\) \(u_1=\begin{bmatrix}-1\\ -3\\ 7\end{bmatrix}\)

Définir ces vecteurs.

Calculer \(u_1+u_2 , u_1+3u_2-5u_3 , u_3/5\)

Calculer le produit des compansantes des vecteur \(u_1\) et \(u_2\), terme à terme.

Calculer les produits \(u_1^Tu_2\) et \(u_1u_2^T\).

Crée par concaténation la matrice : \(\begin{bmatrix}1 & -5 &-1 \\ 2 & 2 & -3 \\ 3 & 1 & 7\end{bmatrix}\)

Exercice 11 - Opérations matricielles

Soit le vecteur \(u=\begin{bmatrix}1\\2\\-5\\2\\-1\\-3\end{bmatrix}\) .

Calculer la somme des composantes du vecteur u sans utiliser la fonction sum de numpy

Calculer le produit des composantes du vecteur u sans utiliser la fonction prod de numpy