NumPy Zeros: Mit Nullen gefuellte Arrays erstellen mit np.zeros()

Name

Soren Atelier

Updated on 10.2.2026

Das Initialisieren von Arrays mit Nullen ist eine der haeufigsten Operationen im numerischen Rechnen. Sie benoetigen vorab zugewiesene Arrays zum Ansammeln von Ergebnissen in Schleifen, mit Nullen aufgefuellte Matrizen fuer die Bildverarbeitung, Platzhalter-Tensoren fuer neuronale Netzwerkgewichte oder leere Gitter fuer den Simulationszustand. Die Verwendung von Python-Listen, die mit Nullen gefuellt sind, ist langsam und bietet nicht die mathematischen Operationen, die NumPy bereitstellt.

np.zeros() erstellt Arrays beliebiger Form, die mit Nullen gefuellt sind, unter Verwendung des von Ihnen angegebenen Datentyps. Es ist schnell, speichereffizient und die Standardmethode zur Initialisierung von Arrays in NumPy.

Grundlegende Verwendung

1D-Array

import numpy as np
 
# Ein 1D-Array mit 5 Nullen erstellen
a = np.zeros(5)
print(a)        # [0. 0. 0. 0. 0.]
print(a.dtype)  # float64 (default)
print(a.shape)  # (5,)

2D-Array (Matrix)

import numpy as np
 
# 3 Zeilen, 4 Spalten
matrix = np.zeros((3, 4))
print(matrix)
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]
print(matrix.shape)  # (3, 4)

3D-Array

import numpy as np
 
# 2 Schichten, 3 Zeilen, 4 Spalten
tensor = np.zeros((2, 3, 4))
print(tensor.shape)  # (2, 3, 4)
print(tensor.size)   # 24 elements total

Datentypen angeben

Der Standard-dtype ist float64. Verwenden Sie den Parameter dtype, um ihn zu aendern:

import numpy as np
 
# Ganzzahl-Nullen
int_zeros = np.zeros(5, dtype=int)
print(int_zeros)       # [0 0 0 0 0]
print(int_zeros.dtype) # int64
 
# Boolesche Nullen (False)
bool_zeros = np.zeros(5, dtype=bool)
print(bool_zeros)  # [False False False False False]
 
# Komplexe Nullen
complex_zeros = np.zeros(3, dtype=complex)
print(complex_zeros)  # [0.+0.j 0.+0.j 0.+0.j]
 
# 32-Bit Float (spart Speicher)
small_zeros = np.zeros((1000, 1000), dtype=np.float32)
print(f"Memory: {small_zeros.nbytes / 1024 / 1024:.1f} MB")  # ~3.8 MB vs 7.6 MB for float64

Gaengige Datentypen

np.zeros_like() -- Ein bestehendes Array abgleichen

Erstellen Sie ein Null-Array mit der gleichen Form und dem gleichen Datentyp wie ein anderes Array:

import numpy as np
 
original = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
 
# Gleiche Form und Datentyp
zeros_copy = np.zeros_like(original)
print(zeros_copy)
# [[0. 0. 0.]
#  [0. 0. 0.]]
print(zeros_copy.dtype)  # float32
print(zeros_copy.shape)  # (2, 3)
 
# Datentyp ueberschreiben
int_copy = np.zeros_like(original, dtype=int)
print(int_copy.dtype)  # int64

Verwandte Initialisierungsfunktionen

import numpy as np
 
# Einsen
print(np.ones((2, 3)))
# [[1. 1. 1.]
#  [1. 1. 1.]]
 
# Full (benutzerdefinierter Wert)
print(np.full((2, 3), 7))
# [[7 7 7]
#  [7 7 7]]
 
# Empty (nicht initialisiert -- schneller, aber enthaelt Muell)
empty = np.empty((2, 3))  # Contents unpredictable
 
# Einheitsmatrix
print(np.eye(3))
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

Praktische Anwendungsfaelle

Ergebnis-Arrays vorab zuweisen

import numpy as np
 
# Vorab zuweisen fuer Performance (vermeidet wiederholte Verkettung)
n_iterations = 1000
results = np.zeros(n_iterations)
 
for i in range(n_iterations):
    results[i] = np.random.randn() ** 2
 
print(f"Mean: {results.mean():.4f}")
print(f"Std:  {results.std():.4f}")

Konfusionsmatrix

import numpy as np
 
def confusion_matrix(y_true, y_pred, n_classes):
    """Build a confusion matrix from predictions."""
    cm = np.zeros((n_classes, n_classes), dtype=int)
    for true, pred in zip(y_true, y_pred):
        cm[true][pred] += 1
    return cm
 
