UKOnline

Création de tableau

Plusieurs fonctions sont disponibles pour créer un tableau multidimensionnel, de manière plus simple que directement avec le constructeur de ndarray. On peut tout d'abord en créer un à partir d'une liste Python, à l'aide de la fonction array :

La première instruction crée un tableau à une dimension à partir d'une simple liste de nombres entiers. Le second tableau créé a, quant à lui, deux dimensions, car il a été créé à partir d'une liste de listes de nombres entiers. Voici le résultat de l'exécution :

[1 2 3]
[[1 2 3]
 [4 5 6]]

Tableau initialisé

On peut également créer des tableaux multidimensionnels dont tous les éléments sont initialisés à zéro avec la fonction zeros et à un avec la fonction ones. Les deux fonctions prennent en paramètre un tuple décrivant les dimensions désirées, exactement comme pour la création par le constructeur. On peut donc, par exemple, écrire :

La première instruction crée un tableau à une dimension dont les deux éléments sont initialisés à zéro. La seconde instruction, quant à elle, crée un tableau à deux dimensions (respectivement $1$ et $2$), dont tous les éléments sont initialisés à un. Malgré que les deux tableaux ont la même taille, à savoir deux, ils n'ont pas les mêmes dimensions ! Notez bien la différence sur le résultat de l'exécution, visible avec les crochets en plus sur la deuxième ligne affichée :

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

Pour créer un tableau d'une seule dimension avec la fonction zeros ou ones, on n'est en fait pas obligé de passer un tuple en paramètre. En effet, un seul nombre entier suffit et on aurait donc pu écrire :

Pour initialiser un tableau multidimensionnel avec une valeur $k$, il suffit d'utiliser la fonction full qui prend en paramètre un tuple avec les dimensions désirées et la valeur d'initialisation. On peut donc, par exemple, écrire les instructions suivantes :

On vient ainsi de créer un tableau à deux dimensions (respectivement $1$ et $3$) dont tous les éléments sont initialisés à 0,5 :

[[0.5 0.5 0.5]]

On peut également remplacer tous les éléments d'un tableau déjà existant avec une même valeur à l'aide de la méthode fill de la classe ndarray. L'exemple suivant crée un nouveau tableau initialisé avec des valeurs aléatoires à l'aide de la fonction empty, qui prend un tuple de dimensions en paramètre, puis modifie tous les éléments de ce dernier :

Comme on le constate sur le résultat de l'exécution, le tableau est initialement rempli de valeurs aléatoires pour ensuite n'être composé que de 0,5, après l'appel de la méthode fill sur le tableau data :

[[-1.72723371e-077 -3.11107841e+231  2.15214072e-314]]
[[0.5 0.5 0.5]]

Enfin, on peut également initialiser un tableau multidimensionnel avec une valeur $k$ à l'aide d'opérations sur les ndarray. On peut soit multiplier par $k$ un tableau initialisé avec des $1$, soit ajouter $k$ aux éléments d'un tableau initialisé avec des $0$. Les deux tableaux suivants sont donc équivalents à ceux précédemment créés :

Les opérations possibles sur des tableaux multidimensionnels sont le sujet de la section 2.6, plus loin dans le même chapitre.

Séquence incrémentale

On peut aussi créer des tableaux unidimensionnels dont les éléments forment des séquences incrémentales. La fonction arange, similaire à la fonction prédéfinie range de Python, permet de créer une telle séquence en spécifiant l'élément de début et celui de fin, et éventuellement le pas d'incrément. Voici trois exemples d'utilisation de cette fonction :

Le résultat de l'exécution permet de constater que l'élément de début est optionnel et vaut $0$ par défaut, que le pas d'incrément est également optionnel et vaut $1$ par défaut, et que l'élément de fin n'est pas inclus :

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

Avec la fonction arange, la taille du tableau unidimensionnel créé dépend des valeurs des paramètres fournis, à savoir les éléments de début et de fin et le pas d'incrément. Néanmoins, on peut vouloir imposer la taille du tableau à créer, en ne spécifiant que l'élément de début et celui de fin, et en laissant le pas d'incrément se calculer tout seul. Pour cela, on utilise la fonction linspace qui sépare les éléments du tableau créé de manière linéaire. Voici deux façons de créer un ndarray de taille $6$ dont les éléments sont équitablement répartis entre $2$ et $7$ :

Le paramètre optionnel endpoint indique si l'on désire que l'élément de fin fasse partie des éléments du tableau créé ou non. Les deux tableaux créés diffèrent donc par le fait que $7$ est un élément du tableau dans le premier cas, mais ne peut pas en faire partie dans le second cas. Voici le résultat de l'exécution :

