Comment créer des tableaux de nombres régulièrement espacés

Ce guide vous expliquera comment employer la fonction linspace() de la bibliothèque NumPy afin de générer des tableaux de nombres uniformément distribués en Python.

Nous aborderons la syntaxe de linspace(), puis nous examinerons des cas concrets pour illustrer son utilisation.

Note : Pour tirer profit de ce tutoriel, vous devez avoir Python et NumPy installés.

Si vous n'avez pas encore NumPy, nous avons élaboré un guide d'installation rapide à votre intention.

C'est parti !

Installation et importation de NumPy

Avant de nous lancer dans ce tutoriel, passons en revue les étapes nécessaires pour installer la bibliothèque NumPy.

⏩ Si vous avez déjà installé NumPy, n'hésitez pas à passer à la section suivante.

• Si vous utilisez Google Colab, un environnement de notebooks Jupyter basé sur le cloud, vous pouvez importer NumPy et commencer à coder sans délai (option recommandée pour ce tutoriel ✅).
• Si vous préférez configurer un environnement de travail local, nous vous conseillons d'installer la distribution Anaconda de Python. Elle intègre de nombreux packages utiles préinstallés. Vous pouvez télécharger l'installateur adapté à votre système d'exploitation. L'installation est très rapide. ⌛
• Si Python est déjà installé sur votre machine, vous pouvez également installer Anaconda. Vous pouvez utiliser conda ou pip pour gérer les packages. Voici les commandes que vous pouvez exécuter depuis l'invite de commande Anaconda pour installer NumPy :

# Installation de NumPy avec conda
conda install numpy

# Installation de NumPy avec pip
pip install numpy

Ensuite, importez NumPy en utilisant l'alias np. Cela vous permettra de faire référence à NumPy via np, plutôt que de devoir écrire numpy à chaque fois que vous accédez à une fonction du module.

import numpy as np

Dans ce qui suit, nous utiliserons la notation pointée (np.nom_de_la_fonction) pour accéder aux fonctions de la bibliothèque NumPy.

L'intérêt des nombres uniformément espacés

Lors de la manipulation de tableaux NumPy, il est fréquemment nécessaire de générer un tableau de nombres répartis de manière uniforme dans un intervalle donné.

Avant de poursuivre, examinons brièvement la fonction np.arange(), qui sert un objectif similaire.

Comparaison de NumPy linspace() et arange()

Si vous avez déjà utilisé NumPy, vous avez probablement eu recours à np.arange() pour générer des séquences de nombres dans un intervalle défini.

Vous savez que np.arange(début, fin, pas) renvoie un tableau de nombres allant de début (inclus) jusqu'à fin (exclue), avec un incrément de pas. La valeur par défaut du pas est 1.

Cependant, la valeur du pas n'est pas toujours intuitive. Voyons pourquoi.

Par exemple, si vous avez besoin de 4 nombres répartis uniformément entre 0 et 1, il est clair que le pas doit être de 0,25. Or, si vous utilisez np.arange(), la valeur de fin, 1, ne sera pas incluse. Il faut donc spécifier une valeur de fin qui dépasse l'intervalle souhaité.

L'image ci-dessous illustre quelques cas où vous auriez besoin d'un nombre précis de points répartis uniformément dans un intervalle [a, b].

Points équidistants dans un intervalle

Notre premier exemple avec 4 points répartis dans l'intervalle [0, 1] était relativement simple. Le pas entre les points est de 0,25.

Considérons un exemple un peu plus complexe, où il faudrait 7 points uniformément espacés entre 1 et 33. Le pas n'est pas évident de prime abord, mais il est possible de le déterminer manuellement.

Heureusement, np.linspace() est là pour vous faciliter la tâche ! 😄

Utilisation de linspace de NumPy

Avec np.linspace(), il suffit de définir le nombre de points souhaité dans l'intervalle, sans se préoccuper du pas. Le tableau résultat est conforme à vos attentes.

Après cette introduction, découvrons la syntaxe de linspace() dans la section suivante.

Syntaxe de NumPy linspace()

La syntaxe de la fonction linspace() de NumPy est la suivante :

np.linspace(début, fin, nombre, endpoint, retstep, dtype, axis)

