ndarray- An n-dimensional array of homogeneous data types

n-dimensional array ndarray.ndim and Axes

The dimension of an array refers to the number of axes (or dimensions) in the array.

n-dimensional array ndarray object has many attributes (discussed in the next section).  One of these attributes is ndim (ndarray.ndim).

ndim attribute specifies the number of axes (dimensions) of the array. Each axis corresponds to a dimension in the array and is associated with a specific dimension of the array.

What are Axes in NumPy

Below are the axes of different NumPy arrays:

1D Array: A 1-D Array is a list of numbers.  It has one axis.

Example 1: an array of shape (4,) has one axis with four elements. Example 2: an array of shape (3,) has one axis with three elements

Note: The shape attribute is discussed in later in this page.

A 2-D Array is a matrix of rows and columns. It has 2 axes.

For example, an array of shape (3, 4) has:

• Axis 0: Rows (3 elements)
• Axis 1: Columns (4 elements)

More information on Axes is at the link below:

https://numpy.org/doc/stable/glossary.html#term-axis

3-D Array: A 3-D array is a matrix of matrices. It has 3 axes. (Imagine a 3-D array as a cube with array elements along the x, y, and z co-ordinates).

For example, an array of shape (2, 3, 4) has:

• Axis 0: Depth (2 elements)
• Axis 1: Rows (3 elements)
• Axis 2: Columns (4 elements)

The Table below relates the array’s dimension to its axis.

Table of Axes for Different Types of Arrays

Overview of ndarray Attributes

NumPy’s ndarray (n-dimensional array) has several key attributes that provide important information about the structure of arrays, such as their dimensions, shape, data type and size, which are crucial for understanding and manipulating data effectively.

Key Attributes

Attribute	Description
ndarray.ndim	ndim: the number of axes (dimensions) of the array. (see table below). ndim tells us the dimensionality of the NumPy array. The number of dimensions can be thought of as the number of distinct “axes”.
ndarray.shape	Attribute shape returns a tuple containing the number of elements in each dimension. shape is a tuple of integers indicating the size of the array in each dimension. For a 2-D arrow with n rows and m columns, the shape will be (n,m). The length of the shape tuple is therefore the number of axes, ndim. A tuple representing the size of each dimension. For example, a shape of (3, 4) indicates 3 rows and 4 columns. (See table below).
ndarray.size	size tells us the  total number of elements of the array. This is equal to the product of the elements of shape ( n*m).  The total number of elements in the array is calculated as the product of the sizes of all dimensions. See table below.
ndarray.dtype	dtype object describes the type of the elements in the array, which defines the type of data stored (e.g., integers, floats).

For details of ndarray attributes, click on the link below.

https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html

NumPy provides several dtypes, in addition to the ones in Python. You can create arrays by specifying standard Python dtypes or the NumPy dtypes.

Some of NumPy dtypes are listed below:

• numpy.int32
• numpy.int16
• numpy.float64

ndarray.itemsize

Attribute itemsize is the size of each element of the array in bytes.

For example, type numpy.float64 element has itemsize 8 (=64/8), while the  type numpy.complex32 has itemsize 4 (=32/8).

It is equivalent to ndarray.dtype.itemsize.

The table below shows details of ndim Attributes:

n-dimensional array Attributes

Array Type	Array Example	# of Axis	ndim	# of Elements Array.size	shape
Scalar	Single value np.array(5)	0	0		()
1-D Array	[1 2 6 8]	1	1	4	(4,)
2-D Array	[[1 2]   [4 9]   [5 6]]	2	2	6	(3, 2)
3-D Array	[[[ 1 2] [ 3 4] [10 11]] [[ 5 6] [ 8 9] [12 13]]]	3	3	12	(2, 3, 2)

Program Example: ndim, shape, size, dtype of 1-D and 2-D Arrays

The following few program examples show how to find various attributes of 1-D and 2-D ndarray.

print("Program Name: ndim_shape_size_dtype.py \n")
import numpy as np
#Array 1D
array1d = np.array([1, 2, 6, 8])
print("array1d is \n", array1d)
print("ndim of array1d is : ", array1d.ndim)
print("shape of array1d is : ", array1d.shape)
print("size of array1d is : ",array1d.size)
print("dtype of array1d is :",array1d.dtype)
print()
#
# Array 2D
array2d = np.array([[1, 2], [4, 9], [5, 6]])
print("array2d is : \n", array2d)
print()
print("ndim of array2d is : ", array2d.ndim)
print("shape of array2d is : ", array2d.shape)
print("size of array2d is : ",array2d.size)
print("dtype of array2d is :",array2d.dtype)
print()

