Manipuler des tableaux

Manipuler des tableaux#

Dans cette feuille, vous allez apprendre à effectuer quelques manipulations simples sur les tableaux, comme nous l’avions fait au premier semestre avec les vector de C++. En Python, de tels tableaux peuvent être représentés par les array de la bibliothèque NumPy (usuellement abrégée en np) :

import numpy as np

Tableaux à deux dimensions#

Voilà un tableau à deux dimensions avec deux lignes et quatre colonnes:

T = np.array([[1, 2, 3, 4], 
              [5, 6, 7, 8]])

T

array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

Vous noterez que l’on a construit le tableau avec la fonction np.array à partir d’une liste de deux listes donnant respectivement le contenu de la première et la seconde ligne du tableau. Puis on a affecté le tableau obtenu à la variable T.

On peut retrouver les tailles de ce tableau avec:

T.shape

(2, 4)

Vous vous rappellez que les vector de C++ sont intrinsèquement des tableaux à une dimension, et que l’on émule des tableaux à deux dimensions avec des tableaux de tableaux. Ici, en revanche, les tableaux array de numpy permettent de construire explicitement des tableaux à deux dimensions.

Exercice#

  1. En vous inspirant de l’exemple ci-dessus, construisez un tableau à trois lignes et trois colonnes, contenant les entiers de 1 à 9 de gauche à droite et de haut en bas comme dans la figure suivante:

    1 2 3
4 5 6
7 8 9

### BEGIN SOLUTION
T2 = np.array([[1,2,3],
               [4,5,6],
               [7,8,9]])
### END SOLUTION
T2

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

Nous testons la forme du tableau:

assert T2.shape == (3,3)

ainsi que son contenu :

assert [ T2[i,j] for i in range(3) for j in range(3) ] == [1, 2, 3, 4, 5, 6, 7, 8, 9]

Voici comment accéder au contenu d’une case individuelle du tableau :

T2[1,2]

np.int64(6)

Cette case est en deuxième ligne et troisième colonne: en effet, comme en C++, les lignes et colonnes sont numérotées à partir de 0.

Si l’on veut extraire toute une ligne, ou toute une colonne, on remplace la coordonnée que l’on veut laisser libre par :. Ainsi, dans l’exemple suivant, on extrait la deuxième colonne (donc d’indice \(1\)) en laissant libre l’indice de la ligne, et en fixant l’indice de la colonne à 1:

T2[:,1]

array([2, 5, 8])

Extrayez la deuxième ligne du tableau et affectez-la à la variable li dont vous afficherez le contenu :

### BEGIN SOLUTION
li = T2[1,:]
li
### END SOLUTION

array([4, 5, 6])

assert isinstance(li, np.ndarray)
assert li.shape == (3,)
assert list(li) == [4,5,6]

Tableaux à trois dimensions et plus#

Pour le moment, nous avons utilisé des tableaux à deux dimensions. Ultérieurement, notamment pour représenter des images, nous aurons besoin de tableaux de plus grande dimension: un seul nombre ne suffit en effet pas pour représenter un pixel.

Numpy permet de représenter des tableaux de toute dimension. Voici un tableau de dimension 3 :

T3D = np.array([[[ 1, 2, 3], [ 4, 5, 6], [ 7, 8, 9]],
                [[10,11,12], [13,14,15], [16,17,18]],
                [[19,20,21], [22,23,24], [25,26,27]]
                ])

On peut le voir comme un tableau à trois couches :

représentation du tableau à trois dimensions

Pour accéder à une case du tableau on utilise T[i,j,k], où i est le numéro de la ligne, j le numéro de la colonne et k le numéro de la couche contenant la case.

Comme pour les listes, on peut extraire des sous-tableaux avec les opérateurs de découpe de tranches (slicing).

Indication

Rappel: tranches (slices)

Lorsque L est une liste, l’opération L[start:stop:step] permet d’extraire une tranche de L, liste contenant tous les éléments de L d’indice entre start (inclus) et stop (exclus) par pas de step. Par défaut, start vaut 0, stop vaut len(L), et step vaut 1. Ainsi, L[:3] contient les trois premiers éléments de L (d’indice i<3) tandis que L[3:] contient les éléments suivants (d’indice 3<=i).

Plus généralement, cette opération s’applique à la plupart des objets indexés par des entiers.

On peut ainsi extraire ces couches comme suit :

T3D[:,:,0]

array([[ 1,  4,  7],
       [10, 13, 16],
       [19, 22, 25]])

T3D[:,:,1]

array([[ 2,  5,  8],
       [11, 14, 17],
       [20, 23, 26]])

T3D[:,:,2]

array([[ 3,  6,  9],
       [12, 15, 18],
       [21, 24, 27]])

Exercices#

Extrayez la première colonne de la deuxième couche de T3D et stockez-la dans la variable C:

### BEGIN SOLUTION
C = T3D[:,0,1]
### END SOLUTION
C

array([ 2, 11, 20])

Notez que c’est un tableau à une dimension, donc noté en ligne !

assert list(C) == [2, 11, 20]

Maintenant, extrayez un tableau contenant la première colonne de chacune des trois couches de T3D et stockez le dans la variable C. Notez que l’on souhaite que ces colonnes soient bien représentées par des colonnes dans C !

À faire

Ajouter une indication: Cela se fait en un seul appel à T[…,…,…]. Pour chacune des trois coordonnées (numéro de ligne, de colonne, de couche) décidez si vous souhaitez la fixer ou la laisser libre.

### BEGIN SOLUTION
C = T3D[:,0,:]
### END SOLUTION
C

array([[ 1,  2,  3],
       [10, 11, 12],
       [19, 20, 21]])

for i in range(3):
    assert np.array_equal(T3D[:,0,i], C[:,i])

Statistiques simples sur les tableaux#

Numpy permet de faire des statistiques simples sur les tableaux. Revenons à notre tableau T :

T

array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

Calculez à la main :

  • la moyenne de chaque colonne de T;

  • la moyenne de chaque ligne de T;

  • la moyenne de tous les éléments du tableau T.

Comparez vos résultats avec ceux des calculs suivants. Que calcule chaque commande ci-dessous?

T.mean(axis=0)

array([3., 4., 5., 6.])

REPONDEZ ICI

T.mean(axis=1)

array([2.5, 6.5])

REPONDEZ ICI

T.mean()

np.float64(4.5)

REPONDEZ ICI

Conclusion#

Voilà, vous avez vu tous les éléments de manipulation des tableaux NumPy dont nous aurons besoin aujourd’hui.