De prime abord, cette syntaxe peut paraître compliquée avec ses nombreux paramètres.

Cependant, la plupart de ces paramètres sont optionnels, et nous allons voir qu'une syntaxe bien plus simple est possible.

Analysons donc cette syntaxe :

• début et fin sont respectivement les points de début et de fin de l'intervalle. début et fin peuvent être des scalaires ou des tableaux. Nous nous limiterons aux valeurs scalaires pour ce tutoriel.
• nombre correspond au nombre de points répartis uniformément dans l'intervalle. Ce paramètre optionnel a une valeur par défaut de 50.
• endpoint est également optionnel, prenant une valeur booléenne (True ou False).
• Sa valeur par défaut est True, ce qui signifie que la valeur de fin est incluse dans l'intervalle. Si vous le définissez sur False, la valeur de fin sera exclue.
• retstep est un autre paramètre optionnel (True ou False). Lorsque sa valeur est True, la fonction retourne également le pas entre les nombres.
• dtype définit le type de données des nombres dans le tableau. Le type est habituellement inféré comme étant un nombre flottant et il n'est généralement pas nécessaire de le spécifier explicitement.
• axis est un paramètre optionnel indiquant l'axe selon lequel les nombres doivent être stockés. Ce paramètre ne prend son sens que si les valeurs début et fin sont elles-mêmes des tableaux.

▶️ Que retourne np.linspace() ?

Elle retourne un tableau de N dimensions contenant des nombres uniformément répartis. Si le paramètre retstep est défini sur True, la fonction retourne également la valeur du pas.

En résumé, voici une version simplifiée de la syntaxe de np.linspace() :

np.linspace(début, fin, nombre)

La ligne de code ci-dessus renvoie un tableau de nombre nombres répartis uniformément entre début et fin (inclus).

Maintenant que la syntaxe est claire, passons à quelques exemples.

Comment créer des tableaux uniformément espacés avec NumPy linspace()

#1. Commençons par créer un tableau de 20 nombres répartis uniformément entre 1 et 5.

Vous pouvez spécifier les valeurs de début, fin et nombre en utilisant des arguments nommés (mots-clés). Ceci est illustré dans le bloc de code ci-dessous :

import numpy as np
arr1 = np.linspace(start = 1,stop = 5,num = 20)
print(arr1)

# Résultat :
[1.         1.21052632 1.42105263 1.63157895 1.84210526 2.05263158
 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947
 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737
 4.78947368 5.        ]

On constate que les nombres du tableau commencent à 1 et se terminent à 5, les deux extrémités étant incluses. Notez également que les nombres, y compris 1 et 5, sont représentés sous forme de nombres flottants dans le tableau renvoyé.

#2. Dans l'exemple précédent, nous avons passé les valeurs de début, fin et nombre en tant qu'arguments nommés. Si vous respectez l'ordre des arguments, vous pouvez également les utiliser comme des arguments positionnels (en ne donnant que les valeurs), comme dans l'exemple ci-dessous.

import numpy as np
arr2 = np.linspace(1,5,20)
print(arr2)

# Résultat :
[1.         1.21052632 1.42105263 1.63157895 1.84210526 2.05263158
 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947
 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737
 4.78947368 5.        ]

#3. Créons maintenant un autre tableau où nous définissons retstep sur True.

Cela signifie que la fonction va retourner à la fois le tableau et la valeur du pas. Nous pouvons donc les décomposer en deux variables : arr3 (le tableau) et step_size (la valeur du pas).

Le bloc de code suivant illustre cela.

import numpy as np
arr3, step_size = np.linspace(1,5,20,retstep = True)
print(arr3)

# Résultat :
[1.         1.21052632 1.42105263 1.63157895 1.84210526 2.05263158
 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947
 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737
 4.78947368 5.        ]

# Résultat :
print(step_size)
0.21052631578947367

#4. Pour finir, définissons endpoint sur False et examinons le résultat.

import numpy as np
arr4 = np.linspace(1,5,20,endpoint = False)
print(arr4)

# Résultat :
[1.  1.2 1.4 1.6 1.8 2.  2.2 2.4 2.6 2.8 3.  3.2 3.4 3.6 3.8 
4.  4.2 4.4 4.6 4.8]

