NumPy Linspace : Comment créer des tableaux uniformément espacés en Python

Name

Soren Atelier

Updated on 09/02/2026

Générer une séquence de nombres uniformément espacés semble trivial jusqu'à ce que vous ayez besoin d'un contrôle exact sur le début, la fin et le nombre de points. La fonction intégrée range() de Python ne gère que les entiers, et même numpy.arange() peut produire des surprises d'arrondi lorsque les pas en virgule flottante accumulent des erreurs. Si vous avez déjà tracé une fonction et obtenu une courbe irrégulière ou manqué la dernière valeur de x, vous avez rencontré exactement ce problème. numpy.linspace() existe pour le résoudre : vous spécifiez combien de points vous voulez entre deux extrémités, et NumPy calcule l'espacement exact pour vous.

Dans ce guide, vous apprendrez l'API complète de np.linspace(), verrez des comparaisons côte à côte avec np.arange(), et parcourrez des cas d'utilisation réels, du tracé de courbes lisses à la construction de grilles multidimensionnelles. Chaque exemple de code est prêt à copier-coller et affiche sa sortie.

Que fait np.linspace() ?

numpy.linspace() renvoie un tableau de nombres uniformément espacés sur un intervalle spécifié. L'idée clé est que vous définissez le nombre d'échantillons plutôt que la taille du pas.

Signature complète

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

Exemple de base

import numpy as np
 
arr = np.linspace(0, 1, 5)
print(arr)
# Output: [0.   0.25 0.5  0.75 1.  ]

NumPy divise l'intervalle [0, 1] en 4 espaces égaux (un de moins que les 5 points demandés) et renvoie les cinq valeurs limites, y compris les deux extrémités.

Contrôler le nombre de points avec num

Le paramètre num détermine combien de valeurs se trouvent dans le tableau renvoyé. La valeur par défaut est 50, c'est pourquoi appeler np.linspace(0, 10) vous donne 50 valeurs même si vous ne les avez pas demandées explicitement.

import numpy as np
 
# 3 points entre 0 et 10
print(np.linspace(0, 10, num=3))
# Output: [ 0.  5. 10.]
 
# 6 points entre -1 et 1
print(np.linspace(-1, 1, num=6))
# Output: [-1.  -0.6 -0.2  0.2  0.6  1. ]

Une erreur courante est de définir num=1. Dans ce cas, seule la valeur start est renvoyée.

import numpy as np
 
print(np.linspace(0, 10, num=1))
# Output: [0.]

Le paramètre endpoint : Inclure ou exclure la valeur d'arrêt

Par défaut, endpoint=True, ce qui signifie que la valeur stop est le dernier élément du tableau. Lorsque vous définissez endpoint=False, la valeur d'arrêt est exclue et l'espacement change.

import numpy as np
 
with_endpoint = np.linspace(0, 1, 5, endpoint=True)
print("endpoint=True: ", with_endpoint)
# Output: endpoint=True:  [0.   0.25 0.5  0.75 1.  ]
 
without_endpoint = np.linspace(0, 1, 5, endpoint=False)
print("endpoint=False:", without_endpoint)
# Output: endpoint=False: [0.  0.2 0.4 0.6 0.8]

Quand endpoint=False est-il utile ? Un exemple classique est la génération d'angles pour une transformée de Fourier discrète, où vous voulez N points dans [0, 2*pi) sans répéter l'angle de départ.

import numpy as np
 
N = 8
angles = np.linspace(0, 2 * np.pi, N, endpoint=False)
print(np.round(angles, 4))
# Output: [0.     0.7854 1.5708 2.3562 3.1416 3.927  4.7124 5.4978]

Obtenir la taille du pas avec retstep

Lorsque retstep=True, np.linspace() renvoie un tuple : le tableau et la taille du pas calculée. C'est pratique lorsque vous avez besoin de l'espacement pour des calculs ultérieurs sans le calculer vous-même.

import numpy as np
 
values, step = np.linspace(0, 10, num=5, retstep=True)
print("Values:", values)
print("Step:  ", step)
# Output:
# Values: [ 0.   2.5  5.   7.5 10. ]
# Step:   2.5

