NumPy Zeros : Creer des tableaux remplis de zeros avec np.zeros()

Name

Soren Atelier

Updated on 10/02/2026

Initialiser des tableaux avec des zeros est l'une des operations les plus courantes en calcul numerique. Vous avez besoin de tableaux pre-alloues pour accumuler des resultats dans des boucles, de matrices remplies de zeros pour le traitement d'images, de tenseurs de remplacement pour les poids de reseaux neuronaux, ou de grilles vides pour l'etat de simulation. Utiliser des listes Python remplies de zeros est lent et ne dispose pas des operations mathematiques fournies par NumPy.

np.zeros() cree des tableaux de n'importe quelle forme remplis de zeros, en utilisant le type de donnees que vous specifiez. C'est rapide, efficace en memoire et la methode standard pour initialiser des tableaux dans NumPy.

Utilisation de base

Tableau 1D

import numpy as np
 
# Creer un tableau 1D de 5 zeros
a = np.zeros(5)
print(a)        # [0. 0. 0. 0. 0.]
print(a.dtype)  # float64 (default)
print(a.shape)  # (5,)

Tableau 2D (Matrice)

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

Tableau 3D

import numpy as np
 
# 2 couches, 3 lignes, 4 colonnes
tensor = np.zeros((2, 3, 4))
print(tensor.shape)  # (2, 3, 4)
print(tensor.size)   # 24 elements total

Specifier les types de donnees

Le dtype par defaut est float64. Utilisez le parametre dtype pour le changer :

import numpy as np
 
# Zeros entiers
int_zeros = np.zeros(5, dtype=int)
print(int_zeros)       # [0 0 0 0 0]
print(int_zeros.dtype) # int64
 
# Zeros booleens (False)
bool_zeros = np.zeros(5, dtype=bool)
print(bool_zeros)  # [False False False False False]
 
# Zeros complexes
complex_zeros = np.zeros(3, dtype=complex)
print(complex_zeros)  # [0.+0.j 0.+0.j 0.+0.j]
 
# Float 32 bits (economise la memoire)
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

Types de donnees courants

np.zeros_like() -- Correspondre a un tableau existant

Creez un tableau de zeros avec la meme forme et le meme dtype qu'un autre tableau :

import numpy as np
 
original = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
 
# Meme forme et dtype
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)
 
# Remplacer le dtype
int_copy = np.zeros_like(original, dtype=int)
print(int_copy.dtype)  # int64

Fonctions d'initialisation associees

import numpy as np
 
# Uns
print(np.ones((2, 3)))
# [[1. 1. 1.]
#  [1. 1. 1.]]
 
# Full (valeur personnalisee)
print(np.full((2, 3), 7))
# [[7 7 7]
#  [7 7 7]]
 
# Empty (non initialise -- plus rapide mais contient des dechets)
empty = np.empty((2, 3))  # Contents unpredictable
 
# Matrice identite
print(np.eye(3))
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

Cas d'utilisation pratiques

Pre-allouer les tableaux de resultats

import numpy as np
 
# Pre-allouer pour la performance (evite la concatenation repetee)
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}")

Matrice de confusion

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

Remplissage avec des zeros pour le traitement du signal

import numpy as np
 
signal = np.array([1, 2, 3, 4, 5])
 
# Remplir avec des zeros jusqu'a la longueur 16 (puissance de 2 pour 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.]
 
# En utilisant np.pad (plus flexible)
padded2 = np.pad(signal, (0, 11), mode='constant', constant_values=0)
print(padded2)

Traitement d'images -- Remplissage avec des zeros

import numpy as np
 
# Image originale 3x3
image = np.array([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])
 
# Ajouter un remplissage de zeros de 1 pixel
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]]

Modele d'accumulation

import numpy as np
 
# Accumuler des comptages dans un histogramme
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})")

Explorer les tableaux de zeros dans Jupyter

Lors de la construction d'algorithmes numeriques utilisant des tableaux initialises a zero, RunCell (opens in a new tab) fournit un environnement Jupyter alimente par l'IA ou vous pouvez inspecter les formes de tableaux, les dtypes et l'utilisation memoire de maniere interactive pendant le developpement.

FAQ

Comment creer un tableau de zeros dans NumPy ?

Utilisez np.zeros(shape) ou shape est un entier pour 1D ou un tuple pour multidimensionnel. Par exemple, np.zeros(5) cree [0., 0., 0., 0., 0.] et np.zeros((3, 4)) cree une matrice 3x4 de zeros. Le dtype par defaut est float64.

Quelle est la difference entre np.zeros et np.empty ?

np.zeros() initialise chaque element a zero. np.empty() alloue de la memoire sans initialisation, donc il contient ce qui etait precedemment a cet emplacement memoire. np.empty() est legerement plus rapide mais uniquement sur quand vous remplirez chaque element immediatement avant de le lire.

Comment creer des zeros entiers au lieu de zeros flottants ?

Passez dtype=int a np.zeros() : np.zeros(5, dtype=int) cree [0, 0, 0, 0, 0] avec dtype int64. Vous pouvez aussi utiliser des types specifiques comme np.int32 ou np.int8 pour le controle memoire.

Comment creer un tableau de zeros avec la meme forme qu'un autre tableau ?

Utilisez np.zeros_like(existing_array). Cela copie la forme et le dtype du tableau d'entree. Vous pouvez remplacer le dtype avec np.zeros_like(arr, dtype=float).

np.zeros() est-il plus rapide que np.full(shape, 0) ?

Oui, np.zeros() est legerement plus rapide car il utilise une allocation memoire optimisee au niveau du systeme d'exploitation (calloc) qui fournit directement de la memoire mise a zero, tandis que np.full() doit allouer puis remplir. Pour la plupart des usages pratiques, la difference est negligeable.

Conclusion

np.zeros() est la methode standard pour creer des tableaux remplis de zeros dans NumPy. Utilisez-le pour la pre-allocation, le remplissage, les modeles d'accumulation et l'initialisation. Choisissez np.zeros_like() quand vous devez correspondre a la forme d'un tableau existant. Specifiez dtype pour controler l'utilisation memoire -- float32 utilise la moitie de la memoire de float64. Pour une initialisation non nulle, utilisez np.ones(), np.full() ou np.empty() selon vos besoins.