NumPy Arange : Comment créer des tableaux avec des valeurs uniformément espacées

Name

Soren Atelier

Updated on 09/02/2026

Créer des tableaux de nombres uniformément espacés est l'une des opérations les plus courantes en calcul scientifique, en analyse de données et en apprentissage automatique. Que vous ayez besoin d'une séquence d'indices pour une boucle, de valeurs d'axe X pour un graphique ou de coordonnées de grille pour une simulation, vous avez besoin d'un moyen rapide et fiable de les générer. La fonction intégrée range() de Python fonctionne pour les entiers, mais elle échoue dès que vous avez besoin de pas en virgule flottante ou que vous devez obtenir le résultat sous forme de tableau NumPy pour les calculs vectorisés.

C'est exactement ce que résout numpy.arange(). Cette fonction génère des tableaux de valeurs uniformément espacées avec un contrôle total sur le point de départ, le point d'arrêt, la taille du pas et le type de données -- le tout en un seul appel de fonction. Ce guide couvre chaque paramètre, présente des exemples pratiques, compare np.arange() avec des alternatives comme range() et np.linspace(), et vous montre comment éviter les erreurs les plus courantes.

Ce que fait np.arange()

np.arange() renvoie un tableau NumPy unidimensionnel contenant des valeurs uniformément espacées dans un intervalle donné. C'est l'équivalent NumPy du range() de Python, mais il renvoie un ndarray au lieu d'un objet range, et il prend en charge les nombres à virgule flottante.

Voici la signature complète de la fonction :

numpy.arange([start, ] stop, [step, ] dtype=None)

Référence des paramètres

La fonction génère des valeurs à partir de start et incrémente de step, s'arrêtant avant que stop ne soit atteint. Ce comportement d'« arrêt exclusif » correspond au range() de Python.

Utilisation de base : Uniquement la valeur de Stop

La façon la plus simple d'utiliser np.arange() est avec un seul argument. Lorsque vous passez une valeur, elle est traitée comme stop, et start vaut par défaut 0 avec un step de 1.

import numpy as np
 
arr = np.arange(5)
print(arr)
# Output: [0 1 2 3 4]
 
print(type(arr))
# Output: <class 'numpy.ndarray'>

Cela crée un tableau d'entiers de 0 jusqu'à (mais sans inclure) 5. Notez que le résultat est un ndarray NumPy, pas une liste Python. Cela signifie que vous pouvez l'utiliser immédiatement dans des opérations vectorisées :

import numpy as np
 
arr = np.arange(5)
print(arr * 10)
# Output: [ 0 10 20 30 40]
 
print(arr ** 2)
# Output: [ 0  1  4  9 16]

Utiliser Start et Stop

Passez deux arguments pour contrôler où la séquence commence et se termine :

import numpy as np
 
arr = np.arange(2, 10)
print(arr)
# Output: [2 3 4 5 6 7 8 9]

Le tableau commence à 2 (inclusif) et s'arrête avant 10 (exclusif). Le pas par défaut est toujours 1.

Vous pouvez également utiliser des valeurs de départ négatives :

import numpy as np
 
arr = np.arange(-3, 4)
print(arr)
# Output: [-3 -2 -1  0  1  2  3]

Utiliser Start, Stop et Step

Le troisième argument contrôle l'espacement entre les valeurs. C'est ici que np.arange() devient bien plus puissant que range(), car le pas peut être un nombre à virgule flottante :

import numpy as np
 
arr = np.arange(0, 1, 0.1)
print(arr)
# Output: [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

Les pas entiers fonctionnent de la même manière :

import numpy as np
 
arr = np.arange(0, 20, 3)
print(arr)
# Output: [ 0  3  6  9 12 15 18]

Le pas peut être n'importe quel nombre positif. La séquence s'arrête toujours avant d'atteindre la valeur stop.

Pas à virgule flottante et problèmes de précision

L'utilisation de pas à virgule flottante est pratique, mais elle comporte un inconvénient : l'arithmétique en virgule flottante n'est pas exacte. De petites erreurs d'arrondi peuvent s'accumuler et produire occasionnellement des résultats inattendus.

Considérez cet exemple :

import numpy as np
 
arr = np.arange(0, 1, 0.3)
print(arr)
# Output: [0.  0.3 0.6 0.9]
 
