Comment ajouter des éléments à un tableau en Python

Introduction

Python n'a pas de type de données de tableau intégré, cependant, il existe des modules que vous pouvez utiliser pour travailler avec des tableaux. Cet article décrit comment ajouter à un tableau en utilisant les modules array et NumPy. Le module array est utile lorsque vous devez créer un tableau d'entiers et de nombres à virgule flottante. Le module NumPy est utile lorsque vous devez effectuer des opérations mathématiques sur un tableau.

Dans de nombreux cas, vous pouvez utiliser List pour créer des tableaux car List offre de la flexibilité, comme des types de données mixtes, tout en conservant toutes les caractéristiques d'un tableau. En savoir plus sur les listes en Python.

Ajouter des éléments à un tableau en utilisant le module Array

Avec le module array, vous pouvez concaténer ou joindre des tableaux en utilisant l'opérateur + et vous pouvez ajouter des éléments à un tableau en utilisant les méthodes append(), extend() et insert().

+ operator, x + y

append(x)

extend(iterable)

insert(i, x)

L'exemple suivant montre comment créer un nouvel objet tableau en joignant deux tableaux :

import array

create array objects, of type integer
arr1 = array.array('i', [1, 2, 3])
arr2 = array.array('i', [4, 5, 6])

print the arrays
print("arr1 is:", arr1) 
print("arr2 is:", arr2)

create a new array that contains all of the elements of both arrays 
and print the result
arr3 = arr1 + arr2
print("After arr3 = arr1 + arr2, arr3 is:", arr3)

La sortie est :

arr1 is: array('i', [1, 2, 3])
arr2 is: array('i', [4, 5, 6])
After arr3 = arr1 + arr2, arr3 is: array('i', [1, 2, 3, 4, 5, 6])

L'exemple précédent crée un nouveau tableau qui contient tous les éléments des tableaux donnés.

L'exemple suivant montre comment ajouter à un tableau en utilisant les méthodes append(), extend() et insert() :

import array

create array objects, of type integer
arr1 = array.array('i', [1, 2, 3])
arr2 = array.array('i', [4, 5, 6])

print the arrays
print("arr1 is:", arr1) 
print("arr2 is:", arr2)

append an integer to an array and print the result
arr1.append(4)
print("\nAfter arr1.append(4), arr1 is:", arr1)

extend an array by appending another array of the same type 
and print the result
arr1.extend(arr2)
print("\nAfter arr1.extend(arr2), arr1 is:", arr1)

insert an integer before index position 0 and print the result
arr1.insert(0, 10)
print("\nAfter arr1.insert(0, 10), arr1 is:", arr1)

La sortie est :

arr1 is: array('i', [1, 2, 3])
arr2 is: array('i', [4, 5, 6])

After arr1.append(4), arr1 is: array('i', [1, 2, 3, 4])

After arr1.extend(arr2), arr1 is: array('i', [1, 2, 3, 4, 4, 5, 6])

After arr1.insert(0, 10), arr1 is: array('i', [10, 1, 2, 3, 4, 4, 5, 6])

Dans l'exemple précédent, chaque méthode est appelée sur l'objet tableau arr1 et modifie l'objet original.

Ajouter des éléments à un tableau NumPy

Avec le module NumPy, vous pouvez utiliser les fonctions append() et insert() de NumPy pour ajouter des éléments à un tableau.

numpy.append(arr, values, axis=None)

numpy.insert(arr, obj, values, axis=None)

La fonction numpy.append() utilise la fonction numpy.concatenate() en arrière-plan. Vous pouvez utiliser numpy.concatenate() pour joindre une séquence de tableaux le long d'un axe existant. Apprenez-en plus sur les routines de manipulation des tableaux dans la documentation NumPy.

Les exemples dans cette section utilisent des tableaux en deux dimensions (2D) pour mettre en évidence comment les fonctions manipulent les tableaux en fonction de la valeur de l'axe que vous fournissez.

Ajouter à un tableau en utilisant numpy.append()

Les tableaux NumPy peuvent être décrits par dimension et forme. Lorsque vous ajoutez des valeurs ou des tableaux à des tableaux multi-dimensionnels, le tableau ou les valeurs ajoutées doivent avoir la même forme, à l'exception de l'axe donné.

