NumPy Array Creation

Zeros Array

np.zeros

np.zeros is used to create the array that all the elements is 0. Its syntax is,

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

Where,

shape is the size of the matrix, and it could be 1-D, 2-D or multiple dimensions.

dtype is float64 by default, but could be assigned with any data type in numpy.

Let’s create some zeros arrays

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

In some cases, you only want to initialize an array with the specified shape and u don’t care about the initialization data inside. You can use np.empty to achieve faster initialization, but keep in mind that it does not guarantee the value of created array is 0.

We could use %timeit to compare the execution time of np.empty() and 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)

Obviously, np.empty() is much faster than np.zeros() in initialization. It takes only about 17.5% of time needed for np.zeros() to initialize an array with the shape of (100, 100).

np.zeros_like

Suppose we already have an array and want to create a zeros array that has the same shape. We could use the traditional way to create this new array.

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

Or we could use the dedicated method - np.zeros_like() to create the new array more efficiently.

x = np.zeros_like(test)
Attention
The array created by np.zeros_like() has not only the same shape with the given array but also the same data type as it.

Ones Array

np.ones

Similar to zeros, we could also create the array filled with ones. The syntax and parameters of np.ones() are identical to 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 to np.zeros_like, np.ones_like could be used to create a new array of ones with the same shape as given array.

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

Diagonal array is the 2-D array with ones on the diagonal and zeros elsewhere. It could be created with np.eye() method whose syntax is,

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

Where,

parameter type of data Summary
N INT Specifies the number of rows in the generated matrix.
M INT (Optional) The default is None. Specifies the number of columns in the matrix to be generated. When it is None, it is equal to N.
k INT (Optional) The default is 0. 0 is the main diagonal position. If k is positive, it creates upper diagonal with the displacement of k; if k is negative, it creates lower diagonal with the displacement of -k.
dtype type of data (Optional) The default value is float. It specifies the data type of the element of the created array.

np.eye() Example

>>> 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()

np.identitycould be treated as special np.eye because it creates a square diagonal array with ones on the main diagonal.

numpy.identity(n, dtype = float)
parameter type of data Description
n INT Specifies the size of the matrix to be generated. It creates an N×N square array.
dtype type of data (Optional) The default is float. It specifies the data type of the element.

np.identity() Examples

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

Triangular Array

You could use np.tri() to create a triangular array. Its syntax is,

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

Its input parameters are similar to np.eye().

np.tri() Examples

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