print(len(arr))
# Output: 4

Cela semble correct. Mais observez ce qui se passe avec certaines tailles de pas :

import numpy as np
 
arr = np.arange(0, 1.0, 0.1)
print(len(arr))
# Output: 10
 
arr2 = np.arange(0.0, 1.0 + 1e-10, 0.1)
print(len(arr2))
# Output: 11

En raison de la représentation en virgule flottante, 0.1 * 10 pourrait ne pas être exactement égal à 1.0 en binaire. Le nombre d'éléments dans le résultat peut varier d'un en fonction des valeurs spécifiques.

Bonne pratique : Lorsque vous avez besoin d'un nombre exact de valeurs à virgule flottante uniformément espacées, utilisez np.linspace() à la place. Utilisez np.arange() pour les séquences à virgule flottante uniquement lorsque le nombre exact d'éléments n'a pas d'importance.

Pas négatifs : Compter à rebours

Définissez un step négatif pour créer une séquence descendante :

import numpy as np
 
arr = np.arange(10, 0, -1)
print(arr)
# Output: [10  9  8  7  6  5  4  3  2  1]

Un pas à virgule flottante fonctionne de la même manière :

import numpy as np
 
arr = np.arange(2.0, 0.0, -0.5)
print(arr)
# Output: [2.  1.5 1.  0.5]

La règle clé : la direction du pas doit correspondre à la direction de start vers stop. Si start < stop, le pas doit être positif. Si start > stop, le pas doit être négatif. Se tromper produit un tableau vide (traité dans la section des erreurs ci-dessous).

Le paramètre dtype

Par défaut, np.arange() déduit le type de données à partir des arguments que vous passez. Si tous les arguments sont des entiers, vous obtenez un tableau d'entiers. Si un argument est un flottant, vous obtenez un tableau de flottants. Le paramètre dtype vous permet de remplacer cela :

import numpy as np
 
# Default: integers in, integers out
arr_int = np.arange(5)
print(arr_int.dtype)
# Output: int64
 
# Default: float step, float output
arr_float = np.arange(0, 5, 0.5)
print(arr_float.dtype)
# Output: float64
 
# Force float output from integer inputs
arr_forced = np.arange(5, dtype=np.float32)
print(arr_forced)
# Output: [0. 1. 2. 3. 4.]
print(arr_forced.dtype)
# Output: float32
 
# Force integer output (values get truncated)
arr_trunc = np.arange(0, 2, 0.5, dtype=int)
print(arr_trunc)
# Output: [0 0 1 1]

Remarquez le dernier exemple : lorsque vous forcez un dtype entier sur une séquence de flottants, chaque valeur est tronquée (pas arrondie) en entier. Cela peut produire des valeurs en double et des résultats inattendus, alors utilisez-le avec précaution.

np.arange() vs range() : Quand utiliser lequel

La fonction intégrée range() de Python et np.arange() de NumPy génèrent toutes deux des séquences de nombres, mais elles servent des objectifs différents.

Quand utiliser range() : Boucles Python pures où vous avez besoin d'indices et vous ne faites aucun calcul sur la séquence elle-même.

Quand utiliser np.arange() : Chaque fois que le résultat sera utilisé dans un calcul numérique, passé à une fonction NumPy/SciPy, ou doit contenir des valeurs à virgule flottante.

import numpy as np
 
# range() for loop iteration
for i in range(5):
    print(i, end=' ')
# Output: 0 1 2 3 4
 
print()
 
# np.arange() for vectorized math
x = np.arange(5)
print(np.sin(x))
# Output: [ 0.          0.84147098  0.90929743  0.14112001 -0.7568025 ]

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

Les deux fonctions créent des tableaux de valeurs uniformément espacées, mais elles définissent l'espacement différemment.

Voici un exemple comparatif qui montre clairement la différence :

import numpy as np
 
# arange: "give me values from 0 to 1, stepping by 0.2"
a = np.arange(0, 1, 0.2)
print(f"arange: {a}  (length: {len(a)})")
# Output: arange: [0.  0.2 0.4 0.6 0.8]  (length: 5)
 
