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)

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,

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)

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