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 didacticiel, vous devez avoir installé Python et NumPy.
Vous n’avez pas encore NumPy ? Nous avons préparé pour vous un guide d’installation rapide.
Commençons!
Table des matières
Installer et importer NumPy
Avant de commencer le didacticiel, parcourons rapidement les étapes d’installation de 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 bloc-notes Jupyter basé sur le cloud, vous pouvez importer NumPy et commencer à coder immédiatement. (recommandé pour ce tutoriel ✅)
- Si vous souhaitez configurer un environnement de travail local, je vous recommande d’installer la distribution Anaconda de Python. Anaconda est livré avec plusieurs packages utiles préinstallés. Vous pouvez télécharger le programme d’installation pour 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 packages. 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
Dans une prochaine étape, importez 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 numpy chaque fois que vous accédez à un élément du module.
import numpy as np
À l’avenir, nous utiliserons la notation par points pour accéder à toutes les fonctions de la bibliothèque NumPy comme ceci : np.
Le cas des nombres régulièrement espacés
Lorsque vous travaillez avec des tableaux NumPy, vous devrez parfois 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() contre NumPy arange()
Si vous avez déjà utilisé NumPy, vous auriez probablement utilisé np.arange() pour créer un tableau de nombres dans une plage spécifiée.
Vous savez que np.arange(start, stop, step) renvoie un tableau de nombres du début jusqu’à l’arrêt non compris, par pas de step ; la taille de pas par défaut étant 1.
Cependant, la valeur de l’étape n’est pas toujours évidente. Voyons pourquoi c’est le cas.
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(), il n’inclut pas la valeur d’arrêt de 1. Vous devrez donc choisir un intervalle qui dépasse la valeur d’arrêt.
L’image suivante illustre quelques exemples supplémentaires où vous avez besoin d’un nombre spécifique de points régulièrement espacés dans l’intervalle [a, b].
Points régulièrement espacés dans un intervalle
Notre premier exemple de 4 points régulièrement espacés dans [0,1] était assez facile. Vous savez que la taille du pas entre les points doit être de 0,25.
Supposons que vous ayez un exemple un peu plus compliqué, où vous deviez lister 7 points régulièrement espacés entre 1 et 33. Ici, la taille du pas peut ne pas être très claire immédiatement. Vous pouvez cependant déterminer manuellement la valeur de step dans ce cas.
Cependant, np.linspace() est là pour vous simplifier la tâche ! 😄
Utiliser l’espace lin NumPy
Lorsque vous utilisez np.linspace(), il vous suffit de spécifier le nombre de points dans l’intervalle, sans vous soucier de la taille du pas. Et vous récupérerez le tableau comme vous le souhaitez.
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 illustrée 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 des paramètres facultatifs et nous arriverons à une syntaxe beaucoup plus simple en quelques minutes seulement.
Commençons maintenant par analyser la syntaxe ci-dessus :
- start et stop sont respectivement les points de début et de fin de l’intervalle. Le démarrage et l’arrêt peuvent être des scalaires ou des tableaux. Nous nous limiterons aux valeurs scalaires de début et de fin dans ce didacticiel.
- num est le nombre de points régulièrement espacés. Et c’est un paramètre facultatif avec une valeur par défaut de 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. Cependant, vous pouvez le définir sur False pour exclure le point final.
- retstep est encore un autre paramètre facultatif qui prend les booléens Vrai ou Faux. Lorsqu’il est défini sur True, la valeur du pas est renvoyée.
- dtype est le type de données des nombres dans le tableau. Le type est généralement déduit comme flottant 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. Et cela n’est pertinent que lorsque les valeurs de début et de fin sont elles-mêmes des tableaux.
▶️ Alors, que renvoie np.linspace() ?
Il renvoie un tableau à N dimensions de nombres régulièrement espacés. Et si le paramètre retstep est défini sur True, il renvoie également la taille du pas.
Sur la base de la discussion jusqu’à présent, voici une syntaxe simplifiée pour utiliser np.linspace() :
np.linspace(start, stop, num)
La ligne de code ci-dessus renverra un tableau de num 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. Comme 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, stop et num comme arguments de mot-clé. Ceci est indiqué dans 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 comment les nombres du tableau commencent à 1 et se terminent à 5, y compris les deux extrémités. Observez également comment les nombres, y compris les points 1 et 5, sont représentés sous forme flottante dans le tableau renvoyé.
#2. Dans l’exemple précédent, vous aviez transmis les valeurs de start, stop et num en tant qu’arguments de mots clés. Si vous transmettez les arguments dans le bon ordre, vous pouvez aussi bien les utiliser comme arguments positionnels avec uniquement 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 où nous définissons retstep sur True.
Cela signifie que la fonction renverra maintenant à la fois le tableau et l’étape. Et nous pouvons les décompresser en deux variables arr3 : le tableau et step_size : la taille de pas renvoyée.
La cellule de code suivante explique comment vous pouvez le faire.
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. Comme dernier exemple, définissons endpoint sur False et vérifions 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 renvoyé, vous pouvez voir que 1 est inclus, alors que 5 n’est pas inclus. Et la dernière valeur du tableau se trouve être 4,8, mais nous avons encore 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, visualisons en traçant ces nombres.
Comment tracer des nombres régulièrement espacés dans un intervalle
Dans cette section, choisissons [10,15] comme intervalle d’intérêt. Et ensuite, utilisez np.linspace() pour générer deux tableaux, chacun avec 8 et 12 points, respectivement.
Une fois cette opération terminée, nous pouvons utiliser la fonction de traçage de la bibliothèque matplotlib pour les tracer.
Pour plus de clarté, nous allons serrer les deux tableaux de N1 = 8 et N2 = 12 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 être utile lorsque vous travaillez avec des fonctions mathématiques. Nous en apprendrons davantage dans la section suivante.
Comment utiliser NumPy linspace() avec des fonctions mathématiques
Après avoir généré un tableau de nombres régulièrement espacés à l’aide de 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 de 0 à 2π. Et puis créez le tableau y en utilisant np.sin() sur le tableau x. Notez que vous pouvez ignorer le paramètre num, car la valeur par défaut est 50. Nous l’utiliserons toujours explicitement.
Dans une prochaine étape, vous pouvez tracer la fonction sinus dans l’intervalle [0, 2π]. Pour ce faire, vous pouvez utiliser matplotlib, comme dans l’exemple précédent. Plus précisément, la fonction plot() dans matplotlib.pytplot est utilisée 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()
Maintenant, exécutez le code ci-dessus en définissant N égal à 10. Vous obtiendrez le tracé comme indiqué dans la figure ci-dessous.
Et vous pouvez voir que le tracé n’est pas très fluide, car vous n’avez sélectionné que 10 points dans l’intervalle.
En général, plus le nombre de points que vous considérez est grand, 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 nombres régulièrement espacés dans l’intervalle [start, stop].
- Définissez le point de terminaison du paramètre facultatif sur False pour exclure l’arrêt et définissez l’intervalle sur[startstop)[startstop)
- Définissez éventuellement retstep sur True pour obtenir la taille du pas.
- Générez des tableaux régulièrement espacés à l’aide de np.linspace(), puis utilisez le tableau avec des fonctions mathématiques.
J’espère que vous comprenez maintenant comment fonctionne np.linspace(). Vous pouvez choisir d’exécuter les exemples ci-dessus dans le bloc-notes Jupyter. Consultez notre guide sur le bloc-notes Jupyter ou d’autres alternatives Jupyter que vous pouvez envisager.
A bientôt dans un autre tutoriel Python. Jusque-là, continuez à coder ! 😀