CODEWITHSUNDEEP
pythonnumpy
flamingo_stark
flamingo_stark

Reputation: 151

Understanding axes in NumPy

I was going through NumPy documentation, and am not able to understand one point. It mentions, for the example below, the array has rank 2 (it is 2-dimensional). The first dimension (axis) has a length of 2, the second dimension has a length of 3.

 [[ 1., 0., 0.],
 [ 0., 1., 2.]]

How does the first dimension (axis) have a length of 2?

Edit: The reason for my confusion is the below statement in the documentation.

The coordinates of a point in 3D space [1, 2, 1] is an array of rank 1, because it has one axis. That axis has a length of 3.

In the original 2D ndarray, I assumed that the number of lists identifies the rank/dimension, and I wrongly assumed that the length of each list denotes the length of each dimension (in that order). So, as per my understanding, the first dimension should be having a length of 3, since the length of the first list is 3.

Upvotes: 2

Views: 4457

Answers (5)

Alex Oakley
Alex Oakley

Reputation: 127

Keep the following points in mind when considering Numpy axes:

  1. Each sub-level of a list (or array) represents an axis. For example:
import numpy as np

a = np.array([1,2])                         # 1 axis
b = np.array([[1,2],[3,4]])                 # 2 axes
c = np.array([[[1,2],[3,4]],[[5,6],[7,8]]]) # 3 axes

  1. Axis labels correspond to the level of the sub-list they represent, starting with axis 0 for the outer most list.

    To illustrate this, consider the following array of different shape, each with 24 elements:

# 1D Array
a0 = np.array(
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
)
a0.shape # (24,) - here, the length along the 0-axis is 24 

# 2D Array
a01 = np.array(
    [
     [1.1, 1.2, 1.3, 1.4],
     [2.1, 2.2, 2.3, 2.4],
     [3.1, 3.2, 3.3, 3.4],
     [4.1, 4.2, 4.3, 4.4],
     [5.1, 5.2, 5.3, 5.4],
     [6.1, 6.2, 6.3, 6.4]
    ]

)
a01.shape # (6, 4) - now, the length along the 0-axis is 6

# 3D Array
a012 = np.array(


    [
     [
      [1.1.1, 1.1.2],
      [1.2.1, 1.2.2],
      [1.3.1, 1.3.2]
     ],
     [
      [2.1.1, 2.1.2],
      [2.2.1, 2.2.2],
      [2.3.1, 2.3.2]
     ],
     [
      [3.1.1, 3.1.2],
      [3.2.1, 3.2.2],
      [3.3.1, 3.3.2]
     ],
     [
      [4.1.1, 4.1.2],
      [4.2.1, 4.2.2],
      [4.3.1, 4.3.2]
     ]
)
a012.shape # (4, 3, 2) - and finally, the length along the 0-axis is 4

Upvotes: 0

FabienP
FabienP

Reputation: 3138

In numpy, axis ordering follows zyx convention, instead of the usual (and maybe more intuitive) xyz.

Visually, it means that for a 2D array where the horizontal axis is x and the vertical axis is y:

    x -->
y      0   1   2
|  0 [[1., 0., 0.],
V  1  [0., 1., 2.]]

The shape of this array is (2, 3) because it is ordered (y, x), with the first axis y of length 2.

And verifying this with slicing:

import numpy as np

a = np.array([[1, 0, 0], [0, 1, 2]], dtype=np.float)

>>> a
Out[]:
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  2.]])

>>> a[0, :]                    # Slice index 0 of first axis
Out[]: array([ 1.,  0.,  0.])  # Get values along second axis `x` of length 3

>>> a[:, 2]                    # Slice index 2 of second axis
Out[]: array([ 0.,  2.])       # Get values along first axis `y` of length 2

Upvotes: 6

Andy Hayden
Andy Hayden

Reputation: 375415

The first dimensions is the length:

In [11]: a = np.array([[ 1., 0., 0.], [ 0., 1., 2.]])

In [12]: a
Out[12]:
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  2.]])

In [13]: len(a)  # "length of first dimension"
Out[13]: 2

The second is the length of each "row":

In [14]: [len(aa) for aa in a]  # 3 is "length of second dimension"
Out[14]: [3, 3]

Many numpy functions take axis as an argument, for example you can sum over an axis:

In [15]: a.sum(axis=0)
Out[15]: array([ 1.,  1.,  2.])

In [16]: a.sum(axis=1)
Out[16]: array([ 1.,  3.])

The thing to note is that you can have higher dimensional arrays:

In [21]: b = np.array([[[1., 0., 0.], [ 0., 1., 2.]]])

In [22]: b
Out[22]:
array([[[ 1.,  0.,  0.],
        [ 0.,  1.,  2.]]])

In [23]: b.sum(axis=2)
Out[23]: array([[ 1.,  3.]])

Upvotes: 0

Dave Rosenman
Dave Rosenman

Reputation: 1447

If you print the numpy array

print(np.array([[ 1.  0.  0.],[ 0.  1.  2.]])

You'll get the following output

#col1 col2 col3
[[ 1.  0.  0.]  # row 1
[ 0.  1.  2.]] #  row 2

Think of it as a 2 by 3 matrix... 2 rows, 3 columns. It is a 2d array because it is a list of lists. ([[ at the start is a hint its 2d)).

The 2d numpy array 

np.array([[ 1.  0., 0., 6.],[ 0.  1.  2., 7.],[3.,4.,5,8.]])

would print as

#col1 col2 col3 col4
[[ 1.  0. , 0., 6.]  # row 1
[ 0.  1. , 2., 7.] #  row 2
[3.,  4. , 5., 8.]] # row 3

This is a 3 by 4 2d array (3 rows, 4 columns)

Upvotes: 1

MattR
MattR

Reputation: 5126

You may be confusing the other sentence with the picture example below. Think of it like this: Rank = number of lists in the list(array) and the term length in your question can be thought of length = the number of 'things' in the list(array)

I think they are trying to describe to you the definition of shape which is in this case (2,3)

in that post I think the key sentence is here:

In NumPy dimensions are called axes. The number of axes is rank.

Upvotes: 2

Related Questions