y_true = [0, 1, 2, 0, 1, 2, 0, 0, 1, 2]
y_pred = [0, 1, 1, 0, 2, 2, 0, 1, 1, 0]
 
cm = confusion_matrix(y_true, y_pred, 3)
print(cm)
# [[3 1 0]
#  [0 2 1]
#  [1 0 2]]

Zero-Padding fuer Signalverarbeitung

import numpy as np
 
signal = np.array([1, 2, 3, 4, 5])
 
# Mit Nullen auf Laenge 16 auffuellen (Zweierpotenz fuer FFT)
padded = np.zeros(16)
padded[:len(signal)] = signal
print(padded)
# [1. 2. 3. 4. 5. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 
# Mit np.pad (flexibler)
padded2 = np.pad(signal, (0, 11), mode='constant', constant_values=0)
print(padded2)

Bildverarbeitung -- Zero-Padding

import numpy as np
 
# Originales 3x3 Bild
image = np.array([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])
 
# 1-Pixel Zero-Padding hinzufuegen
padded = np.zeros((5, 5), dtype=image.dtype)
padded[1:-1, 1:-1] = image
print(padded)
# [[0 0 0 0 0]
#  [0 1 2 3 0]
#  [0 4 5 6 0]
#  [0 7 8 9 0]
#  [0 0 0 0 0]]

Akkumulationsmuster

import numpy as np
 
# Zaehler in einem Histogramm akkumulieren
data = np.random.randint(0, 10, size=1000)
bins = np.zeros(10, dtype=int)
 
for value in data:
    bins[value] += 1
 
print("Histogram:")
for i, count in enumerate(bins):
    bar = '#' * (count // 5)
    print(f"  {i}: {bar} ({count})")

Null-Arrays in Jupyter erkunden

Beim Erstellen numerischer Algorithmen, die mit Nullen initialisierte Arrays verwenden, bietet RunCell (opens in a new tab) eine KI-gestuetzte Jupyter-Umgebung, in der Sie Array-Formen, Datentypen und Speicherverbrauch waehrend der Entwicklung interaktiv untersuchen koennen.

FAQ

Wie erstelle ich ein Array von Nullen in NumPy?

Verwenden Sie np.zeros(shape), wobei shape eine Ganzzahl fuer 1D oder ein Tupel fuer mehrdimensional ist. Zum Beispiel erstellt np.zeros(5) [0., 0., 0., 0., 0.] und np.zeros((3, 4)) erstellt eine 3x4-Matrix von Nullen. Der Standard-dtype ist float64.

Was ist der Unterschied zwischen np.zeros und np.empty?

np.zeros() initialisiert jedes Element mit Null. np.empty() reserviert Speicher ohne Initialisierung, sodass es enthaelt, was zuvor an dieser Speicherstelle war. np.empty() ist etwas schneller, aber nur sicher, wenn Sie jedes Element sofort fuellen, bevor Sie es lesen.

Wie erstelle ich Ganzzahl-Nullen statt Float-Nullen?

Uebergeben Sie dtype=int an np.zeros(): np.zeros(5, dtype=int) erstellt [0, 0, 0, 0, 0] mit dtype int64. Sie koennen auch spezifische Typen wie np.int32 oder np.int8 zur Speicherkontrolle verwenden.

Wie erstelle ich ein Null-Array mit der gleichen Form wie ein anderes Array?

Verwenden Sie np.zeros_like(existing_array). Dies kopiert die Form und den Datentyp des Eingabe-Arrays. Sie koennen den Datentyp mit np.zeros_like(arr, dtype=float) ueberschreiben.

Ist np.zeros() schneller als np.full(shape, 0)?

Ja, np.zeros() ist etwas schneller, da es eine optimierte Speicherzuweisung auf Betriebssystemebene (calloc) verwendet, die genullten Speicher direkt bereitstellt, waehrend np.full() Speicher zuweisen und dann fuellen muss. Fuer die meisten praktischen Zwecke ist der Unterschied vernachlaessigbar.

Fazit

np.zeros() ist die Standardmethode zum Erstellen von mit Nullen gefuellten Arrays in NumPy. Verwenden Sie es fuer Vorabzuweisung, Padding, Akkumulationsmuster und Initialisierung. Waehlen Sie np.zeros_like(), wenn Sie die Form eines bestehenden Arrays abgleichen muessen. Geben Sie dtype an, um den Speicherverbrauch zu kontrollieren -- float32 verwendet die Haelfte des Speichers von float64. Fuer Nicht-Null-Initialisierung verwenden Sie np.ones(), np.full() oder np.empty() je nach Bedarf.