Concaténation et fractionnement de tableaux NumPy

La concaténation et le fractionnement de tableaux NumPy sont deux opérations importantes et opposées sur les tableaux.

La concaténation de tableaux consiste à joindre deux ou plusieurs tableaux ensemble. Nous pouvons joindre deux tableaux horizontalement ou verticalement. Nous verrons cela en détail dans ce chapitre.

Le fractionnement de tableaux consiste à diviser un tableau unique en deux parties ou plus. Nous divisons les éléments du tableau en utilisant leurs indices.

Tu comprendras mieux ces deux opérations par des exemples de code que par des définitions. Créons donc rapidement quelques tableaux et essayons ces opérations.

Commençons par la concaténation.

Concaténation de tableaux NumPy

a1 = np.arange(1, 5)
a2 = np.arange(5, 9)
a1, a2

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

Dans le code ci-dessus, j’ai créé deux tableaux d’échantillons a1 et a2 en utilisant arange().

Joignons ces deux tableaux en utilisant la méthode np.concatenation().

np.concatenate([a1, a2])

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

Nous venons de joindre deux tableaux 1D à l’aide de la méthode de concaténation.

Mais lorsqu’il s’agit de tableaux 2D ou 3D, il existe d’autres méthodes que nous pouvons utiliser pour joindre les deux tableaux sur des axes différents.

Ne t’inquiète pas si tu n’as pas compris le paragraphe précédent. L’exemple de code suivant va t’éclairer.

Créons deux tableaux 2D en utilisant arange().

a3 = np.arange(1, 10).reshape(3, 3)
a4 = np.arange(10, 19).reshape(3, 3)
a3, a4

""" (array([[1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]]),
						        
     array([[10, 11, 12],
            [13, 14, 15],
            [16, 17, 18]]))
"""

Joignons-les !

np.concatenate([a3, a4])   # concatène par lignes

""" array([[ 1,  2,  3],
           [ 4,  5,  6],
           [ 7,  8,  9],
           [10, 11, 12],
           [13, 14, 15],
           [16, 17, 18]])
"""

Les tableaux 2D sont reliés verticalement (par lignes).

Mais que se passe-t-il si je veux les joindre horizontalement (dans le sens des colonnes) ?

Pour les joindre horizontalement, nous devons passer la valeur 1 dans le paramètre axis.

np.concatenate([a3, a4], axis=1)   # concatène par colonnes

""" array([[ 1,  2,  3, 10, 11, 12],
           [ 4,  5,  6, 13, 14, 15],
           [ 7,  8,  9, 16, 17, 18]])
"""

J’espère que tu as compris.

De plus, il y a aussi 2 méthodes appelées :

• vstack() &
• hstack()

pour faire la même chose. En utilisant vstack(), nous pouvons joindre les tableaux verticalement. En utilisant hstack(), nous pouvons les joindre horizontalement.

Essayons-les.

np.vstack([a3, a4])

""" array([[ 1,  2,  3],
           [ 4,  5,  6],
           [ 7,  8,  9],
           [10, 11, 12],
           [13, 14, 15],
           [16, 17, 18]])
"""

np.hstack([a3, a4])

""" array([[ 1,  2,  3, 10, 11, 12],
           [ 4,  5,  6, 13, 14, 15],
           [ 7,  8,  9, 16, 17, 18]])
"""

Exercice : Crée trois tableaux 2D et utilise concatenate(), vstack(), et hstack() et effectue différentes opérations de jointure.

Nous allons maintenant procéder au fractionnement.

Fractionnement de tableaux NumPy

Le fractionnement de tableaux est l’inverse de la concaténation de tableau.

Créons un tableau de 10 éléments et faisons un peu de fractionnement.

a5 = np.arange(1, 10)
a5

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

np.split(a5, [4])

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

J’ai donc passé une valeur [4] dans la méthode np.split().

La valeur [4] est juste la valeur de l’index où je veux faire le fractionnement.

L’index 4 appartient à la valeur 5 dans le tableau. Ainsi, le tableau est divisé en deux, l’un contenant les valeurs d’indice 0 à 3 et l’autre contenant les valeurs d’indice 4 au reste.

Nous pouvons également diviser le tableau en plus de deux parties.

np.split(a5, [3, 5, 7])

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

Maintenant, j’ai passé 3 valeurs d’index [3, 5, 7].

Ainsi, les éléments précédant l’indice 3 constitueront la première division ([1, 2, 3]).

Les éléments allant de l’indice 3 à l’indice 5 (la valeur de l’indice 5 n’est pas incluse) constitueront la deuxième division ([4, 5]).

Les éléments allant de l’indice 5 à l’indice 7 (la valeur de l’indice 7 n’est pas incluse) constitueront la troisième division ([6, 7]).

Enfin, chaque élément à partir de l’indice 7 constituera la quatrième division ([8, 9]).

J’espère que c’est clair.

Effectuons un découpage sur un tableau 2D.

a6 = np.arange(1, 21).reshape(5, 4)
a6

""" array([[ 1,  2,  3,  4],
           [ 5,  6,  7,  8],
           [ 9, 10, 11, 12],
           [13, 14, 15, 16],
           [17, 18, 19, 20]])
"""

np.split(a6, [2])

""" [array([[1, 2, 3, 4],
            [5, 6, 7, 8]]),
						        
     array([[ 9, 10, 11, 12],
            [13, 14, 15, 16],
            [17, 18, 19, 20]])]
"""

Il modifie l’axe.

np.split(a6, [2], axis=1)

""" [array([[ 1,  2],
            [ 5,  6],
            [ 9, 10],
            [13, 14],
            [17, 18]]),
						        
     array([[ 3,  4],
            [ 7,  8],
            [11, 12],
            [15, 16],
            [19, 20]])]
"""

Comme nous l’avons vu dans la concaténation de tableaux, à propos des deux méthodes spéciales vstack() et hstack().

Nous avons obtenu :

• vsplit() &
• hsplit()

Utilisons-les.

np.vsplit(a6, [3])

""" [array([[ 1,  2,  3,  4],
            [ 5,  6,  7,  8],
            [ 9, 10, 11, 12]]),
						        
     array([[13, 14, 15, 16],
            [17, 18, 19, 20]])]
"""

np.hsplit(a6, [2])

""" [array([[ 1,  2],
            [ 5,  6],
            [ 9, 10],
            [13, 14],
            [17, 18]]),
						        
     array([[ 3,  4],
            [ 7,  8],
            [11, 12],
            [15, 16],
            [19, 20]])]
"""

Exercice : Créer un tableau 2D de forme (6, 5) en utilisant arange() et effectuer une opération de fractionnement/division en utilisant vsplit() et hsplit().

Ce chapitre est terminé.

Enfin, tu as atteint le dernier chapitre de ce cours.

Dernier chapitre 👉 Fonctions universelles NumPy (Ufuncs).