Dans le tableau retourné, 1 est bien inclus, tandis que 5 est exclu. La dernière valeur est 4.8, et nous avons toujours 20 nombres au total.

Jusqu'à présent, nous n'avons généré que des tableaux de nombres uniformément espacés. Dans la section suivante, visualisons ces données en traçant des graphiques.

Comment tracer des nombres uniformément espacés dans un intervalle

Dans cette section, prenons l'intervalle [10, 15]. Nous allons utiliser np.linspace() pour générer deux tableaux, un avec 8 points et l'autre avec 12 points.

Ensuite, nous allons utiliser les fonctions de tracé de la bibliothèque matplotlib pour afficher ces données.

Afin de mieux visualiser les données, nous allons décaler les deux tableaux, N1 = 8 et N2 = 12 points uniformément espacés, sur l'axe des ordonnées.

Le bloc de code suivant illustre cette démarche.

import numpy as np
import matplotlib.pyplot as plt

N1 = 8
N2 = 12

a = 10
b = 15

y1 = np.zeros(N1)
y2 = np.zeros(N2)

x1 = np.linspace(a, b, N1)
x2 = np.linspace(a, b, N2)

plt.plot(x1, y1-0.5, 'o')
plt.plot(x2, y2 + 0.5, 'o')

plt.ylim([-1, 1])

plt.title(f'Nombres uniformément espacés dans l\'intervalle [{a},{b}]')
plt.xlabel('Intervalle')

plt.show()

La génération de points uniformément espacés peut s'avérer très utile lors de la manipulation de fonctions mathématiques. Nous allons en savoir plus dans la section suivante.

Comment utiliser NumPy linspace() avec des fonctions mathématiques

Après avoir généré un tableau de nombres répartis uniformément à l'aide de np.linspace(), vous pouvez calculer les valeurs de fonctions mathématiques sur cet intervalle.

Dans le bloc de code ci-dessous, nous allons commencer par générer 50 points répartis uniformément entre 0 et 2π. Puis, nous allons créer un tableau y en utilisant np.sin() sur le tableau x. Notez que vous pouvez omettre le paramètre nombre, sa valeur par défaut étant 50. Nous allons néanmoins l'utiliser de façon explicite ici.

Ensuite, nous allons tracer la fonction sinus dans l'intervalle [0, 2π]. Pour cela, nous allons utiliser matplotlib, comme dans l'exemple précédent. Plus précisément, la fonction plot() de matplotlib.pyplot permet de créer un tracé linéaire.

import numpy as np
import matplotlib.pyplot as plt

N = 50

a = 0.0
b = 2*np.pi

x = np.linspace(a, b, N)
y = np.sin(x)

plt.plot(x, y, marker = "o")

plt.ylim([-1, 1])
plt.title(f'y = sin(x)')
plt.xlabel('x ---->')

plt.show()

Maintenant, exécutons le code précédent en fixant N à 10. Vous obtiendrez le tracé illustré dans la figure ci-dessous.

On remarque que le tracé n'est pas très lisse, car nous n'avons considéré que 10 points dans l'intervalle.

En général, plus le nombre de points considérés est élevé, plus le tracé de la fonction sera fluide.

Conclusion

Voici un résumé des points clés que nous avons abordés :

• np.linspace(début, fin, nombre) retourne un tableau de nombre nombres uniformément espacés dans l'intervalle [début, fin].
• Définissez la valeur du paramètre optionnel endpoint sur False pour exclure la valeur de fin, ce qui donne l'intervalle [début, fin).
• Définissez éventuellement retstep sur True pour obtenir la valeur du pas.
• Générez des tableaux de points uniformément espacés à l'aide de np.linspace(), puis utilisez ces tableaux avec des fonctions mathématiques.

Nous espérons que vous comprenez désormais le fonctionnement de np.linspace(). Vous pouvez exécuter les exemples précédents dans un notebook Jupyter. N'hésitez pas à consulter notre guide sur les notebooks Jupyter ou les alternatives Jupyter.

À bientôt pour un prochain tutoriel Python. D'ici là, continuez à coder ! 😀