Vous pouvez utiliser la taille du pas pour la différentiation numérique, l'intégration, ou simplement pour vérifier que votre grille a la résolution attendue.

import numpy as np
 
x, dx = np.linspace(0, np.pi, 1000, retstep=True)
# Approximate integral of sin(x) from 0 to pi using the trapezoidal rule
integral = np.trapz(np.sin(x), dx=dx)
print(f"Integral of sin(x) over [0, pi]: {integral:.6f}")
# Output: Integral of sin(x) over [0, pi]: 2.000000

np.linspace() vs np.arange() : Quand utiliser laquelle

Les deux fonctions créent des séquences de nombres, mais elles diffèrent fondamentalement : linspace vous permet de spécifier le nombre, tandis que arange vous permet de spécifier la taille du pas.

Piège de virgule flottante avec arange

import numpy as np
 
# arange can produce unexpected element counts with float steps
arr = np.arange(0, 1, 0.1)
print(len(arr), arr)
# Output: 10 [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
 
# Slightly different bounds can cause an extra element
arr2 = np.arange(0, 1.0 + 1e-15, 0.1)
print(len(arr2))
# Output: 11

Avec linspace, vous obtenez toujours exactement le nombre d'éléments demandés. Lorsque vous travaillez avec des intervalles en virgule flottante, préférez linspace à moins que vous n'ayez véritablement besoin d'une taille de pas spécifique et de limites compatibles avec les entiers.

Cas d'utilisation pratiques

1. Tracer des courbes lisses

L'utilisation la plus courante de np.linspace() est la génération de valeurs x pour tracer des fonctions mathématiques. Plus de points produisent des courbes plus lisses.

import numpy as np
import matplotlib.pyplot as plt
 
x = np.linspace(-2 * np.pi, 2 * np.pi, 300)
y = np.sin(x) / x  # sinc-like function (warning: division by zero at x=0)
 
# Handle division by zero
y = np.where(np.isclose(x, 0), 1.0, np.sin(x) / x)
 
plt.figure(figsize=(8, 4))
plt.plot(x, y, linewidth=1.5)
plt.title("sinc-like function: sin(x)/x")
plt.xlabel("x")
plt.ylabel("y")
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig("sinc_plot.png", dpi=100)
plt.show()

2. Traitement du signal : Générer des axes temporels

Lors de la simulation ou de l'analyse de signaux, vous avez besoin d'un vecteur temporel avec une fréquence d'échantillonnage connue. linspace rend cela simple.

import numpy as np
 
duration = 1.0        # seconds
sample_rate = 44100   # Hz (CD quality)
num_samples = int(duration * sample_rate)
 
t = np.linspace(0, duration, num_samples, endpoint=False)
 
# Generate a 440 Hz sine wave (concert A)
frequency = 440
signal = np.sin(2 * np.pi * frequency * t)
 
print(f"Time array shape: {t.shape}")
print(f"First 5 time values: {t[:5]}")
print(f"First 5 signal values: {np.round(signal[:5], 6)}")
# Output:
# Time array shape: (44100,)
# First 5 time values: [0.00000000e+00 2.26757370e-05 4.53514739e-05 6.80272109e-05 9.07029478e-05]
# First 5 signal values: [0.       0.062648 0.125178 0.187474 0.24942 ]

Notez que endpoint=False est utilisé ici car le signal est périodique : l'échantillon à t = 1.0 dupliquerait l'échantillon à t = 0.0.

3. Créer des dégradés de couleurs

linspace est utile pour interpoler entre des valeurs de couleur lors de la construction de cartes de couleurs personnalisées.

import numpy as np
 
# Interpolate between blue (0, 0, 255) and red (255, 0, 0) in 5 steps
steps = 5
r = np.linspace(0, 255, steps).astype(int)
g = np.zeros(steps, dtype=int)
b = np.linspace(255, 0, steps).astype(int)
 
colors = np.column_stack([r, g, b])
for i, c in enumerate(colors):
    print(f"Step {i}: RGB({c[0]:3d}, {c[1]:3d}, {c[2]:3d})")
