NumPy Arange: Arrays mit gleichmäßig verteilten Werten erstellen

Name

Soren Atelier

Updated on 9.2.2026

Das Erstellen von Arrays mit gleichmäßig verteilten Zahlen ist eine der häufigsten Operationen im wissenschaftlichen Rechnen, in der Datenanalyse und im maschinellen Lernen. Ob Sie eine Folge von Indizes für eine Schleife, X-Achsen-Werte für ein Diagramm oder Gitterkoordinaten für eine Simulation benötigen – Sie brauchen eine schnelle und zuverlässige Methode, um diese zu generieren. Pythons eingebaute Funktion range() funktioniert für Ganzzahlen, versagt aber in dem Moment, in dem Sie Gleitkomma-Schritte benötigen oder das Ergebnis als NumPy-Array für vektorisierte Mathematik brauchen.

Genau das löst numpy.arange(). Die Funktion erzeugt Arrays mit gleichmäßig verteilten Werten mit voller Kontrolle über Startpunkt, Endpunkt, Schrittweite und Datentyp – alles in einem einzigen Funktionsaufruf. Dieser Leitfaden behandelt jeden Parameter, geht praktische Beispiele durch, vergleicht np.arange() mit Alternativen wie range() und np.linspace() und zeigt Ihnen, wie Sie die häufigsten Fehler vermeiden.

Was np.arange() macht

np.arange() gibt ein eindimensionales NumPy-Array zurück, das gleichmäßig verteilte Werte innerhalb eines gegebenen Intervalls enthält. Es ist das NumPy-Äquivalent von Pythons range(), gibt aber ein ndarray anstelle eines Range-Objekts zurück und unterstützt Gleitkommazahlen.

Hier ist die vollständige Funktionssignatur:

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

Parameterreferenz

Die Funktion erzeugt Werte beginnend bei start und erhöht sich um step, wobei sie vor Erreichen von stop stoppt. Dieses Verhalten mit "exklusivem Stop" entspricht Pythons range().

Grundlegende Verwendung: Nur der Stop-Wert

Der einfachste Weg, np.arange() zu verwenden, ist mit einem einzelnen Argument. Wenn Sie einen Wert übergeben, wird er als stop behandelt, und start hat standardmäßig den Wert 0 mit einem step von 1.

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

Dies erstellt ein Array von Ganzzahlen von 0 bis (aber nicht einschließlich) 5. Beachten Sie, dass das Ergebnis ein NumPy ndarray ist, keine Python-Liste. Das bedeutet, dass Sie es sofort in vektorisierten Operationen verwenden können:

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]

Verwendung von Start und Stop

Übergeben Sie zwei Argumente, um zu steuern, wo die Sequenz beginnt und endet:

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

Das Array beginnt bei 2 (inklusive) und stoppt vor 10 (exklusive). Der Standard-Schritt ist weiterhin 1.

Sie können auch negative Startwerte verwenden:

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

Verwendung von Start, Stop und Step

Das dritte Argument steuert den Abstand zwischen den Werten. Hier wird np.arange() viel leistungsfähiger als range(), da der Schritt eine Gleitkommazahl sein kann:

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]

Ganzzahlige Schritte funktionieren genauso:

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

Der Schritt kann jede positive Zahl sein. Die Sequenz stoppt immer vor Erreichen des stop-Werts.

Gleitkomma-Schrittweiten und Präzisionsprobleme

Die Verwendung von Gleitkomma-Schrittweiten ist praktisch, hat aber einen Vorbehalt: Gleitkomma-Arithmetik ist nicht exakt. Kleine Rundungsfehler können sich akkumulieren und gelegentlich unerwartete Ergebnisse produzieren.

Betrachten Sie dieses Beispiel:

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

Das sieht korrekt aus. Aber beobachten Sie, was bei bestimmten Schrittweiten passiert:

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

Aufgrund der Gleitkommadarstellung ist 0.1 * 10 im Binärsystem möglicherweise nicht exakt gleich 1.0. Die Anzahl der Elemente im Ergebnis kann je nach den spezifischen Werten um eins variieren.

Best Practice: Wenn Sie eine exakte Anzahl gleichmäßig verteilter Gleitkommawerte benötigen, verwenden Sie stattdessen np.linspace(). Verwenden Sie np.arange() für Gleitkommasequenzen nur dann, wenn die genaue Anzahl der Elemente keine Rolle spielt.

Negative Schritte: Rückwärts zählen

Setzen Sie einen negativen step, um eine absteigende Sequenz zu erstellen:

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

