Comment utiliser la fonction NumPy linspace()

NumPy est un package essentiel dans l'écosystème de la science des données de Python, offrant un large éventail de fonctions pour manipuler efficacement les données numériques. Parmi celles-ci, la fonction linspace() est souvent utilisée pour générer des valeurs régulièrement espacées sur un intervalle spécifié, ce qui en fait un outil utile pour les tâches nécessitant des plages numériques précises, telles que la visualisation de données et la modélisation mathématique. Dans ce tutoriel, je vous montrerai les tenants et les aboutissants de la fonction linspace().

La réponse courte : Comment l'utiliser np.linspace()

Si vous êtes pressé, voici l'explication la plus rapide de la fonction linspace(). La fonction linspace() de NumPy génère un tableau de nombres régulièrement espacés sur un intervalle défini. Ici, par exemple, nous créons un tableau qui commence à 0 et se termine à 100, dans un intervalle de 5 nombres. Comme vous pouvez vous en douter, elle renvoie un tableau avec [0, 25, 75, 100].

import numpy as np

# Basic usage of linspace to create an array from 0 to 100 with 5 elements
linspace_example = np.linspace(0, 100.0, 5)
linspace_example # Return example

# Output: array([  0.,  25.,  50.,  75., 100.])

Pourquoi utiliser la fonction linspace() fonction ?

La fonction linspace() est une méthode simple et efficace pour générer des valeurs linéairement espacées, offrant une solution utile pour une variété de scénarios où des plages numériques spécifiques sont nécessaires, comme dans la visualisation de données, les simulations, et même dans le réglage fin des algorithmes. Voici quelques exemples d'utilisation de linspace():

• Tâches de visualisation des données : Par exemple, lors de la création d'un graphique linéaire représentant la trajectoire d'un satellite au fil du temps, linspace() peut être utilisé pour générer les intervalles de temps auxquels les données de position sont échantillonnées, garantissant ainsi une ligne lisse et continue sur le graphique.
• Simulations : En modélisation financière, pour évaluer l'impact de taux d'intérêt variables sur le prix des obligations, linspace() peut produire une gamme de taux d'intérêt allant du plus bas possible au plus élevé anticipé, ce qui permet une analyse complète sur l'ensemble du spectre.
• Recherche scientifique : Pour étudier les effets du réchauffement climatique sur les calottes glaciaires, les chercheurs peuvent utiliser linspace() pour créer une série d'intervalles de temps régulièrement espacés sur plusieurs décennies. À chaque intervalle, ils ont pu simuler l'augmentation moyenne de la température mondiale et son impact sur les taux de fonte des glaces.

NumPy linspace() Syntaxe et utilisation avec exemples

Comme indiqué précédemment, la fonction linspace() crée des valeurs linéairement espacées, ce qui est utile pour divers calculs numériques. Avant de plonger dans les exemples, examinons les différents arguments avec lesquels vous pouvez travailler lorsque vous utilisez linspace().

NumPy linspace() Arguments

• start: La valeur de départ de la séquence.
• stop: La valeur finale de la séquence.
• num (facultatif) : L'intervalle spécifié. La valeur par défaut est 50 et doit être non négative.
• endpoint (facultatif) : Si True (valeur par défaut), stop est le dernier échantillon. Si False, la valeur d'arrêt n'est pas incluse dans la séquence générée par linspace(). Cela signifie que la fonction créera des échantillons régulièrement espacés dans la plage allant du début jusqu'à juste avant l'arrêt, en excluant effectivement la valeur d'arrêt elle-même de la séquence. Cela peut s'avérer utile lorsque vous avez besoin d'une plage qui s'approche du point final sans l'atteindre, ce qui permet un contrôle plus souple de la plage de valeurs générées.
• retstep (facultatif) : Si True, il renvoie (samples, step), où step est l'espacement entre les échantillons.
• dtype (facultatif) : Le type du tableau de sortie. S'il n'est pas indiqué, dtype sera déterminé par les arguments start et stop.
• axis (facultatif) : L'axe dans le résultat pour stocker les échantillons, uniquement lorsque vous travaillez avec des tableaux multidimensionnels.

