NumPy linspace() : Comment créer des tableaux de nombres régulièrement espacés

Ce tutoriel vous apprendra à utiliser NumPy linspace() pour créer un tableau de nombres régulièrement espacés en Python.

Vous apprendrez la syntaxe de NumPy linspace()suivie d'exemples qui vous aideront à comprendre comment l'utiliser.

Remarque : Pour suivre ce tutoriel, vous devez avoir installé Python et NumPy.

Vous n'avez pas encore NumPy ? Nous avons élaboré un guide d'installation rapide pour vous.

C'est parti !

Installation et importation de NumPy

Avant de commencer le tutoriel, passons rapidement en revue les étapes de l'installation de la bibliothèque NumPy.

⏩ Si NumPy est déjà installé, vous pouvez passer à la section suivante.

• Si vous utilisez Google Colab-une solution basée sur l'informatique dématérialisée Bloc-notes Jupyter vous pouvez importer NumPy et commencer à coder immédiatement. (recommandé pour ce tutoriel ✅)
• Si vous souhaitez mettre en place un environnement de travail local, je vous recommande d'installer la distribution Anaconda de Python. Anaconda est livré avec plusieurs paquets utiles préinstallés. Vous pouvez télécharger le programme d'installation correspondant à votre système d'exploitation. Le processus d'installation ne prend que quelques minutes.
• Si Python est déjà installé sur votre ordinateur, vous pouvez toujours installer la distribution Anaconda. Vous pouvez utiliser conda ou pip pour installer et gérer les paquets. Vous pouvez exécuter l'une des commandes suivantes à partir de l'invite de commande Anaconda pour installer NumPy.

# Install NumPy using conda
conda install numpy

# Install NumPy using pip
pip install numpy

L'étape suivante consiste à importer numpy sous l'alias np en exécutant la commande suivante. Cela vous aidera à référencer NumPy en tant que np-sans avoir à taper sur le clavier numpy chaque fois que vous accédez à un élément du module.

import numpy as np

Par la suite, nous utiliserons la notation point pour accéder à toutes les fonctions de la bibliothèque NumPy comme suit : np.<func-name>.

Arguments en faveur de l'espacement régulier des nombres

Lorsque vous travaillez avec Tableaux NumPyil arrive que vous ayez besoin de créer un tableau de nombres régulièrement espacés dans un intervalle.

Avant d'aller plus loin, passons rapidement en revue une autre fonction similaire np.arange().

NumPy linspace() vs NumPy arange()

Si vous avez déjà utilisé NumPy, vous avez probablement utilisé np.arange() pour créer un tableau de nombres dans un intervalle spécifié.

Vous savez que np.arange(start, stop, step) renvoie un tableau de nombres de start jusqu'à, mais sans inclure stoppar étapes de stepla taille de pas par défaut étant de 1.

Toutefois, la valeur de step n'est pas toujours évidente. Voyons pourquoi.

Par exemple, si vous avez besoin de 4 nombres régulièrement espacés entre 0 et 1, vous savez que la taille du pas doit être de 0,25. Mais si vous utilisez np.arange()Vous devrez donc choisir un intervalle qui va au-delà de la valeur d'arrêt.

L'image suivante illustre quelques autres exemples dans lesquels vous avez besoin d'un nombre spécifique de points régulièrement espacés dans l'intervalle [a, b].

Notre premier exemple de 4 points régulièrement espacés dans [0,1] était assez facile. Vous savez que le pas entre les points doit être de 0,25.

Supposons que vous ayez un exemple un peu plus complexe, dans lequel vous devez énumérer 7 points régulièrement espacés entre 1 et 33. Dans ce cas, la taille du pas n'est peut-être pas très claire immédiatement. Vous pouvez cependant calculer manuellement la valeur de step dans ce cas.

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

Lors de l'utilisation de np.linspace()il suffit de spécifier le nombre de points dans l'intervalle, sans se préoccuper de la taille du pas. Vous obtiendrez alors le tableau souhaité.

Avec cette motivation, apprenons la syntaxe de NumPy linspace() dans la section suivante.

Syntaxe de NumPy linspace()

La syntaxe d'utilisation de NumPy linspace() est indiqué ci-dessous :

np.linspace(start, stop, num, endpoint, retstep, dtype, axis)

Au départ, la syntaxe ci-dessus peut sembler très compliquée, avec de nombreux paramètres.

Cependant, la plupart d'entre eux sont facultatif et nous arriverons à une syntaxe beaucoup plus simple dans quelques minutes.

Commençons par analyser la syntaxe ci-dessus :

• start et stop sont respectivement les points de départ et d'arrivée de l'intervalle. Start et Stop peuvent être des scalaires ou des tableaux. Dans ce tutoriel, nous nous limiterons aux valeurs scalaires de début et de fin.
• num est le nombre de points régulièrement espacés. Il s'agit d'un paramètre facultatif dont la valeur par défaut est 50.
• endpoint est également un paramètre facultatif qui peut être True ou False.
• La valeur par défaut est True, ce qui signifie que le point final sera inclus dans l'intervalle par défaut. Toutefois, vous pouvez lui attribuer la valeur False pour exclure le point final.
• retstep est un autre paramètre facultatif qui prend la valeur booléenne True ou False. S'il vaut True, la valeur de l'étape est renvoyée.
• dtype est le type de données des nombres du tableau. Le type est généralement déduit comme étant float et n'a pas besoin d'être fourni explicitement.
• axis est un autre paramètre facultatif indiquant l'axe le long duquel les nombres doivent être stockés. Ce paramètre n'est pertinent que lorsque l'option start et le stop sont elles-mêmes des tableaux.