# linspace: "give me exactly 6 values from 0 to 1"
b = np.linspace(0, 1, 6)
print(f"linspace: {b}  (length: {len(b)})")
# Output: linspace: [0.  0.2 0.4 0.6 0.8 1. ]  (length: 6)

Remarquez que np.linspace() inclut le point final (1.0) et garantit exactement 6 valeurs, tandis que np.arange() s'arrête avant 1.0 et le nombre dépend du calcul du pas en virgule flottante.

Règle générale : Utilisez np.arange() quand la taille du pas compte. Utilisez np.linspace() quand le nombre de points compte.

Cas d'utilisation courants

Indices de boucle et indexation de tableaux

import numpy as np
 
data = np.array([10, 20, 30, 40, 50])
indices = np.arange(len(data))
 
print(indices)
# Output: [0 1 2 3 4]
 
# Use for conditional selection
mask = indices % 2 == 0
print(data[mask])
# Output: [10 30 50]

Valeurs d'axe X pour les graphiques

import numpy as np
 
x = np.arange(0, 2 * np.pi, 0.01)
y = np.sin(x)
 
print(f"x has {len(x)} points, from {x[0]:.2f} to {x[-1]:.2f}")
# Output: x has 629 points, from 0.00 to 6.28
print(f"y ranges from {y.min():.4f} to {y.max():.4f}")
# Output: y ranges from -1.0000 to 1.0000

Vous pouvez passer x et y directement à plt.plot(x, y) de matplotlib pour tracer une onde sinusoïdale lisse.

Création de coordonnées de grille

import numpy as np
 
x = np.arange(0, 3)
y = np.arange(0, 4)
xx, yy = np.meshgrid(x, y)
 
print("xx:")
print(xx)
# Output:
# [[0 1 2]
#  [0 1 2]
#  [0 1 2]
#  [0 1 2]]
 
print("yy:")
print(yy)
# Output:
# [[0 0 0]
#  [1 1 1]
#  [2 2 2]
#  [3 3 3]]

Ce modèle est largement utilisé dans le traitement d'images, les cartes thermiques et les graphiques de surface 3D.

Génération de séquences temporelles

import numpy as np
 
# Hours from 0 to 24 in 30-minute intervals
hours = np.arange(0, 24.5, 0.5)
print(f"Time points: {len(hours)}")
# Output: Time points: 49
print(hours[:6])
# Output: [0.  0.5 1.  1.5 2.  2.5]

Erreurs courantes et comment les corriger

Tableau vide dû à une mauvaise direction de pas

L'erreur la plus fréquente avec np.arange() est d'utiliser un pas qui va dans la mauvaise direction :

import numpy as np
 
# Trying to count down with a positive step
arr = np.arange(10, 0, 1)
print(arr)
# Output: []
 
# Trying to count up with a negative step
arr2 = np.arange(0, 10, -1)
print(arr2)
# Output: []

Les deux renvoient un tableau vide sans erreur ni avertissement. La solution est simple -- assurez-vous que la direction du pas correspond à la direction de start vers stop :

import numpy as np
 
# Correct: counting down with negative step
arr = np.arange(10, 0, -1)
print(arr)
# Output: [10  9  8  7  6  5  4  3  2  1]

Taille de pas nulle

Un pas de 0 n'est jamais valide et provoque une erreur :

import numpy as np
 
try:
    arr = np.arange(0, 10, 0)
except ZeroDivisionError as e:
    print(f"Error: {e}")
# Output: Error: division by zero

Tableaux inopinément grands

Comme np.arange() crée le tableau entier en mémoire en une seule fois, un pas très petit sur une grande plage peut consommer des gigaoctets de RAM :

import numpy as np
 
# This creates 10 billion elements -- do NOT run this
# arr = np.arange(0, 10, 0.000000001)
 
# Check the size first
count = int((10 - 0) / 0.000000001)
print(f"This would create {count:,} elements")
# Output: This would create 10,000,000,000 elements
print(f"Memory: ~{count * 8 / 1e9:.1f} GB (for float64)")
# Output: Memory: ~80.0 GB (for float64)

Estimez toujours la taille avant de générer de grandes séquences.

Expérimentez avec NumPy dans RunCell

