Création de tableaux à l’aide des fonctions NumPy

Jusqu’à présent, nous avons créé des tableaux par nous-mêmes. Mais il existe quelques fonctions dans NumPy qui nous permettent de créer des tableaux à partir de rien.

Il se peut que tu ne comprennes pas l’utilisation de ces fonctions maintenant, mais au fur et à mesure que tu avanceras dans ton apprentissage, tout commencera à avoir un sens pour toi.

En tant que débutant, garde l’esprit ouvert et apprends les bases. Avec le temps, tu verras comment ces concepts s’imbriquent les uns dans les autres.

Tu trouveras ci-dessous la liste des fonctions que nous allons apprendre dans ce chapitre :

• zeros()
• ones()
• full()
• arange()
• linspace()
• random()
• randint()
• eyes()

Construisons des tableaux NumPy en utilisant ces fonctions une par une.

zeros

z = np.zeros((3, 4), dtype=int)
z

"""array([[0, 0, 0, 0],
          [0, 0, 0, 0],
          [0, 0, 0, 0]]) 
"""

Dans le code ci-dessus, (3, 4) est équivalent à (ligne, colonne).

De même, nous pouvons créer un tableau 3D avec (profondeur, lignes, colonnes) comme dans le code ci-dessous.

z = np.zeros((2, 5, 3), dtype=int)
z

"""array([[[0, 0, 0],
           [0, 0, 0],
           [0, 0, 0],
           [0, 0, 0],
           [0, 0, 0]],

          [[0, 0, 0],
           [0, 0, 0],
           [0, 0, 0],
           [0, 0, 0],
           [0, 0, 0]]]) 
"""

Tu sais maintenant comment créer des tableaux remplis de zéros dans différentes dimensions.

Voyons maintenant comment créer des tableaux remplis de un

ones

o = np.ones((4, 5), dtype=int)
o

"""array([[1, 1, 1, 1, 1],
          [1, 1, 1, 1, 1],
          [1, 1, 1, 1, 1],
          [1, 1, 1, 1, 1]]) 

"""

Maintenant, il n’y a plus que des 0 et des 1. Nous pouvons remplir un tableau avec n’importe quel nombre en utilisant la méthode full().

full

f = np.full((2, 4), 9)
f

"""array([[9, 9, 9, 9],
          [9, 9, 9, 9]]) 
"""

arange

C’est l’une des fonctions intégrées les plus utilisées par rapport aux autres fonctions intégrées de NumPy.

a = np.arange(2, 21, 2)
a

# array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20])

Les valeurs des paramètres (2, 21, 2) signifient (start, stop, step), ce qui signifie qu’il commence à 2 et se termine à 21, et qu’il saute la deuxième valeur après chaque valeur.

Par exemple, pour 2, il saute à 4, à partir de 4, il saute à 6, et ainsi de suite.

Nous utiliserons beaucoup cette fonction tout au long de ce cours, alors utilise-la et essaye de créer des tableaux différents.

linspace

l = np.linspace(1, 2, 10)
l

""" array([1.        , 1.11111111, 1.22222222, 1.33333333, 1.44444444,
           1.55555556, 1.66666667, 1.77777778, 1.88888889, 2.        ]) 
"""

La fonction linspace() trouve un nombre spécifié de valeurs entre deux nombres donnés.

Dans le code ci-dessus, les deux premières valeurs des paramètres (1 et 2) sont les deux nombres donnés. La fonction linspace() trouvera 10 valeurs d’équidistance l’une par rapport à l’autre.

Pour comprendre cela facilement, voir le code ci-dessous.

l = np.linspace(2, 20, 10)
l

# array([ 2.,  4.,  6.,  8., 10., 12., 14., 16., 18., 20.])

Le résultat est constitué de 10 valeurs comprises entre 2 et 20, chaque valeur étant équidistante de l’autre.

random

La bibliothèque NumPy contient un module appelé random. Et à l’intérieur de ce module random, nous avons une méthode nommée random. C’est pourquoi nous avons np.random.random() dans le code ci-dessous.

La méthode random() nous donne un nombre aléatoire entre 0 et 1.

Nous pouvons seulement spécifier la forme. Dans le code ci-dessous, j’ai spécifié la forme/shape (5, 4).

rr = np.random.random((5, 4)) # Gives random numbers between 0 and 1
rr

""" array([[0.63633551, 0.08796748, 0.81917062, 0.12715859],
           [0.6638637 , 0.89355948, 0.14505798, 0.49973856],
           [0.47773628, 0.33628658, 0.0651107 , 0.53675706],
           [0.63973589, 0.28866727, 0.10723666, 0.55947122],
           [0.14240055, 0.18737459, 0.17222864, 0.5487357 ]]) 
"""

Si tu souhaites créer un nombre aléatoire de ton choix, tu dois utiliser la méthode randint(). Tu dois utiliser la méthode randint().

randint

ri = np.random.randint(4, 10, (3,9))
ri

""" array([[5, 6, 8, 8, 4, 8, 4, 5, 7],
           [8, 7, 7, 9, 9, 6, 7, 6, 7],
           [6, 8, 4, 4, 9, 9, 6, 5, 8]]) 
"""

Le code ci-dessus crée un tableau avec des éléments de nombres aléatoires entre 4 et 10 de la forme (3, 9).

Chaque fois que tu exécutes la cellule de code ci-dessus dans ton notebook Google Colab, tu obtiendras un ensemble de valeurs différent.

Si tu souhaites obtenir le même ensemble de valeurs à chaque fois que tu exécutes la cellule, tu dois définir une valeur de seed.

Dans le code ci-dessous, j’ai fixé la valeur de départ à 38. Mais la valeur de départ peut être n’importe quoi.

Si tu définis la même valeur de départ que moi, tu obtiendras le même ensemble d’éléments aléatoires que moi. Si tu utilises une valeur de seed différente, tu obtiendras un ensemble différent d’éléments aléatoires.

np.random.seed(38)
ri = np.random.randint(4, 10, (3,9))
ri

""" array([[5, 7, 9, 7, 8, 8, 6, 5, 5],
           [8, 4, 6, 5, 9, 9, 8, 7, 5],
           [6, 9, 9, 9, 5, 4, 6, 7, 7]]) 
"""

Après avoir défini la valeur de départ à l’aide de la méthode seed(), la sortie ne change pas à chaque fois que j’exécute la cellule.

Essaye toi-même.

(J’espère que tu es en train de coder).

eye

Enfin, la méthode eye() génère une matrice qui contiendra des 1 en diagonale, voir le code ci-dessous :

e = np.eye(5, dtype=int)
e

""" array([[1, 0, 0, 0, 0],
           [0, 1, 0, 0, 0],
           [0, 0, 1, 0, 0],
           [0, 0, 0, 1, 0],
           [0, 0, 0, 0, 1]]) 
"""

Tu connaîtras l’utilité de cette fonction lorsque tu commenceras à te familiariser avec la vision par ordinateur (CNN, filtres, etc.).

Pour l’instant, concentre-toi sur la maîtrise des bases.

Exercice : Essaye toutes les fonctions par toi-même avec différents ensembles de paramètres.

Nous sommes prêts à passer au chapitre suivant.

Chapitre suivant 👉 Indexation de tableaux NumPy.