# Output:
# Step 0: RGB(  0,   0, 255)
# Step 1: RGB( 63,   0, 191)
# Step 2: RGB(127,   0, 127)
# Step 3: RGB(191,   0,  63)
# Step 4: RGB(255,   0,   0)

Grilles multidimensionnelles avec linspace et meshgrid

Pour les calculs 2D ou 3D (cartes de chaleur, graphiques de surface, graphiques de contour), combinez np.linspace() avec np.meshgrid().

import numpy as np
 
x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y)
 
# Compute a 2D Gaussian
Z = np.exp(-(X**2 + Y**2))
 
print(f"X shape: {X.shape}")
print(f"Z min: {Z.min():.6f}, Z max: {Z.max():.6f}")
# Output:
# X shape: (100, 100)
# Z min: 0.000001, Z max: 1.000000

import numpy as np
import matplotlib.pyplot as plt
 
x = np.linspace(-3, 3, 200)
y = np.linspace(-3, 3, 200)
X, Y = np.meshgrid(x, y)
Z = np.exp(-(X**2 + Y**2))
 
plt.figure(figsize=(6, 5))
plt.contourf(X, Y, Z, levels=20, cmap="viridis")
plt.colorbar(label="Amplitude")
plt.title("2D Gaussian via linspace + meshgrid")
plt.xlabel("x")
plt.ylabel("y")
plt.tight_layout()
plt.savefig("gaussian_contour.png", dpi=100)
plt.show()

Ce modèle s'adapte à n'importe quelle dimension. Pour les grilles 3D, ajoutez un troisième appel linspace et utilisez np.meshgrid(x, y, z).

Le paramètre dtype

Par défaut, np.linspace() renvoie des valeurs float64. Vous pouvez remplacer cela avec le paramètre dtype, mais sachez que les types entiers tronqueront les valeurs calculées.

import numpy as np
 
# Float64 (default)
print(np.linspace(0, 5, 6).dtype)
# Output: float64
 
# Explicit float32 for memory savings
arr32 = np.linspace(0, 1, 5, dtype=np.float32)
print(arr32, arr32.dtype)
# Output: [0.   0.25 0.5  0.75 1.  ] float32
 
# Integer dtype truncates values
arr_int = np.linspace(0, 10, 5, dtype=int)
print(arr_int)
# Output: [ 0  2  5  7 10]

Lors de l'utilisation de types entiers, les parties fractionnaires sont simplement supprimées (comportement floor), ce qui peut produire des résultats inégalement espacés. Conservez les types float sauf si vous avez une raison spécifique de convertir.

Modèles courants : Générer des valeurs X pour le tracé de fonctions

Voici une référence concise des modèles que vous utiliserez régulièrement.

Modèle 1 : Tracé de fonction standard

import numpy as np
import matplotlib.pyplot as plt
 
x = np.linspace(0, 10, 500)
plt.plot(x, np.sin(x), label="sin(x)")
plt.plot(x, np.cos(x), label="cos(x)")
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Modèle 2 : Courbe paramétrique

import numpy as np
import matplotlib.pyplot as plt
 
t = np.linspace(0, 2 * np.pi, 1000)
x = 16 * np.sin(t)**3
y = 13 * np.cos(t) - 5 * np.cos(2*t) - 2 * np.cos(3*t) - np.cos(4*t)
 
plt.figure(figsize=(5, 5))
plt.plot(x, y, color="red")
plt.title("Heart Curve")
plt.axis("equal")
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Modèle 3 : Évaluer un polynôme sur une plage

import numpy as np
 
coefficients = [1, -3, 2]  # x^2 - 3x + 2
x = np.linspace(-1, 4, 6)
y = np.polyval(coefficients, x)
 
for xi, yi in zip(x, y):
    print(f"x={xi:5.2f}  ->  y={yi:5.2f}")
# Output:
# x=-1.00  ->  y= 6.00
# x= 0.00  ->  y= 2.00
# x= 1.00  ->  y= 0.00
# x= 2.00  ->  y= 0.00
# x= 3.00  ->  y= 2.00
# x= 4.00  ->  y= 6.00

Visualiser les données générées par Linspace avec PyGWalker

