Tutoriel Numpy - Création de tableaux NumPy

1. Tableau de zéros
2. Ones Array
3. Tableau en diagonale
4. Réseau triangulaire

Tableau de zéros

np.zeros

Le tableau np.zeros est utilisé pour créer un tableau dont tous les éléments sont 0. Sa syntaxe est ,

np.zeros(shape, dtype=float, order="C")

Où,

La shape est la taille de la matrice, et elle peut être 1-D, 2-D ou à dimensions multiples.

dtype est float64 par défaut, mais peut être assigné avec n’importe quel type de données dans NumPy.

Créons quelques tableaux de zéros

>>> import numpy as np
>>> np.zeros(5)		# it creates a 1D array with 5 zeros
array([0., 0., 0., 0., 0.])
>>> np.zeros(5, dtype='int8')	# it creates a 1D array with 5 zeros with the data type of int8
array([0, 0, 0, 0, 0], dtype=int8)
>>> np.zeros((4, 3)) # it creates a 4x3 zeros array
array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

np.empty

Dans certains cas, vous voulez seulement initialiser un tableau avec la forme spécifiée et vous ne vous souciez pas des données d’initialisation à l’intérieur. Vous pouvez utiliser np.empty pour obtenir une initialisation plus rapide, mais gardez à l’esprit que cela ne garantit pas que la valeur du tableau créé soit 0.

Nous pourrions utiliser %timeit pour comparer le temps d’exécution de np.empty() et np.zeros(),

In[1]: % timeit np.empty((100, 100))
715 ns ± 11.6 ns per loop(mean ± std. dev. of 7 runs, 1000000 loops each)
In[2]: % timeit np.zeros((100, 100))
4.03 µs ± 104 ns per loop(mean ± std. dev. of 7 runs, 100000 loops each)

Evidemment, np.empty() est beaucoup plus rapide que np.zeros() à l’initialisation. Il ne faut qu’environ 17,5% du temps nécessaire à np.zeros() pour initialiser un tableau de la forme de (100, 100).

np.zeros_like

Supposons que nous ayons déjà un tableau et que nous voulions créer un tableau de zéros ayant la même forme. Nous pourrions utiliser la méthode traditionnelle pour créer ce nouveau tableau.

test = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
np.zeros(test.shape)

Ou nous pourrions utiliser la méthode dédiée - np.zeros_like() pour créer le nouveau tableau plus efficacement.

x = np.zeros_like(test)

Ones Array

np.ones

Comme pour les zeros, nous pourrions aussi créer un tableau rempli de uns. La syntaxe et les paramètres de np.ones() sont identiques à ceux de np.zeros().

>>> import numpy as np
>>> np.ones(5)		# it creates a 1-D array with 5 ones
array([1., 1., 1., 1., 1.])
>>> np.ones(5, dtype='int8')	# it creates a 1-D array with 5 ones, and its data type is int8
array([1, 1, 1, 1, 1], dtype=int8)
>>> np.ones((4, 3)) # it creates an array of (4, 3) shape
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

np.ones_like

Semblable à np.zeros_like, np.ones_like pourrait être utilisé pour créer un nouveau tableau de uns avec la même forme que le tableau donné.

>>> test = np.array([[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]])
>>> np.ones_like(test)
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

Tableau en diagonale

Le tableau diagonal est le tableau 2-D avec des uns sur la diagonale et des zéros ailleurs. Il peut être créé avec la méthode np.eye() dont la syntaxe est

np.eye(N, M=None, k=0, dtype= < class 'float' >, order='C')

Où,

np.eye() Exemple

>>> import numpy as np
>>> np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> np.eye(4, 3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.]])
>>> np.eye(3, 4)
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.]])
>>> np.eye(4, k=1)
array([[0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.],
       [0., 0., 0., 0.]])

np.identity()

Le fichier np.identity peut être traité comme un fichier spécial np.eye car il crée un tableau de diagonales carrées avec des diagonales principales.

numpy.identity(n, dtype = float)

np.identity() Exemples

>>> import numpy as np
>>> np.identity(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

Réseau triangulaire

Vous pouvez utiliser np.tri() pour créer un tableau triangulaire. Sa syntaxe est la suivante,

numpy.tri(N, M=None, k=0, dtype= < class 'float' >)

Ses paramètres d’entrée sont similaires à ceux de np.eye().

np.tri() Exemples

>>> import numpy as np
>>> np.tri(3)
array([[1., 0., 0.],
       [1., 1., 0.],
       [1., 1., 1.]])
>>> np.tri(4, k=1)
array([[1., 1., 0., 0.],
       [1., 1., 1., 0.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])