Ein Gleitkomma-Schritt funktioniert genauso:

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

Die wichtige Regel: Die Schrittrichtung muss mit der Richtung von start zu stop übereinstimmen. Wenn start < stop, muss der Schritt positiv sein. Wenn start > stop, muss der Schritt negativ sein. Wird dies falsch gemacht, entsteht ein leeres Array (behandelt im Fehlerabschnitt unten).

Der dtype-Parameter

Standardmäßig leitet np.arange() den Datentyp aus den übergebenen Argumenten ab. Wenn alle Argumente Ganzzahlen sind, erhalten Sie ein Ganzzahl-Array. Wenn ein Argument eine Gleitkommazahl ist, erhalten Sie ein Gleitkomma-Array. Der dtype-Parameter ermöglicht es Ihnen, dies zu überschreiben:

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]

Beachten Sie das letzte Beispiel: Wenn Sie einen Ganzzahl-dtype auf eine Gleitkommasequenz erzwingen, wird jeder Wert abgeschnitten (nicht gerundet). Dies kann zu doppelten Werten und unerwarteten Ergebnissen führen, also verwenden Sie es vorsichtig.

np.arange() vs range(): Wann welche Funktion verwenden

Pythons eingebaute Funktion range() und NumPys np.arange() generieren beide Zahlensequenzen, dienen aber unterschiedlichen Zwecken.

Wann range() verwenden: Reine Python-Schleifen, bei denen Sie Indizes benötigen und keine Berechnungen mit der Sequenz selbst durchführen.

Wann np.arange() verwenden: Immer wenn das Ergebnis in numerischen Berechnungen verwendet wird, an eine NumPy/SciPy-Funktion übergeben wird oder Gleitkommawerte enthalten muss.

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(): Wann welche Funktion verwenden

Beide Funktionen erstellen Arrays mit gleichmäßig verteilten Werten, definieren den Abstand aber unterschiedlich.

Hier ist ein Vergleichsbeispiel, das den Unterschied deutlich zeigt:

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)

Beachten Sie, dass np.linspace() den Endpunkt (1.0) einschließt und genau 6 Werte garantiert, während np.arange() vor 1.0 stoppt und die Anzahl von der Gleitkomma-Schrittberechnung abhängt.

Faustregel: Verwenden Sie np.arange(), wenn die Schrittweite wichtig ist. Verwenden Sie np.linspace(), wenn die Anzahl der Punkte wichtig ist.

Häufige Anwendungsfälle

Schleifen-Indizes und Array-Indizierung

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]

X-Achsen-Werte für Diagramme

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

Sie können x und y direkt an matplotlibs plt.plot(x, y) übergeben, um eine glatte Sinuswelle zu zeichnen.

Gitterkoordinaten erstellen

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]]

Dieses Muster wird ausgiebig in der Bildverarbeitung, bei Heatmaps und 3D-Oberflächendiagrammen verwendet.

Zeitbasierte Sequenzen generieren

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]

Häufige Fehler und deren Behebung

Leeres Array durch falsche Schrittrichtung

Der häufigste Fehler bei np.arange() ist die Verwendung eines Schritts, der in die falsche Richtung geht:

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: []

Beide geben ein leeres Array zurück, ohne Fehler oder Warnung. Die Lösung ist einfach – stellen Sie sicher, dass die Schrittrichtung mit der Richtung von start zu stop übereinstimmt:

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]

Schrittweite Null

Ein Schritt von 0 ist nie gültig und löst einen Fehler aus:

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

Unerwartet große Arrays

Da np.arange() das gesamte Array auf einmal im Speicher erstellt, kann ein sehr kleiner Schritt über einen großen Bereich Gigabytes an RAM verbrauchen:

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)

Schätzen Sie immer die Größe, bevor Sie große Sequenzen generieren.

Experimentieren Sie mit NumPy in RunCell

Wenn Sie diese Beispiele interaktiv ausprobieren und KI-gestützte Unterstützung beim Lernen von NumPy erhalten möchten, schauen Sie sich RunCell (opens in a new tab) an. RunCell ist ein KI-Agent, der direkt in Jupyter integriert ist und Datenwissenschaftlern beim Schreiben, Debuggen und Optimieren von Code hilft.

Anstatt zwischen Dokumentations-Tabs und Ihrem Notebook zu wechseln, können Sie RunCell bitten, np.arange()-Beispiele zu generieren, das Verhalten der Gleitkomma-Präzision zu erklären oder Ihnen bei der Wahl zwischen arange und linspace für Ihren speziellen Anwendungsfall zu helfen. Es läuft direkt in Ihrer bestehenden Jupyter-Umgebung, sodass es keine Einrichtungshürden gibt – einfach installieren und direkt neben Ihren Code-Zellen Fragen stellen.