Pour comprendre la forme d'un tableau 2D, considérons les lignes et les colonnes. array([[1, 2], [3, 4]]) a une forme 2, 2 équivalente à 2 lignes et 2 colonnes, tandis que array([[10, 20, 30], [40, 50, 60]]) a une forme 2, 3 équivalente à 2 lignes et 3 colonnes.

Testez ce concept en utilisant la console interactive Python.

Tout d'abord, importez le module NumPy, puis créez quelques tableaux et vérifiez leur forme.

Importez NumPy, puis créez et imprimez np_arr1 :

import numpy as np
np_arr1 = np.array([[1, 2], [3, 4]])
print(np_arr1)

[[1 2]
 [3 4]]

Vérifiez la forme de np_arr1 :

np_arr1.shape

(2, 2)

Créez et imprimez un autre tableau, np_arr2 :

np_arr2 = np.array([[10, 20, 30], [40, 50, 60]])
print(np_arr2)

[[10 20 30]
 [40 50 60]]

Vérifiez la forme de np_arr2 :

np_arr2.shape

(2, 3)

Essayez ensuite d'ajouter des tableaux le long des différents axes. Vous pouvez ajouter un tableau de forme 2, 3 à un tableau de forme 2, 2 le long de l'axe 1, mais pas le long de l'axe 0.

Ajouter np_arr2 à np_arr1 le long de l'axe 0, ou par ligne :

np.append(np_arr1, np_arr2, axis=0)

Vous obtenez une ValueError :

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<__array_function__ internals>", line 5, in append
  File "/Users/digitalocean/opt/anaconda3/lib/python3.9/site-packages/numpy/lib/function_base.py", line 4817, in append
    return concatenate((arr, values), axis=axis)
  File "<__array_function__ internals>", line 5, in concatenate
ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 1, the array at index 0 has size 2 and the array at index 1 has size 3

Vous ne pouvez pas ajouter un tableau dont les lignes ont trois colonnes à un tableau dont les lignes n'ont que deux colonnes.

Ajoutez np_arr2 à np_arr1 le long de l'axe 1, ou par colonne :

np.append(np_arr1, np_arr2, axis=1)

La sortie est :

array([[ 1,  2, 10, 20, 30],
       [ 3,  4, 40, 50, 60]])

Vous pouvez ajouter un tableau avec des colonnes de deux lignes de hauteur à un autre tableau avec des colonnes de deux lignes de hauteur.

L'exemple suivant démontre comment ajouter des éléments à un tableau NumPy en utilisant la fonction numpy.append() :

import numpy as np

create 2D array objects (integers)
np_arr1 = np.array([[1, 2], [3, 4]])
np_arr2 = np.array([[10, 20], [30, 40]])

print the arrays
print("np_arr1 is:\n", np_arr1)
print("np_arr2 is:\n", np_arr2)

append an array to the end of another array and print the result
both arrays are flattened before appending
append_axis_none = np.append(np_arr1, np_arr2, axis=None)
print("append_axis_none is:\n", append_axis_none)

append an array to the end of another array along axis 0 (append rows)
and print the result
append_axis_0 = np.append(np_arr1, np_arr2, axis=0)
print("append_axis_0 is:\n", append_axis_0)

append an array to the end of another array along axis 1 (append columns)
and print the result
append_axis_1 = np.append(np_arr1, np_arr2, axis=1)
print("append_axis_1 is:\n", append_axis_1)

La sortie est :

np_arr1 is:
 [[1 2]
 [3 4]]
np_arr2 is:
 [[10 20]
 [30 40]]
append_axis_none is:
 [ 1  2  3  4 10 20 30 40]
append_axis_0 is:
 [[ 1  2]
 [ 3  4]
 [10 20]
 [30 40]]
append_axis_1 is:
 [[ 1  2 10 20]
 [ 3  4 30 40]]

L'exemple précédent montre comment la fonction numpy.append() fonctionne pour chaque axe du tableau 2D et comment la forme du tableau résultant change. Lorsque l'axe est 0, le tableau est ajouté par ligne. Lorsque l'axe est 1, le tableau est ajouté par colonne.

