NumPy Linspace: Gleichmäßig verteilte Arrays in Python erstellen

Name

Soren Atelier

Updated on 9.2.2026

Eine Folge gleichmäßig verteilter Zahlen zu erzeugen klingt trivial, bis man exakte Kontrolle über Start, Stopp und Anzahl braucht. Pythons eingebaute range()-Funktion verarbeitet nur ganze Zahlen, und selbst numpy.arange() kann durch die Akkumulation von Gleitkomma-Rundungsfehlern bei der Schrittweite unerwartete Ergebnisse liefern. Wenn Sie jemals eine Funktion geplottet haben und dabei eine gezackte Kurve oder einen fehlenden letzten x-Wert erhalten haben, sind Sie genau auf dieses Problem gestoßen. numpy.linspace() wurde entwickelt, um es zu lösen: Sie geben an, wie viele Punkte Sie zwischen zwei Endpunkten möchten, und NumPy berechnet den exakten Abstand für Sie.

In diesem Leitfaden lernen Sie die vollständige np.linspace()-API kennen, sehen Vergleiche mit np.arange() nebeneinander und arbeiten sich durch praxisnahe Anwendungsfälle – von der Darstellung glatter Kurven bis zum Aufbau mehrdimensionaler Gitter. Jedes Codebeispiel ist zum Kopieren bereit und zeigt seine Ausgabe.

Was macht np.linspace()?

numpy.linspace() gibt ein Array gleichmäßig verteilter Zahlen über ein angegebenes Intervall zurück. Die Kernidee ist, dass Sie die Anzahl der Stichproben anstelle der Schrittweite definieren.

Vollständige Signatur

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

Einfaches Beispiel

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

NumPy teilt das Intervall [0, 1] in 4 gleiche Abstände (einen weniger als die 5 angeforderten Punkte) und gibt alle fünf Grenzwerte zurück, einschließlich beider Endpunkte.

Kontrolle der Punktanzahl mit num

Der Parameter num bestimmt, wie viele Werte im zurückgegebenen Array enthalten sind. Der Standardwert ist 50, weshalb der Aufruf von np.linspace(0, 10) Ihnen 50 Werte liefert, auch wenn Sie diese nicht explizit angefordert haben.

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

Ein häufiger Fehler ist, num=1 zu setzen. In diesem Fall wird nur der start-Wert zurückgegeben.

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

Der Parameter endpoint: Einschließen oder Ausschließen des Stoppwerts

Standardmäßig ist endpoint=True, was bedeutet, dass der stop-Wert das letzte Element des Arrays ist. Wenn Sie endpoint=False setzen, wird der Stoppwert ausgeschlossen und der Abstand ändert sich.

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]

Wann ist endpoint=False nützlich? Ein klassisches Beispiel ist die Erzeugung von Winkeln für eine diskrete Fourier-Transformation, bei der man N Punkte in [0, 2*pi) benötigt, ohne den Startwinkel zu wiederholen.

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]

Schrittweite ermitteln mit retstep

Wenn retstep=True gesetzt ist, gibt np.linspace() ein Tupel zurück: das Array und die berechnete Schrittweite. Dies ist praktisch, wenn Sie den Abstand für spätere Berechnungen benötigen, ohne ihn selbst berechnen zu müssen.

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

Sie können die Schrittweite für numerische Differentiation, Integration oder einfach zur Überprüfung verwenden, ob Ihr Gitter die erwartete Auflösung hat.

import numpy as np
 
x, dx = np.linspace(0, np.pi, 1000, retstep=True)
# Approximation des Integrals von sin(x) von 0 bis pi mit der Trapezregel
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(): Wann welche Funktion verwenden

Beide Funktionen erzeugen Zahlenfolgen, unterscheiden sich aber grundlegend: linspace lässt Sie die Anzahl angeben, während arange die Schrittweite festlegt.

Gleitkomma-Falle bei 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

Mit linspace erhalten Sie immer genau die Anzahl der angeforderten Elemente. Bei der Arbeit mit Gleitkomma-Intervallen bevorzugen Sie linspace, es sei denn, Sie benötigen tatsächlich eine bestimmte Schrittweite und ganzzahlfreundliche Grenzen.

Praktische Anwendungsfälle

1. Glatte Kurven plotten

Die häufigste Verwendung von np.linspace() ist die Erzeugung von x-Werten für das Plotten mathematischer Funktionen. Mehr Punkte erzeugen glattere Kurven.

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. Signalverarbeitung: Zeitachsen erzeugen

Bei der Simulation oder Analyse von Signalen benötigen Sie einen Zeitvektor mit einer bekannten Abtastrate. linspace macht dies unkompliziert.

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 ]

Beachten Sie, dass hier endpoint=False verwendet wird, da das Signal periodisch ist: die Abtastung bei t = 1.0 würde die Abtastung bei t = 0.0 duplizieren.

3. Farbverläufe erstellen

linspace ist nützlich für die Interpolation zwischen Farbwerten beim Erstellen benutzerdefinierter Farbskalen.

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)

Mehrdimensionale Gitter mit linspace und meshgrid

Für 2D- oder 3D-Berechnungen (Heatmaps, Oberflächenplots, Konturplots) kombinieren Sie np.linspace() mit 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()

Dieses Muster lässt sich auf beliebige Dimensionen skalieren. Für 3D-Gitter fügen Sie einen dritten linspace-Aufruf hinzu und verwenden np.meshgrid(x, y, z).