The following is the program’s output of 1-D and 2-D ndarray attributes:

Program Example: ndim, shape, size, dtype of Float Type and Complex Type Arrays

# ndarray attributes of Array Float type and Array Complex type
import numpy as np
array2df= np.array([[1.1, 2], [4, 9], [5, 6]])
print("2-D array2df is: \n ", array2df)
print()
print("dtype of 2-D array2df is:\n",array2df.dtype)
print()
print("Specify dtype while creating an floating-point array. \n")
#
array2df1 = np.array([[1, 2], [4, 9], [5, 6]],dtype = float)
print("2-D array2df1 is:\n ", array2df1)
print()
print("dtype of array2df1 is: \n",array2df1.dtype)

print("----- End of 2-D float array section ------ \n")
# Array Complex
array2dcomp= np.array([[1+1j, 2], [4, 9], [5, 6]])
print("2-D Complex array array2dcomp is: \n ", array2dcomp)
print()
print("dtype of array2dcomp is: \n",array2dcomp.dtype)
print()
print("Create another 2D Complex array by specifying dtype \n")
array2dc= np.array([[1, 2], [4, 9], [5, 6]],dtype = complex)
print("2-D complex array array2dc is : \n ", array2dc)
print()
print("dtype of 2-D complex array array2dc is :",array2dc.dtype)

The following is the programs’s output:

Program Example: ndim, shape, size, dtype of 3_D Array(3)

# Array attributes of 3D array
import numpy as np
array3d = np.array([[[1, 2], [3, 4], [10, 11]], [[5, 6], [8, 9], [12, 13]]])
print("array3d is : \n ", array3d)
print()
print("ndim of array3d is : ", array3d.ndim)
print("shape of array3d is : ", array3d.shape)
print("size of array3d is : ",array3d.size)
print("dtype of array3d is :",array3d.dtype)
print()

The following is the output of the 3-D array attributes program:

The following program prints the ndarray attributes for floting-point and complex numbers data types.

# ndarray attributes of Array Float type and Array Complex type
import numpy as np
array2df= np.array([[1.1, 2], [4, 9], [5, 6]])
print("2-D array2df is: \n ", array2df)
print()
print("dtype of 2-D array2df is:\n",array2df.dtype)
print()
print("Specify dtype while creating an floating-point array. \n")
#
array2df1 = np.array([[1, 2], [4, 9], [5, 6]],dtype = float)
print("2-D array2df1 is:\n ", array2df1)
print()
print("dtype of array2df1 is: \n",array2df1.dtype)

print("----- End of 2-D float array section ------ \n")
# Array Complex
array2dcomp= np.array([[1+1j, 2], [4, 9], [5, 6]])
print("2-D Complex array array2dcomp is: \n ", array2dcomp)
print()
print("dtype of array2dcomp is: \n",array2dcomp.dtype)
print()
print("Create another 2D Complex array by specifying dtype \n")
array2dc= np.array([[1, 2], [4, 9], [5, 6]],dtype = complex)
print("2-D complex array array2dc is : \n ", array2dc)
print()
print("dtype of 2-D complex array array2dc is :",array2dc.dtype)

The following is the floating-point and complex number program’s output:

Array Creation Functions

NumPy offers several functions to create arrays with initial placeholder content.

Some of these functions are listed in the table below:

Table: Array Creation Functions

FUNCTION	DESCRIPTION
Function zeros	The function zeros creates an array full of zeros.
Function ones	The function ones creates an array full of ones.
Function empty	The function empty creates an array whose initial content is random and depends on the state of the memory.
Numpy.arrange	This function creates a sequences of evenly spaced values within a specified range.
Numpy.linspace	This function creates arrays with a specified number of elements in the array, and spaced equally between the specified beginning and end values
Numpy.identity	The NumPy identity array is a square matrix with ones on the main diagonal and zeros elsewhere.

These functions are further described below:

Numpy.arange Function

The numpy.arange() function creates an array of evenly spaced values within a specified range.

Numpy.arange() can handle both integer and floating-point numbers. It allows negative steps to generate descending sequences.