▶️ Qu'est-ce que np.linspace() retour ?

Il renvoie un tableau à N dimensions de nombres régulièrement espacés. Et si le paramètre retstep est fixé à Trueil renvoie également la taille du pas.

Sur la base des discussions menées jusqu'à présent, voici une syntaxe simplifiée à utiliser np.linspace():

np.linspace(start, stop, num)

La ligne de code ci-dessus renverra un tableau de num des nombres régulièrement espacés dans l'intervalle [start, stop].

Maintenant que vous connaissez la syntaxe, commençons à coder des exemples.

Comment créer des tableaux régulièrement espacés avec NumPy linspace()

#1. Pour notre premier exemple, créons un tableau de 20 nombres régulièrement espacés dans l'intervalle [1, 5].

Vous pouvez spécifier les valeurs de start, stopet num comme arguments de mot-clé. C'est ce que montre la cellule de code ci-dessous :

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

# Output:
[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.        ]

Remarquez que les nombres du tableau commencent à 1 et se terminent à 5, y compris les deux extrémités. Observez également que les nombres, y compris les points 1 et 5, sont représentés comme suit float dans le tableau retourné.

#2. Dans l'exemple précédent, vous avez transmis les valeurs de start, stopet num comme Arguments des mots-clés. Si vous passez les arguments dans le bon ordre, vous pouvez tout aussi bien les utiliser en tant que arguments de position avec seulement les valeurs, comme indiqué ci-dessous.

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

# Output:
[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 dans lequel nous mettrons retstep à True.

Cela signifie que la fonction renverra à la fois le tableau et l'étape. Et nous pouvons les décompresser en deux variables arr3: le tableau, et step_size: la taille du pas renvoyée.

La cellule de code suivante explique comment procéder.

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

# Output:
[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.        ]

# Output:
print(step_size)
0.21052631578947367

#4. En guise de dernier exemple, définissons endpoint à Falseet vérifiez ce qui se passe.

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

# Output:
[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é, vous pouvez voir que 1 est inclus, alors que 5 ne l'est pas. La dernière valeur du tableau est 4,8, mais nous avons toujours 20 nombres.

Jusqu'à présent, nous n'avons généré que des tableaux de nombres régulièrement espacés. Dans la section suivante, nous allons visualiser ces nombres en les traçant.

Comment tracer des nombres régulièrement espacés dans un intervalle ?

Dans cette section, choisissons [10,15] comme intervalle d'intérêt. Puis, utilisons np.linspace() pour générer deux tableaux, chacun avec 8 et 12 points, respectivement.

Une fois cette étape terminée, nous pouvons utiliser la fonction de traçage de l'application matplotlib pour les tracer.

Pour plus de clarté, nous regrouperons les deux tableaux de N1 = 8 et N2 = 12 des points régulièrement espacés à différentes positions le long de l'axe y.

L'extrait de code suivant le démontre.

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'Evenly Spaced Numbers in the Interval [{a},{b}]')
plt.xlabel('Interval')

plt.show()

La génération de points régulièrement espacés peut s'avérer utile lorsque l'on travaille avec des fonctions mathématiques. Nous verrons cela dans la section suivante.

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

Après avoir généré un tableau de nombres régulièrement espacés à l'aide de la fonction np.linspace()vous pouvez calculer les valeurs des fonctions mathématiques dans l'intervalle.

Dans la cellule de code ci-dessous, vous générez d'abord 50 points régulièrement espacés dans l'intervalle 0 à 2π. Vous créez ensuite le tableau y en utilisant np.sin() sur le tableau x. Notez que vous pouvez sauter l'étape num car la valeur par défaut est 50. Nous l'utiliserons quand même explicitement.

L'étape suivante consiste à tracer la fonction sinus dans l'intervalle [0, 2π]. Pour ce faire, vous pouvez utiliser matplotlibcomme dans l'exemple précédent. Plus précisément, le plot() fonction dans matplotlib.pytplot est utilisé pour 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()

Exécutez maintenant le code ci-dessus en définissant N égale à 10. Vous obtiendrez le graphique illustré dans la figure ci-dessous.

Vous pouvez constater que le graphique n'est pas très lisse, car vous n'avez choisi que 10 points dans l'intervalle.

En général, plus le nombre de points pris en compte est important, plus le tracé de la fonction sera lisse.

Conclusion

Voici un résumé de ce que nous avons appris.

• np.linspace(start, stop, num) renvoie un tableau de num des nombres régulièrement espacés dans l'intervalle [start, stop].
• Définir le paramètre optionnel endpoint à False d'exclure stopet fixer l'intervalle à (début, fin).
• Fixer retstep à True optionnellement pour obtenir la taille du pas.
• Générer des tableaux régulièrement espacés à l'aide de np.linspace()puis d'utiliser le tableau avec des fonctions mathématiques.

J'espère que vous comprenez maintenant comment np.linspace() travaux. Vous pouvez choisir d'exécuter les exemples ci-dessus dans le carnet Jupyter. Consultez notre guide sur Bloc-notes Jupyterou d'autres Alternatives à Jupyter que vous pouvez envisager.

A très bientôt dans un autre tutoriel Python. D'ici là, continuez à coder!😀