[2. 3. 4. 5. 6. 7.]
[2.         2.83333333 3.66666667 4.5        5.33333333 6.16666667]

Dans le premier cas, on veut six éléments entre $2$ et $7$, inclus, ce qui fait que ces derniers seront séparés de $1$. Dans le second cas, $7$ est exclu et les éléments du tableau seront donc séparés de $5/6$.

De manière générale, si on veut obtenir $n$ éléments équitablement répartis entre $start$ et $end$, ils seront séparés de :

$$step = \frac{end - start + 1}{n} \qquad\textrm{ou}\qquad step = \frac{end - start}{n},$$

selon qu'il faut inclure $end$ ou non dans le tableau créé. On peut donc voir la fonction linspace comme un raccourci de la fonction arange, avec un $step$ comme on vient de définir. Par défaut, si on ne précise pas le nombre d'éléments désirés avec la fonction linspace, ce dernier vaut $50$.

Notez qu'il existe aussi les fonctions logspace et geomspace qui créent également des séquences incrémentales, sauf que les éléments du tableau créé suivent une échelle logarithmique ou géométrique. L'exemple suivant montre ces deux fonctions en action :

La base pour logspace étant, par défaut, de $10$, la première instruction demande quatre éléments entre $10^0$ et $10^3$, suivant une échelle logarithmique. La seconde instruction crée une progression géométrique, partant de $1$ jusqu'à $1000$, qui contient quatre éléments. Pour l'exemple présenté, les deux instructions génèrent donc le même résultat :

[   1.   10.  100. 1000.]
[   1.   10.  100. 1000.]

On peut changer la base utilisée par logspace avec le paramètre optionnel base. Dans les deux cas, on peut utiliser endpoint pour décider d'utiliser ou non le second paramètre comme dernier élément du tableau créé.

Combinaison

On peut également créer des tableaux multidimensionnels en en combinant plusieurs déjà existants. Les deux principales fonctions pour ce faire sont hstack et vstack qui empilent plusieurs tableaux, respectivement horizontalement et verticalement. Voyons tout de suite un premier exemple d'empilement vertical :

La première instruction crée un tableau unidimensionnel à deux éléments et de dimensions $(1, 2)$. On empile ensuite trois fois ce tableau, verticalement, l'un au-dessus de l'autre, avec la fonction vstack. Cette dernière prend en paramètre un tuple contenant les tableaux qu'il faut empiler. Le résultat obtenu est le suivant :

[[0 1]
 [0 1]
 [0 1]]
(3, 2)

On voit bien que le tableau créé par vstack a comme dimensions $(3, 2)$ et contient trois fois le tableau initialement créé dans la variable line. Dans notre exemple, la fonction vstack a en fait copié trois fois les éléments du tableau line, pour créer un nouveau tableau data. Pour que cela fonctionne, il faut bien évidemment que les dimensions des tableaux empilés soient compatibles. L'instruction suivante, par exemple, provoque une erreur d'exécution :

La fonction hstack permet, quant à elle, de faire la même opération, mais de manière horizontale. On peut, par exemple, empiler deux fois le tableau data, précédemment créé, horizontalement :

Comme le montre le résultat de l'exécution, on se retrouve maintenant avec un tableau de dimensions $(3, 4)$, ce qui est logique, car on a mis côte-à-côte deux tableaux de dimensions $(3, 2)$ :

[[0 1 0 1]
 [0 1 0 1]
 [0 1 0 1]]
(3, 4)

De manière plus générale, on peut utiliser la fonction concatenate qui permet de « coller » ensemble plusieurs tableaux tout en précisant l'axe le long duquel on désire réaliser l'opération.

Par défaut, l'opération de concaténation se fait le long de l'axe $0$. On peut aussi spécifier None comme valeur d'axe, dans lequel cas les tableaux sont transformés en un équivalent unidimensionnel avant d'être concaténés. Cette transformation particulière est détaillée plus loin dans le chapitre, à la section 2.5. Voici un exemple de concaténation de tableaux :

La première concaténation se fait le long du premier axe et revient donc à un empilement vertical de main « au-dessus » de bottom. La deuxième se fait suivant l'axe $1$, ce qui revient à un empilement horizontal de main « à gauche » de right. Enfin, la troisième instruction concatène les transformations unidimensionnelles des tableaux main et right. Voici le résultat de l'exécution de ces instructions :

[[1 3]
 [2 4]
 [5 6]]
[[1 3 5]
 [2 4 6]]
[1 3 2 4 5 6]