Lorsque vous travaillez avec des tableaux créés par np.linspace(), vous devez souvent explorer les données résultantes de manière interactive -- ajuster les axes, filtrer les plages ou comparer plusieurs séries sans réécrire le code de tracé à chaque fois. PyGWalker (opens in a new tab) est une bibliothèque Python open-source qui transforme tout DataFrame Pandas en une interface de visualisation interactive de type Tableau directement dans Jupyter Notebook.

Voici comment combiner des données générées par linspace avec PyGWalker pour une exploration interactive :

import numpy as np
import pandas as pd
import pygwalker as pyg
 
# Generate data using linspace
x = np.linspace(0, 4 * np.pi, 200)
df = pd.DataFrame({
    "x": x,
    "sin": np.sin(x),
    "cos": np.cos(x),
    "damped_sin": np.exp(-0.1 * x) * np.sin(x),
})
 
# Launch interactive visualization in Jupyter
walker = pyg.walk(df)

Avec PyGWalker ouvert, vous pouvez glisser x sur l'axe des x, déposer sin et damped_sin sur l'axe des y, et comparer instantanément les formes d'onde. Vous pouvez basculer entre les graphiques en lignes, les nuages de points et les diagrammes à barres sans écrire de code supplémentaire. C'est particulièrement utile lorsque vous générez des données sur différentes plages de paramètres avec linspace et que vous souhaitez confirmer visuellement le comportement avant de finaliser un tracé.

Foire aux questions

Quelle est la différence entre np.linspace et np.arange ?

np.linspace() prend une valeur de début, une valeur d'arrêt et le nombre de points souhaités. np.arange() prend une valeur de début, une valeur d'arrêt et une taille de pas. Utilisez linspace quand vous vous souciez du nombre de points (tracé, interpolation). Utilisez arange quand vous vous souciez du pas exact entre les valeurs (séquences d'entiers, boucles).

np.linspace inclut-il l'endpoint par défaut ?

Oui. Par défaut, endpoint=True, ce qui signifie que la valeur stop est incluse comme dernier élément. Définissez endpoint=False pour l'exclure, ce qui est utile pour les signaux périodiques ou les transformées de Fourier.

Comment obtenir la taille du pas de np.linspace ?

Passez retstep=True pour obtenir un tuple de (tableau, taille_du_pas). Par exemple : values, step = np.linspace(0, 10, 100, retstep=True).

np.linspace peut-il générer des entiers ?

Vous pouvez passer dtype=int, mais les valeurs seront tronquées (pas arrondies), ce qui produit souvent un espacement inégal. Si vous avez besoin d'entiers uniformément espacés, np.arange() est généralement un meilleur choix.

Combien de points dois-je utiliser pour un tracé lisse ?

Pour la plupart des tracés de fonctions 2D, 200 à 500 points produisent des courbes visuellement lisses. Pour les fonctions à haute fréquence ou les figures de qualité publication, 1000 points est un choix sûr. Plus de points augmentent l'utilisation de la mémoire et le temps de rendu, alors équilibrez la fluidité avec les performances.

Conclusion

numpy.linspace() est l'une des fonctions NumPy les plus fréquemment utilisées pour une bonne raison : elle vous donne un contrôle précis sur le nombre de valeurs uniformément espacées que vous générez entre deux extrémités. Contrairement à np.arange(), elle ne vous surprend jamais avec un élément supplémentaire ou manquant en raison de l'arrondi en virgule flottante. Les paramètres endpoint, retstep et dtype vous donnent un contrôle fin pour tout, des tracés rapides aux pipelines de traitement du signal.

Points clés à retenir :

• Utilisez num pour définir le nombre exact de valeurs de sortie.
• Définissez endpoint=False pour les données périodiques où la valeur d'arrêt dupliquerait le début.
• Utilisez retstep=True chaque fois que vous avez besoin de la taille du pas pour un calcul en aval.
• Préférez linspace à arange pour les intervalles en virgule flottante.
• Combinez linspace avec meshgrid pour les grilles multidimensionnelles.

Avec ces modèles dans votre boîte à outils, vous pouvez générer en toute confiance des séquences numériques pour le tracé, la simulation, l'interpolation et le calcul scientifique en Python.