Skip to content

NumPy Zeros: Crear arrays rellenos de ceros con np.zeros()

Soren Atelier
Name
Soren Atelier

Updated on

Inicializar arrays con ceros es una de las operaciones mas comunes en la computacion numerica. Necesitas arrays preasignados para acumular resultados en bucles, matrices rellenadas con ceros para procesamiento de imagenes, tensores de marcador de posicion para pesos de redes neuronales o cuadriculas vacias para el estado de simulacion. Usar listas de Python llenas de ceros es lento y carece de las operaciones matematicas que proporciona NumPy.

np.zeros() crea arrays de cualquier forma llenos de ceros, usando el tipo de datos que especifiques. Es rapido, eficiente en memoria y la forma estandar de inicializar arrays en NumPy.

📚

    Uso basico

    Array 1D

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

    Array 2D (Matriz)

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

    Array 3D

    import numpy as np
 
# 2 capas, 3 filas, 4 columnas
tensor = np.zeros((2, 3, 4))
print(tensor.shape)  # (2, 3, 4)
print(tensor.size)   # 24 elements total

    Especificar tipos de datos

    El dtype predeterminado es float64. Usa el parametro dtype para cambiarlo:

    import numpy as np
 
# Ceros enteros
int_zeros = np.zeros(5, dtype=int)
print(int_zeros)       # [0 0 0 0 0]
print(int_zeros.dtype) # int64
 
# Ceros booleanos (False)
bool_zeros = np.zeros(5, dtype=bool)
print(bool_zeros)  # [False False False False False]
 
# Ceros complejos
complex_zeros = np.zeros(3, dtype=complex)
print(complex_zeros)  # [0.+0.j 0.+0.j 0.+0.j]
 
# Float de 32 bits (ahorra memoria)
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

    Tipos de datos comunes

    dtypeDescripcionLos ceros se ven comoMemoria por elemento
    float64Float de 64 bits (predeterminado)0.8 bytes
    float32Float de 32 bits0.4 bytes
    int64Entero de 64 bits08 bytes
    int32Entero de 32 bits04 bytes
    boolBooleanoFalse1 byte
    complex128Complejo de 128 bits0.+0.j16 bytes

    np.zeros_like() -- Coincidir con un array existente

    Crea un array de ceros con la misma forma y dtype que otro array:

    import numpy as np
 
original = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
 
# Misma forma y 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)
 
# Anular dtype
int_copy = np.zeros_like(original, dtype=int)
print(int_copy.dtype)  # int64

    Funciones de inicializacion relacionadas

    FuncionCreaCaso de uso
    np.zeros(shape)Todos cerosInicializacion predeterminada
    np.ones(shape)Todos unosIdentidad multiplicativa, mascaras
    np.full(shape, value)Mismo valorValor de relleno personalizado
    np.empty(shape)No inicializadoRendimiento (cuando se llena inmediatamente)
    np.eye(n)Matriz identidadAlgebra lineal
    np.zeros_like(arr)Ceros que coinciden con otro arrayArrays de resultado que coinciden con la entrada
    import numpy as np
 
# Unos
print(np.ones((2, 3)))
# [[1. 1. 1.]
#  [1. 1. 1.]]
 
# Full (valor personalizado)
print(np.full((2, 3), 7))
# [[7 7 7]
#  [7 7 7]]
 
# Empty (no inicializado -- mas rapido pero contiene basura)
empty = np.empty((2, 3))  # Contents unpredictable
 
# Matriz identidad
print(np.eye(3))
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

    Casos de uso practicos

    Preasignar arrays de resultados

    import numpy as np
 
# Preasignar para rendimiento (evita concatenacion repetida)
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}")

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

    Relleno con ceros para procesamiento de senales

    import numpy as np
 
signal = np.array([1, 2, 3, 4, 5])
 
# Rellenar con ceros hasta longitud 16 (potencia de 2 para 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.]
 
# Usando np.pad (mas flexible)
padded2 = np.pad(signal, (0, 11), mode='constant', constant_values=0)
print(padded2)

    Procesamiento de imagenes -- Relleno con ceros

    import numpy as np
 
# Imagen original 3x3
image = np.array([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])
 
# Agregar relleno de ceros 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]]

    Patron de acumulacion

    import numpy as np
 
# Acumular conteos en un histograma
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})")

    Explorar arrays de ceros en Jupyter

    Al construir algoritmos numericos que usan arrays inicializados con ceros, RunCell (opens in a new tab) proporciona un entorno Jupyter con IA donde puedes inspeccionar formas de arrays, dtypes y uso de memoria de forma interactiva mientras desarrollas.

    FAQ

    Como creo un array de ceros en NumPy?

    Usa np.zeros(shape) donde shape es un entero para 1D o una tupla para multidimensional. Por ejemplo, np.zeros(5) crea [0., 0., 0., 0., 0.] y np.zeros((3, 4)) crea una matriz 3x4 de ceros. El dtype predeterminado es float64.

    Cual es la diferencia entre np.zeros y np.empty?

    np.zeros() inicializa cada elemento a cero. np.empty() asigna memoria sin inicializacion, asi que contiene lo que estaba previamente en esa ubicacion de memoria. np.empty() es ligeramente mas rapido pero solo seguro cuando llenaras cada elemento inmediatamente antes de leer.

    Como creo ceros enteros en lugar de ceros flotantes?

    Pasa dtype=int a np.zeros(): np.zeros(5, dtype=int) crea [0, 0, 0, 0, 0] con dtype int64. Tambien puedes usar tipos especificos como np.int32 o np.int8 para control de memoria.

    Como creo un array de ceros con la misma forma que otro array?

    Usa np.zeros_like(existing_array). Esto copia la forma y dtype del array de entrada. Puedes anular el dtype con np.zeros_like(arr, dtype=float).

    Es np.zeros() mas rapido que np.full(shape, 0)?

    Si, np.zeros() es ligeramente mas rapido porque usa asignacion de memoria optimizada a nivel de sistema operativo (calloc) que proporciona memoria con ceros directamente, mientras que np.full() debe asignar y luego llenar. Para la mayoria de propositos practicos, la diferencia es insignificante.

    Conclusion

    np.zeros() es la forma estandar de crear arrays rellenos de ceros en NumPy. Usalo para preasignacion, relleno, patrones de acumulacion e inicializacion. Elige np.zeros_like() cuando necesites coincidir con la forma de un array existente. Especifica dtype para controlar el uso de memoria -- float32 usa la mitad de memoria que float64. Para inicializacion distinta de cero, usa np.ones(), np.full() o np.empty() segun tus necesidades.

    📚