Uses: This function is used for generating sequences for loops and mathematical calculations.

For details of the arange() function, click on the link below:

https://numpy.org/doc/stable/reference/generated/numpy.arange.html

numpy.arange() function Usage Examples

Example Description	Code Example	Result
Basic integer sequence	np.arange(5)	[0, 1, 2, 3, 4]
Custom range with start and stop	np.arange(2, 10)	[2, 3, 4, 5, 6, 7, 8, 9]
Stepped sequence	np.arange(0, 20, 3)	[0, 3, 6, 9, 12, 15, 18]
Floating-point sequence	np.arange(1.0, 5.0, 0.5)	[1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]
Descending sequence	np.arange(10, 2, -2)	[10, 8, 6, 4]

Numpy.arange() syntax:

Array1 = np.array([start], stop [, step], dtype = none)

Parameters:

The program below uses the reshape() function, which is discussed in a later section.

Program Example: numpy.arange() Function

print("Program Name: numpy_arange.py \n")
import numpy as np
print("Examples of arange() function usage. \n")
# arange() Function programs
# Create a 1-D array of 5 elements evenly spaced by 3
array1d = np.arange(0, 15, 3)
print("1-D array of 5 elements between 0 and 15 spaced by 3 is : \n" , array1d)
print()
# Create a 1-D array between 2 and 20 evenly spaced by 6
array1d1 = np.arange(2, 20, 6)
print("1-D array starting from 2 to 20 spaced by 6 is : \n" , array1d1)
print()
# Create a 2D array of 20 elements using arange() function
array2d = np.arange(20).reshape(4, 5)
print("2-D 4X5 array of 20 elements spaced evenly by 1 is : \n", array2d)
print()
# Create a 2D 3X5 array using arange() function
array2d1 = np.arange(0, 45, 3).reshape(3, 5)
print("2-D 3X5 array of 15 elements spaced evenly by 3 is : \n", array2d1)

The following is the arange() program’s output:

Numpy.linspace Function

Numpy.linspace() function creates arrays with a specified number of elements in the array, and spaced equally between the specified beginning and end values. NumPy will calculate the spacing between the numbers automatically.

The linspace() function provides precise control over numerical ranges.

For more details refer to the link below.

https://numpy.org/doc/stable/reference/generated/numpy.linspace.html

Return value:

linspace() function returns num evenly spaced numbers over a specified interval calculated over the interval [start, stop].

Syntax of linspace():

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0, *, device=None)

Keyword Arguments:

Usage Example of linspace() function:

Example Code	Output
np.linspace(0, 10, 5)	[ 0. 2.5 5. 7.5 10.]
np.linspace(0, 10, 4, endpoint=False)	[0. 3.33333333 6.66666667]
np.linspace(0, 10, 5, retstep=True)	(array([ 0. , 2.5, 5. , 7.5, 10. ]), 2.5)

The following program shows the functionality of the linspace() function.

Program Example: numpy.linspace() Function

print("PROGRAM NAME: numpy_linspace.py \n")
import numpy as np
print("Examples of linspace() programs \n")
# create a 1-D array of 5 evenly spaced numbers from 0 to 1
array1d = np.linspace(0, 1, 5)
print("1-D array of 5 evenly spaced elements between 0 and 1 is: \n", array1d)  
print()
#
# Create a 1-D array of 10 elements between 0 and 10
array1d1 = np.linspace(0, 10, num = 10, endpoint = False)
print("1-D array of 10 evenly-spaced elements between o and 10 is: \n", array1d1)
print()

# Create a 1-D array of 50 elements between 0 and 10.
# without parameter num, with endpoint=False, and retstep=False
arr1d = np.linspace(0, 10, endpoint = False, retstep = False)
print("1-D array of 10 evenly-spaced elements between 0 and 10 is: \n", arr1d)
print()
#
array2d = np.linspace(1, 20, num = 20).reshape(5, 4)
print("2-D array of 20 elements between 0 and 20 is: \n", array2d)

The following is the linspace() program’s output:

General Array Creation Functions

The ndarray provides a few array creation functions, e.g., numpy.ones, numpy.zeros to define arrays based upon the desired shape. The ndarray creation functions can create arrays:

• Of any dimension by specifying the number of dimensions and
• Length along that dimension in a tuple or list.