Ajouter dans un tableau en utilisant numpy.insert()

La fonction numpy.insert() insère un tableau ou des valeurs dans un autre tableau avant l'indice donné, le long d'un axe, et retourne un nouveau tableau.

Contrairement à la fonction numpy.append(), si l'axe n'est pas fourni ou est spécifié comme None, la fonction numpy.insert() aplatit uniquement le premier tableau, et ne fonctionne pas sur les valeurs ou le tableau à insérer. Vous obtiendrez une ValueError si vous essayez d'insérer un tableau 2D dans un tableau 2D sans spécifier un axe.

L'exemple suivant démontre comment insérer des éléments dans un tableau en utilisant la fonction numpy.insert() :

import numpy as np

create array objects (integers)
np_arr1 = np.array([[1, 2], [4, 5]])
np_arr2 = np.array([[10, 20], [30, 40]])
np_arr3 = np.array([100, 200, 300])

print the arrays
print("np_arr1 is:\n", np_arr1)
print("np_arr2 is:\n", np_arr2)
print("np_arr3 is:\n", np_arr3)

insert a 1D array into a 2D array and then print the result
the original array is flattened before insertion
insert_axis_none = np.insert(np_arr1, 1, np_arr3, axis=None)
print("insert_axis_none is:\n", insert_axis_none)

insert an array into another array by row
and print the result
insert_axis_0 = np.insert(np_arr1, 1, np_arr2, axis=0)
print("insert_axis_0 is:\n", insert_axis_0)

insert an array into another array by column
and print the result
insert_axis_1 = np.insert(np_arr1, 1, np_arr2, axis=1)
print("insert_axis_1 is:\n", insert_axis_1)

La sortie est :

np_arr1 is:
 [[1 2]
 [4 5]]
np_arr2 is:
 [[10 20]
 [30 40]]
insert_axis_none is:
 [  1 100 200 300   2   4   5]
insert_axis_0 is:
 [[ 1  2]
 [10 20]
 [30 40]
 [ 4  5]]
insert_axis_1 is:
 [[ 1 10 30  2]
 [ 4 20 40  5]]

Dans l'exemple précédent, lorsque vous avez inséré un tableau 2D dans un autre tableau 2D le long de l'axe 1, chaque tableau à l'intérieur de np_arr2 a été inséré comme une colonne séparée dans np_arr1. Si vous souhaitez insérer l'ensemble du tableau 2D dans un autre tableau 2D, incluez des crochets autour de la valeur d'index du paramètre obj pour indiquer que l'ensemble du tableau doit être inséré avant cette position. Sans les crochets, numpy.insert() empile les tableaux en séquence comme colonnes avant l'index donné.

L'exemple suivant montre la sortie avec et sans crochets autour du paramètre obj (index) :

import numpy as np

create 2D array objects (integers)
np_arr1 = np.array([[1, 2], [3, 4]])
np_arr2 = np.array([[10, 20], [30, 40]])

print the arrays
print("np_arr1 is:\n", np_arr1)
print("np_arr2 is:\n", np_arr2)

insert an array, column by column, into another array
and print the result
insert_axis_1 = np.insert(np_arr1, 1, np_arr2, axis=1)
print("insert_axis_1 is:\n", insert_axis_1)

insert a whole array into another array by column
and print the result
insert_index_axis_1 = np.insert(np_arr1, [1], np_arr2, axis=1)
print("insert_index_axis_1 is:\n", insert_index_axis_1)

La sortie est :

np_arr1 is:
 [[1 2]
 [3 4]]
np_arr2 is:
 [[10 20]
 [30 40]]
insert_axis_1 is:
 [[ 1 10 30  2]
 [ 3 20 40  4]]
insert_index_axis_1 is:
 [[ 1 10 20  2]
 [ 3 30 40  4]]

L'exemple précédent montre comment numpy.insert() insère des colonnes dans un tableau en fonction de la notation d'index.

Conclusion

Dans cet article, vous avez ajouté des éléments aux tableaux en utilisant les modules array et NumPy. Continuez votre apprentissage avec d'autres tutoriels NumPy et des tutoriels Python.