Numpy Tutorial - Criação do NumPy Array

  1. Arrays de Zeros
  2. Sobre o Array
  3. Diagonal Array
  4. Triangular Array

Arrays de Zeros

np.zeros

O np.zeros é utilizado para criar o array de que todos os elementos são 0. Sua sintaxe é,

np.zeros(shape, dtype=float, order='C')

Onde,

A shape é o tamanho do array, e pode ser 1-D, 2-D ou múltiplas dimensões.

O dtype é float64 por padrão, mas pode ser atribuído com qualquer tipo de dado em numpy.

Vamos criar algumas arrays de zeros

>>> import numpy as np
>>> np.zeros(5)		# it creates a 1D array with 5 zeros
array([0., 0., 0., 0., 0.])
>>> np.zeros(5, dtype='int8')	# it creates a 1D array with 5 zeros with the data type of int8
array([0, 0, 0, 0, 0], dtype=int8)
>>> np.zeros((4, 3)) # it creates a 4x3 zeros array
array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

np.empty

Em alguns casos, você só quer inicializar um array com a forma especificada e você não se importa com os dados de inicialização dentro dele. Você pode utilizar np.empty para obter uma inicialização mais rápida, mas tenha em mente que isso não garante que o valor do array criado seja 0.

Nós poderíamos utilizar %timeit para comparar o tempo de execução de np.empty() e np.zeros(),

In [1]: %timeit np.empty((100, 100))
    715 ns ± 11.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [2]: %timeit np.zeros((100, 100))
    4.03 µs ± 104 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Obviamente, np.empty() é muito mais rápido que np.zeros() na inicialização. Leva apenas cerca de 17,5% do tempo necessário para np.zeros() inicializar um array com a forma de (100, 100).

np.zeros_like

Suponha que já temos um array e queremos criar um array de zeros que tenha a mesma forma. Poderíamos usar a forma tradicional para criar este novo array.

test = np.array([[1,2,3],[4,5,6],[7,8,9]])
np.zeros(test.shape)

Ou poderíamos utilizar o método dedicado - np.zeros_like() para criar o novo array de forma mais eficiente.

x = np.zeros_like(test)
Atenção

O array criado por np.zeros_like() não tem apenas a mesma forma com o array dado, mas também o mesmo tipo de dados que ele.

Sobre o Array

np.ones

Semelhante a zeros, nós também poderíamos criar o array cheio de zeros. A sintaxe e os parâmetros de np.ones() são idênticos a np.zeros().

>>> import numpy as np
>>> np.ones(5)		# it creates a 1-D array with 5 ones
array([1., 1., 1., 1., 1.])
>>> np.ones(5, dtype='int8')	# it creates a 1-D array with 5 ones, and its data type is int8
array([1, 1, 1, 1, 1], dtype=int8)
>>> np.ones((4, 3)) # it creates an array of (4, 3) shape
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

np.ones_like

Similar ao np.zeros_like, np.ones_like poderia ser utilizado para criar um novo array com a mesma forma do array dado.

>>> test = np.array([[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]])
>>> np.ones_like(test)
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

Diagonal Array

A matriz diagonal é a matriz 2-D com uns na diagonal e zeros em outros lugares. Ele poderia ser criado com o método np.eye() cuja sintaxe é,

np.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')

Onde,

parâmetro tipo de dado Sumário
N INT Especifica o número de filas na matriz gerada.
M INT (Opcional) O padrão é None. Especifica o número de colunas na matriz a ser gerada. Quando é None, é igual a N.
k INT (Opcional) O padrão é 0. 0 é a posição diagonal principal. Se k for positivo, cria a diagonal superior com o deslocamento de k; se k for negativo, cria a diagonal inferior com o deslocamento de -k.
dtype. tipo de dado (Opcional) O valor padrão é float. Ele especifica o tipo de dados do elemento do array criado.

np.eye() Exemplo

>>> import numpy as np
>>> np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> np.eye(4, 3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.]])
>>> np.eye(3, 4)
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.]])
>>> np.eye(4, k=1)
array([[0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.],
       [0., 0., 0., 0.]])

np.identity()

O np.identity pode ser tratado como especial np.eye porque cria um array quadrada na diagonal com as diagonais na diagonal principal.

numpy.identity(n, dtype = float)
parâmetro tipo de dado Descrição
n INT Especifica o tamanho do array a ser gerada. Cria um array quadrada N×N.
dtype. tipo de dado (Opcional) O padrão é flutuar. Ele especifica o tipo de dados do elemento.

np.identity() Exemplos

>>> import numpy as np
>>> np.identity(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

Triangular Array

Você poderia utilizar np.tri() para criar um array triangular. Sua sintaxe é,

numpy.tri(N, M=None, k=0, dtype=<class 'float'>)

Seus parâmetros de entrada são similares a np.eye().

np.tri() Exemplos

>>> import numpy as np
>>> np.tri(3)
array([[1., 0., 0.],
       [1., 1., 0.],
       [1., 1., 1.]])
>>> np.tri(4, k=1)
array([[1., 1., 0., 0.],
       [1., 1., 1., 0.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])