Numpy.ones() Function

The numpy.ones() function is used to create an array filled with ones. This function is particularly useful for initializing arrays in mathematical computations or algorithms.

For details refer to the link below:

https://numpy.org/doc/stable/reference/generated/numpy.ones.html

Syntax:

numpy.ones(shape, dtype=None, order=’C’, *, device=None, like=None)

Return value:

The function returns a new array of the given shape and type, filled with ones.

Parameters:

Parameter	Description	Example
shape : int or sequence of ints	Shape of the new array	Tuple e.g. (2,3) or 2
dtype : data-type	(Optional) The desired data-type for the array	e.g., numpy.int8. Default is numpy.float64.
Order : {‘C’, ‘F’}	(Optional) Store multi-dimensional data in row-major (C-style) or column-major (F-style) order in memory.	Default: C
Device :	Optional	str

The program example shows how to generate an array filled with 1’s.

Program Example: numpy.ones() Function

# ndarray numpy.ones()
print("numpy.ones PROGRAM EXAMPLES")
import numpy as np
# Create a 1D array of size 6 filled with ones
ones1d = np.ones(6)
print("A 1D ones array of size 6 : \n", ones1d)
print()
# Create a 2D ones array of size 2x6 filled with ones
ones2d = np.ones((2,6))
print("A 2D ones array of size 2x6 : \n", ones2d)
print()
# Create a 3D ones array of size 2x5x3 filled with ones
ones3d = np.ones((2, 5, 3))
print("A 3D ones array of size 2x5x3 : \n", ones3d)
print()

The following is the program’s output:

numpy.zeros() Function

The numpy.zeros() function is used to create an array filled with zeros. It is used for creating placeholders before filling them with actual data.

This function is particularly useful for initializing arrays in mathematical computations or algorithms, where you may not have initial values. 

For more details, refer to the link below:

https://numpy.org/doc/stable/reference/generated/numpy.zeros.html#numpy.zeros

numpy.zeros Syntax:

numpy.zeros(shape, dtype=None, order=’C’, *, device=None, like=None)

Return Value.

numpy.zeros() returns a new array of given shape and type, filled with zeros.

Parameters:

Parameter	Description	Example
shape: int or tuple of ints	Shape of the new array. An integer for a 1D array or a tuple for multi-dimensional arrays	e.g., (2, 3) or 2.
dtype: data-type	(Optional) The desired data-type for the array elements	e.g., numpy.int8. Default is numpy.float64.
order : {‘C’, ‘F’}	(Optional) Defines memory layout. Whether to store multi-dimensional data in row-major (C-style) or column-major (F-style) order in memory.	default: ‘C’
Device :	Optional	str

Program Example: numpy.zeros() Function

# naarray numpy.zeros()
print("numpy.zeros PROGRAM EXAMPLES")
import numpy as np
# Create a 1D array of size 6 filled with zeros
zeros1d = np.zeros(6)
print("A 1D array of size 6 : \n", zeros1d)
print()
# Create a 2D array of size 2x6 filled with zeros
zeros2d = np.zeros((2,6))
print("A 2D array of size 2x6 : \n", zeros2d)
print()
# Create a 3D array of size 2x5x3 filled with zeros
zeros3d = np.zeros((2, 5, 3))
print("A 3D array of size 2x5x3 : \n", zeros3d)
print()

The following is the program’s output:

Numpy.identity() Function

The identity array can be created using numpy.identity() function, which takes the size of the matrix as an argument. The identity array is always square i.e., it has the same number of rows and columns. It has ones on the main diagonal (from the top left to the bottom right) and zeros elsewhere.

When multiplied by any matrix of compatible dimensions, it returns the original matrix.

Identity() function is used in linear algebra computations to represent a matrix that doesn’t change a vector when multiplied by it.

Syntax:

numpy.identity(n, dtype=None)

n = dimension of the square array.

Return value:

identity() [ndarray] returns an n x n array with its main diagonal set to one, and all other elements set to 0.

You can create an identity array in NumPy using the numpy.identity() function as in the program below.

Program Example: numpy.identity() Function

# Numpy Identity Array
print("Program name: numpy_identity.py \n")
import numpy as np
# Create a 3x3 identity aarray
identityarray = np.identity(3)
print("3x3 identity array is : \n", identityarray)
print()

The following is identity() function program’s output.