Dies ist besonders nützlich, wenn Sie zum ersten Mal NumPy-Array-Erstellungsfunktionen erkunden, da Sie Beispiele in Echtzeit iterieren und Ergebnisse sofort sehen können.

FAQ

Was gibt numpy arange zurück?

np.arange() gibt ein eindimensionales NumPy ndarray zurück, das gleichmäßig verteilte Werte enthält. Im Gegensatz zu Pythons range(), das einen lazy Iterator zurückgibt, erzeugt np.arange() das vollständige Array im Speicher. Das Array unterstützt vektorisierte Operationen, Broadcasting und alle Standard-NumPy-Funktionen.

Kann numpy arange Gleitkomma-Schritte verwenden?

Ja. Im Gegensatz zu Pythons range(), das nur Ganzzahlen akzeptiert, unterstützt np.arange() vollständig Gleitkomma-Werte für Start, Stop und Schritt. Zum Beispiel erzeugt np.arange(0, 1, 0.1) [0.0, 0.1, 0.2, ..., 0.9]. Beachten Sie jedoch, dass Gleitkomma-Rundungen gelegentlich dazu führen können, dass das Ergebnis ein Element mehr oder weniger als erwartet hat. Verwenden Sie np.linspace(), wenn Sie eine garantierte Anzahl von Elementen benötigen.

Was ist der Unterschied zwischen np.arange und np.linspace?

np.arange() nimmt eine Schrittweite und erzeugt Werte, bis es den Stop-Wert erreicht (exklusive). np.linspace() nimmt die gewünschte Anzahl von Punkten und berechnet die Schrittweite automatisch, wobei der Endpunkt standardmäßig eingeschlossen ist. Verwenden Sie arange, wenn Sie die Schrittweite kennen. Verwenden Sie linspace, wenn Sie wissen, wie viele Punkte Sie benötigen.

Warum gibt np.arange ein leeres Array zurück?

Ein leeres Array wird zurückgegeben, wenn die Schrittrichtung nicht mit der Richtung von Start zu Stop übereinstimmt. Zum Beispiel gibt np.arange(10, 0, 1) ein leeres Array zurück, weil ein positiver Schritt nicht von 10 nach unten zu 0 gehen kann. Die Lösung ist ein negativer Schritt: np.arange(10, 0, -1).

Ist np.arange inklusive oder exklusive des Stop-Werts?

Der Stop-Wert ist exklusive – er ist nie im Output enthalten. np.arange(0, 5) gibt [0, 1, 2, 3, 4] zurück, nicht [0, 1, 2, 3, 4, 5]. Dies entspricht dem Verhalten von Pythons eingebautem range(). Wenn Sie den Endpunkt einschließen möchten, verwenden Sie np.linspace() mit endpoint=True (Standard).

Fazit

np.arange() ist aus gutem Grund eine der am häufigsten verwendeten NumPy-Funktionen: Es ist der schnellste Weg, Arrays mit gleichmäßig verteilten Zahlen in Python zu erzeugen. Hier eine Zusammenfassung der wichtigsten Punkte:

• Ein Argument (np.arange(n)) erstellt Ganzzahlen von 0 bis n-1.
• Zwei Argumente (np.arange(start, stop)) definieren den Bereich mit einem Standard-Schritt von 1.
• Drei Argumente (np.arange(start, stop, step)) geben volle Kontrolle, einschließlich Gleitkomma-Schritte und negative Schritte für absteigende Sequenzen.
• dtype überschreibt die automatische Typerkennung, wenn Sie einen bestimmten Datentyp benötigen.
• Verwenden Sie np.arange(), wenn die Schrittweite wichtig ist. Verwenden Sie np.linspace(), wenn die Anzahl der Punkte wichtig ist.
• Vorsicht bei Gleitkomma-Präzision – np.arange() mit Gleitkomma-Schritten kann eine unerwartete Anzahl von Elementen erzeugen.
• Leere Arrays entstehen durch eine Diskrepanz zwischen Schrittrichtung und der Start-zu-Stop-Richtung.

Für interaktives Experimentieren mit NumPy-Arrays bietet RunCell (opens in a new tab) KI-gestütztes Coding direkt in Jupyter, mit dem Sie np.arange()-Varianten testen und sofortige Erklärungen erhalten können, ohne Ihr Notebook zu verlassen.