Création de tableaux à une dimension avec linspace()

Maintenant que nous avons bien compris les arguments disponibles dans linspace(), voyons quelques exemples en action !

Création d'un tableau unidimensionnel régulièrement espacé à l'aide de linspace()

Cet exemple crée un tableau de 7 nombres régulièrement espacés entre 0 et 10.

import numpy as np

# Create an array of 7 evenly spaced elements from 0 to 10
uniform_array = np.linspace(0, 10, num=7)
print("Uniform Array")
uniform_array

Uniform Array
array([ 0., 1.66666667, 3.33333333, 5., 6.66666667,8.33333333, 10.])

Exclusion de l'extrémité d'un tableau unidimensionnel régulièrement espacé à l'aide de linspace()

Dans ce cas, nous générons un tableau de 8 nombres entre 10 et 20, mais nous excluons la valeur finale (20) du tableau, ce qui illustre l'argument endpoint en action.

import numpy as np


# Create an array of 8 elements from 10 to 20, excluding 20
exclude_final_array = np.linspace(10, 20, num=8, endpoint=False)
print("Array Excluding Final Value")
exclude_final_array

Array Excluding Final Value
array([10. , 11.25, 12.5 , 13.75, 15. , 16.25, 17.5 , 18.75])

Inclure la taille du pas dans un tableau unidimensionnel régulièrement espacé en utilisant linspace()

Ici, nous créons un tableau de 4 éléments entre -5 et 5. Nous capturons et affichons également la taille du pas.

import numpy as np


# Create an array of 4 elements from -5 to 5 and capture the step size
step_array, step = np.linspace(-5, 5, num=4, retstep=True)
print("Array with Defined Step Size", step_array)
print("Step Size", step)

Array with Defined Step Size [-5.         -1.66666667  1.66666667  5.        ]
Step Size 3.3333333333333335

Création de tableaux à N dimensions avec linspace()

linspace() est également utile pour générer des tableaux multidimensionnels. Nous vous en présentons ici quelques exemples.

Génération d'un tableau à deux dimensions à l'aide de linspace()

Cet exemple montre comment générer un tableau 2D où chaque ligne passe en douceur du vecteur [0, 10] à [5, 15], créant ainsi un effet de gradient sur 4 étapes.

import numpy as np


# Perform column-wise linear interpolation from [10, 20] to [15, 25] over 3 steps
column_interpolation_array = np.linspace([10, 20], [15, 25], num=3, axis=1)
print("Column-wise Interpolation Array:")
print(column_interpolation_array)

Column-wise Interpolation Array:
[[10.  12.5 15. ]
 [20.  22.5 25. ]]

Alternatives à NumPy linspace()

Bien que linspace() soit très utile, il existe d'autres solutions qui méritent d'être prises en compte, comme la fonction arange() de NumPy et les compréhensions de liste.

Utilisation du logiciel NumPy arange() function

La fonction arange() génère des valeurs dans un intervalle donné. Contrairement à linspace(), l'espacement entre les valeurs est spécifié plutôt que le nombre de valeurs.

# Using arange to generate values from 0 to 10, spaced by 2
arange_example = np.arange(0, 10, 2)
arange_example

# Returns array([0, 2, 4, 6, 8])

# Using linspace() to generate values from 0 to 10, with interval set to 2
linspace_example = np.linspace(0, 10, 2)
linspace_example

# Returns array([0.,10.0])

Utilisation des compréhensions de listes

Les compréhensions de listes fournissent un moyen plus Python de générer des listes, bien qu'elles ne bénéficient pas des avantages de vectorisation et de la flexibilité de NumPy linspace().

list_comp = [x for x in range(10)]
print(list_comp)

# Outputs [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Réflexions finales

La fonction linspace() de NumPy est un outil fondamental dans la boîte à outils de la science des données, offrant précision et flexibilité dans la génération de séquences numériques. Si vous souhaitez renforcer vos compétences en NumPy, consultez ce tutoriel sur les tableaux NumPy, cette fiche d'aide NumPy, ou envisagez de vous inscrire à notre cours d'introduction à NumPy.