Skip to content

NumPy Zeros: Criar arrays preenchidos com zeros usando np.zeros()

Soren Atelier
Name
Soren Atelier

Updated on

Inicializar arrays com zeros e uma das operacoes mais comuns na computacao numerica. Voce precisa de arrays pre-alocados para acumular resultados em loops, matrizes preenchidas com zeros para processamento de imagens, tensores de marcacao para pesos de redes neurais ou grades vazias para estado de simulacao. Usar listas Python preenchidas com zeros e lento e nao possui as operacoes matematicas que o NumPy fornece.

np.zeros() cria arrays de qualquer forma preenchidos com zeros, usando o tipo de dados que voce especificar. E rapido, eficiente em memoria e a forma padrao de inicializar arrays no NumPy.

📚

    Uso basico

    Array 1D

    import numpy as np
 
# Criar um array 1D de 5 zeros
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 linhas, 4 colunas
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 camadas, 3 linhas, 4 colunas
tensor = np.zeros((2, 3, 4))
print(tensor.shape)  # (2, 3, 4)
print(tensor.size)   # 24 elements total

    Especificando tipos de dados

    O dtype padrao e float64. Use o parametro dtype para alterar:

    import numpy as np
 
# Zeros inteiros
int_zeros = np.zeros(5, dtype=int)
print(int_zeros)       # [0 0 0 0 0]
print(int_zeros.dtype) # int64
 
# Zeros booleanos (False)
bool_zeros = np.zeros(5, dtype=bool)
print(bool_zeros)  # [False False False False False]
 
# Zeros complexos
complex_zeros = np.zeros(3, dtype=complex)
print(complex_zeros)  # [0.+0.j 0.+0.j 0.+0.j]
 
# Float de 32 bits (economiza 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 dados comuns

    dtypeDescricaoZeros parecem comMemoria por elemento
    float64Float de 64 bits (padrao)0.8 bytes
    float32Float de 32 bits0.4 bytes
    int64Inteiro de 64 bits08 bytes
    int32Inteiro de 32 bits04 bytes
    boolBooleanoFalse1 byte
    complex128Complexo de 128 bits0.+0.j16 bytes

    np.zeros_like() -- Corresponder a um array existente

    Crie um array de zeros com a mesma forma e dtype de outro array:

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

    Funcoes de inicializacao relacionadas

    FuncaoCriaCaso de uso
    np.zeros(shape)Todos zerosInicializacao padrao
    np.ones(shape)Todos unsIdentidade multiplicativa, mascaras
    np.full(shape, value)Mesmo valorValor de preenchimento personalizado
    np.empty(shape)Nao inicializadoPerformance (quando preenchido imediatamente)
    np.eye(n)Matriz identidadeAlgebra linear
    np.zeros_like(arr)Zeros correspondendo a outro arrayArrays de resultado correspondendo a entrada
    import numpy as np
 
# Uns
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 (nao inicializado -- mais rapido mas contem lixo)
empty = np.empty((2, 3))  # Contents unpredictable
 
# Matriz identidade
print(np.eye(3))
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

    Casos de uso praticos

    Pre-alocar arrays de resultados

    import numpy as np
 
# Pre-alocar para performance (evita concatenacao 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 confusao

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

    Preenchimento com zeros para processamento de sinais

    import numpy as np
 
signal = np.array([1, 2, 3, 4, 5])
 
# Preencher com zeros ate comprimento 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 (mais flexivel)
padded2 = np.pad(signal, (0, 11), mode='constant', constant_values=0)
print(padded2)

    Processamento de imagens -- Preenchimento com zeros

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

    Padrao de acumulacao

    import numpy as np
 
# Acumular contagens em um 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 zeros no Jupyter

    Ao construir algoritmos numericos que usam arrays inicializados com zeros, RunCell (opens in a new tab) fornece um ambiente Jupyter com IA onde voce pode inspecionar formas de arrays, dtypes e uso de memoria interativamente enquanto desenvolve.

    FAQ

    Como criar um array de zeros no NumPy?

    Use np.zeros(shape) onde shape e um inteiro para 1D ou uma tupla para multidimensional. Por exemplo, np.zeros(5) cria [0., 0., 0., 0., 0.] e np.zeros((3, 4)) cria uma matriz 3x4 de zeros. O dtype padrao e float64.

    Qual e a diferenca entre np.zeros e np.empty?

    np.zeros() inicializa cada elemento com zero. np.empty() aloca memoria sem inicializacao, entao contem o que estava anteriormente naquele local de memoria. np.empty() e ligeiramente mais rapido mas so seguro quando voce preenchera cada elemento imediatamente antes de ler.

    Como criar zeros inteiros em vez de zeros de ponto flutuante?

    Passe dtype=int para np.zeros(): np.zeros(5, dtype=int) cria [0, 0, 0, 0, 0] com dtype int64. Voce tambem pode usar tipos especificos como np.int32 ou np.int8 para controle de memoria.

    Como criar um array de zeros com a mesma forma de outro array?

    Use np.zeros_like(existing_array). Isso copia a forma e o dtype do array de entrada. Voce pode substituir o dtype com np.zeros_like(arr, dtype=float).

    np.zeros() e mais rapido que np.full(shape, 0)?

    Sim, np.zeros() e ligeiramente mais rapido porque usa alocacao de memoria otimizada a nivel do sistema operacional (calloc) que fornece memoria zerada diretamente, enquanto np.full() deve alocar e depois preencher. Para a maioria dos propositos praticos, a diferenca e insignificante.

    Conclusao

    np.zeros() e a forma padrao de criar arrays preenchidos com zeros no NumPy. Use-o para pre-alocacao, preenchimento, padroes de acumulacao e inicializacao. Escolha np.zeros_like() quando precisar corresponder a forma de um array existente. Especifique dtype para controlar o uso de memoria -- float32 usa metade da memoria de float64. Para inicializacao diferente de zero, use np.ones(), np.full() ou np.empty() conforme suas necessidades.

    📚