Der Parameter dtype

Standardmäßig gibt np.linspace() float64-Werte zurück. Sie können dies mit dem Parameter dtype überschreiben, beachten Sie jedoch, dass ganzzahlige Typen die berechneten Werte abschneiden.

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]

Bei Verwendung von ganzzahligen Datentypen werden die Nachkommastellen einfach verworfen (Floor-Verhalten), was zu ungleichmäßig verteilten Ergebnissen führen kann. Bleiben Sie bei Float-Typen, es sei denn, Sie haben einen bestimmten Grund zur Konvertierung.

Gängige Muster: X-Werte für Funktionsplots erzeugen

Hier ist eine kompakte Referenz für Muster, die Sie wiederholt verwenden werden.

Muster 1: Standard-Funktionsplot

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()

Muster 2: Parametrische Kurve

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()

Muster 3: Polynom über einen Bereich auswerten

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

Linspace-generierte Daten mit PyGWalker visualisieren

Wenn Sie mit Arrays arbeiten, die von np.linspace() erstellt wurden, müssen Sie die resultierenden Daten oft interaktiv erkunden – Achsen anpassen, Bereiche filtern oder mehrere Reihen vergleichen, ohne jedes Mal den Plotting-Code umzuschreiben. PyGWalker (opens in a new tab) ist eine Open-Source-Python-Bibliothek, die jeden Pandas DataFrame in eine interaktive Tableau-ähnliche Visualisierungsoberfläche direkt in Jupyter Notebook umwandelt.

So kombinieren Sie linspace-generierte Daten mit PyGWalker für interaktive Erkundung:

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)

Mit PyGWalker können Sie x auf die x-Achse ziehen, sin und damped_sin auf die y-Achse legen und sofort Wellenformen vergleichen. Sie können zwischen Liniendiagrammen, Streudiagrammen und Balkendiagrammen wechseln, ohne zusätzlichen Code zu schreiben. Dies ist besonders nützlich, wenn Sie Daten über verschiedene Parameterbereiche mit linspace generieren und das Verhalten visuell bestätigen möchten, bevor Sie sich auf einen endgültigen Plot festlegen.

Häufig gestellte Fragen

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

np.linspace() nimmt einen Startwert, Stoppwert und die Anzahl der Punkte, die Sie möchten. np.arange() nimmt einen Startwert, Stoppwert und eine Schrittweite. Verwenden Sie linspace, wenn Ihnen wichtig ist, wie viele Punkte Sie erhalten (Plotten, Interpolation). Verwenden Sie arange, wenn Ihnen der exakte Abstand zwischen den Werten wichtig ist (ganzzahlige Folgen, Schleifen).

Enthält np.linspace den Endpunkt standardmäßig?

Ja. Standardmäßig ist endpoint=True, was bedeutet, dass der stop-Wert als letztes Element enthalten ist. Setzen Sie endpoint=False, um ihn auszuschließen, was für periodische Signale oder Fourier-Transformationen nützlich ist.

Wie erhalte ich die Schrittweite von np.linspace?

Übergeben Sie retstep=True, um ein Tupel aus (Array, Schrittweite) zu erhalten. Zum Beispiel: values, step = np.linspace(0, 10, 100, retstep=True).

Kann np.linspace Ganzzahlen erzeugen?

Sie können dtype=int übergeben, aber die Werte werden abgeschnitten (nicht gerundet), was oft zu ungleichmäßigen Abständen führt. Wenn Sie gleichmäßig verteilte Ganzzahlen benötigen, ist np.arange() normalerweise die bessere Wahl.

Wie viele Punkte sollte ich für einen glatten Plot verwenden?

Für die meisten 2D-Funktionsplots erzeugen 200 bis 500 Punkte visuell glatte Kurven. Für hochfrequente Funktionen oder Publikationsqualität sind 1000 Punkte eine sichere Wahl. Mehr Punkte erhöhen den Speicherverbrauch und die Renderzeit, also wägen Sie Glätte gegen Leistung ab.

Fazit

numpy.linspace() ist aus gutem Grund eine der am häufigsten verwendeten NumPy-Funktionen: Sie gibt Ihnen präzise Kontrolle darüber, wie viele gleichmäßig verteilte Werte Sie zwischen zwei Endpunkten erzeugen. Im Gegensatz zu np.arange() überrascht sie Sie nie mit einem zusätzlichen oder fehlenden Element aufgrund von Gleitkomma-Rundungsfehlern. Die Parameter endpoint, retstep und dtype geben Ihnen feinkörnige Kontrolle für alles, von schnellen Plots bis zu Signalverarbeitungs-Pipelines.

Wichtige Erkenntnisse:

• Verwenden Sie num, um die exakte Anzahl der Ausgabewerte festzulegen.
• Setzen Sie endpoint=False für periodische Daten, bei denen der Stoppwert den Start duplizieren würde.
• Verwenden Sie retstep=True, wann immer Sie die Schrittweite für nachfolgende Berechnungen benötigen.
• Bevorzugen Sie linspace gegenüber arange für Gleitkomma-Intervalle.
• Kombinieren Sie linspace mit meshgrid für mehrdimensionale Gitter.

Mit diesen Mustern in Ihrem Werkzeugkasten können Sie selbstbewusst numerische Folgen für Plotten, Simulation, Interpolation und wissenschaftliches Rechnen in Python erzeugen.