Si vous voulez essayer ces exemples de manière interactive et obtenir une assistance alimentée par l'IA tout en apprenant NumPy, découvrez RunCell (opens in a new tab). RunCell est un agent IA intégré directement dans Jupyter qui aide les data scientists à écrire, déboguer et optimiser du code.

Au lieu de basculer entre les onglets de documentation et votre notebook, vous pouvez demander à RunCell de générer des exemples de np.arange(), d'expliquer le comportement de la précision en virgule flottante, ou de vous aider à choisir entre arange et linspace pour votre cas d'utilisation spécifique. Il s'exécute directement dans votre environnement Jupyter existant, donc il n'y a aucune friction d'installation -- il suffit d'installer et de commencer à poser des questions à côté de vos cellules de code.

C'est particulièrement utile lorsque vous explorez les fonctions de création de tableaux NumPy pour la première fois, car vous pouvez itérer sur des exemples en temps réel et voir les résultats immédiatement.

FAQ

Que renvoie numpy arange ?

np.arange() renvoie un ndarray NumPy unidimensionnel contenant des valeurs uniformément espacées. Contrairement au range() de Python, qui renvoie un itérateur paresseux, np.arange() génère le tableau complet en mémoire. Le tableau prend en charge les opérations vectorisées, le broadcasting et toutes les fonctions NumPy standard.

Est-ce que numpy arange peut utiliser des valeurs de pas flottantes ?

Oui. Contrairement au range() de Python, qui n'accepte que des entiers, np.arange() prend entièrement en charge les valeurs à virgule flottante pour start, stop et step. Par exemple, np.arange(0, 1, 0.1) génère [0.0, 0.1, 0.2, ..., 0.9]. Cependant, sachez que l'arrondi en virgule flottante peut occasionnellement faire que le résultat ait un élément de plus ou de moins que prévu. Utilisez np.linspace() lorsque vous avez besoin d'un nombre garanti d'éléments.

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

np.arange() prend une taille de pas et génère des valeurs jusqu'à atteindre la valeur de stop (exclusive). np.linspace() prend le nombre de points souhaité et calcule la taille du pas automatiquement, incluant le point final par défaut. Utilisez arange quand vous connaissez la taille du pas. Utilisez linspace quand vous savez combien de points vous avez besoin.

Pourquoi np.arange renvoie-t-il un tableau vide ?

Un tableau vide est renvoyé lorsque la direction du pas ne correspond pas à la direction de start vers stop. Par exemple, np.arange(10, 0, 1) renvoie un tableau vide car un pas positif ne peut pas aller de 10 vers 0. La solution est d'utiliser un pas négatif : np.arange(10, 0, -1).

np.arange est-il inclusif ou exclusif de la valeur de stop ?

La valeur de stop est exclusive -- elle n'est jamais incluse dans la sortie. np.arange(0, 5) renvoie [0, 1, 2, 3, 4], pas [0, 1, 2, 3, 4, 5]. Cela correspond au comportement du range() intégré de Python. Si vous avez besoin que le point final soit inclus, utilisez np.linspace() avec endpoint=True (la valeur par défaut).

Conclusion

np.arange() est l'une des fonctions NumPy les plus utilisées pour une bonne raison : c'est le moyen le plus rapide de générer des tableaux de nombres uniformément espacés en Python. Voici un résumé de ce qu'il faut retenir :

• Un argument (np.arange(n)) crée des entiers de 0 à n-1.
• Deux arguments (np.arange(start, stop)) définissent la plage avec un pas par défaut de 1.
• Trois arguments (np.arange(start, stop, step)) donnent un contrôle total, y compris les pas flottants et les pas négatifs pour les séquences descendantes.
• dtype remplace l'inférence automatique de type lorsque vous avez besoin d'un type de données spécifique.
• Utilisez np.arange() quand la taille du pas compte. Utilisez np.linspace() quand le nombre de points compte.
• Attention à la précision des flottants -- np.arange() avec des pas flottants peut produire un nombre inattendu d'éléments.
• Les tableaux vides résultent d'une discordance entre la direction du pas et la direction de start vers stop.

Pour une expérimentation interactive avec les tableaux NumPy, RunCell (opens in a new tab) fournit un codage assisté par l'IA directement dans Jupyter, vous permettant de tester des variantes de np.arange() et d'obtenir des explications instantanées sans quitter votre notebook.