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)
Attention

Le tableau créé par np.zeros_like() a non seulement la même forme avec le tableau donné mais aussi le même type de données que lui.

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ù,

paramètre type de données Résumé
N INT Spécifie le nombre de lignes dans la matrice générée.
M INT (Facultatif) La valeur par défaut est None. Spécifie le nombre de colonnes dans la matrice à générer. Quand il est None, il est égal à N.
k INT (Optionnel) La valeur par défaut est 0. 0 est la position diagonale principale. Si k est positif, il crée la diagonale supérieure avec le déplacement de k ; si k est négatif, il crée la diagonale inférieure avec le déplacement de -k.
dtype type de données (Facultatif) La valeur par défaut est float. Elle spécifie le type de données de l’élément du tableau créé.

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)
paramètre type de données Description
n INT Spécifie la taille de la matrice à générer. Il crée un tableau carré N×N.
dtype type de données (Facultatif) La valeur par défaut est float. Elle spécifie le type de données de l’élément.

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.]])
comments powered by Disqus