## what does numpy ndarray shape do?

numpy shape rows columns

numpy array size

numpy array dimensions

numpy reshape

np.matrix shape

numpy array append

numpy 2d array

I have a simple question about the .shape function, which confused me a lot.

a = np.array([1, 2, 3]) # Create a rank 1 array print(type(a)) # Prints "<class 'numpy.ndarray'>" print(a.shape) # Prints "(3,)" b = np.array([[1,2,3],[4,5,6]]) # Create a rank 2 array print(b.shape) # Prints "(2, 3)"

What did the .shape exactly do? count how many rows, how many columns, then the a.shape suppose to be, (1,3), one row three columns, right?

`yourarray.shape`

or `np.shape()`

or `np.ma.shape()`

returns the shape of your ndarray as a *tuple*; And you can get the (number of) dimensions of your array using `yourarray.ndim`

or `np.ndim()`

. (i.e. it gives the `n`

of the `ndarray`

since all arrays in NumPy are just n-dimensional arrays (shortly called as `ndarray`

s))

For a *1D* array, the shape would be `(n,)`

where `n`

is the number of elements in your array.

For a *2D* array, the shape would be `(n,m)`

where `n`

is the number of rows and `m`

is the number of columns in your array.

Please note that in **1D** case, the shape would simply be `(n, )`

instead of what you said as either `(1, n)`

or `(n, 1)`

for row and column vectors respectively.

This is to follow the convention that:

For 1D array, return a *shape tuple* with only *1* element (i.e. `(n,)`

)
For 2D array, return a *shape tuple* with only *2* elements (i.e. `(n,m)`

)
For 3D array, return a *shape tuple* with only *3* elements (i.e. `(n,m,k)`

)
For 4D array, return a *shape tuple* with only *4* elements (i.e. `(n,m,k,j)`

)

and so on.

Also, please see the example below to see how `np.shape()`

or `np.ma.shape()`

behaves with *1D* arrays and scalars:

# sample array In [10]: u = np.arange(10) # get its shape In [11]: np.shape(u) # u.shape Out[11]: (10,) # get array dimension using `np.ndim` In [12]: np.ndim(u) Out[12]: 1 In [13]: np.shape(np.mean(u)) Out[13]: () # empty tuple (to indicate that a scalar is a 0D array). # check using `numpy.ndim` In [14]: np.ndim(np.mean(u)) Out[14]: 0

**P.S.**: So, the *shape tuple* is *consistent* with our understanding of dimensions of space, at least mathematically.

**NumPy Array Shape,** yourarray.shape or np.shape() or np.ma.shape() returns the shape of your ndarray as a tuple; And you can get the (number of) dimensions of ndarray.shape¶ Tuple of array dimensions. The shape property is usually used to get the current shape of an array, but may also be used to reshape the array in-place by assigning a tuple of array dimensions to it. As with numpy.reshape, one of the new shape dimensions can be -1, in which case its value is inferred from the size of the array and the remaining dimensions. Reshaping an array in-place will fail if a copy is required.

Unlike it's most popular commercial competitor, numpy pretty much from the outset is about "arbitrary-dimensional" arrays, that's why the core class is called `ndarray`

. You can check the dimensionality of a numpy array using the `.ndim`

property. The `.shape`

property is a tuple of length `.ndim`

containing the length of each dimensions. Currently, numpy can handle up to 32 dimensions:

a = np.ones(32*(1,)) a # array([[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ 1.]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]) a.shape # (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) a.ndim # 32

If a numpy array happens to be 2d like your second example, then it's appropriate to think about it in terms of rows and columns. But a 1d array in numpy is truly 1d, no rows or columns.

If you want something like a row or column vector you can achieve this by creating a 2d array with one of its dimensions equal to 1.

a = np.array([[1,2,3]]) # a 'row vector' b = np.array([[1],[2],[3]]) # a 'column vector' # or if you don't want to type so many brackets: b = np.array([[1,2,3]]).T

**what does numpy ndarray shape do?,** ndarray can be obtained as a tuple with attribute shape . Even in the case of a one-dimensional array, it is a tuple with one element instead of an The most important object defined in NumPy is an N-dimensional array type called ndarray. It describes the collection of items of the same type. Items in the collection can be accessed using a zero-based index. Every item in an ndarray takes the same size of block in the memory. Each element in ndarray is an object of data-type object (called dtype).

.shape() gives the actual shape of your array in terms of no of elements in it, No of rows/No of Columns. The answer you get is in the form of tuples.

For Example: 1D ARRAY:

d=np.array([1,2,3,4]) print(d) (1,)

Output: (4,) ie the number4 denotes the no of elements in the 1D Array.

2D Array:

e=np.array([[1,2,3],[4,5,6]]) print(e) (2,3)

Output: (2,3) ie the number of rows and the number of columns.

The number of elements in the final output will depend on the number of rows in the Array....it goes on increasing gradually.

**ndarray.shape - Numpy and Scipy,** Elements in Numpy arrays are accessed by using square brackets and can Array is of type: <class 'numpy.ndarray'> No. of dimensions: 2 Shape of array: (2, Shape of numpy.ndarray: shape. The shape (= size of each dimension) of numpy.ndarray can be obtained as a tuple with attribute shape. Even in the case of a one-dimensional array, it is a tuple with one element instead of an integer value. Note that a tuple with one element has a trailing comma. Related: One-element tuples require a comma in Python

array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

**NumPy: Get the number of dimensions, shape, and size of ndarray ,** Slicing: Similar to Python lists, numpy arrays can be sliced. The returned array will have shape (3,) and print(a[[0, 1, 2], [0, 1, 0]]) Get the Dimensions of a Numpy array using ndarray.shape() numpy.ndarray.shape. Python’s Numpy Module provides a function to get the dimensions of a Numpy array, ndarray.shape It returns the dimension of numpy array as tuple. Let’s use this to get the shape or dimensions of a 2D & 1D numpy array i.e.

**Numpy,** In this article we will discuss how to count number of elements in a 1D, 2D & 3D Numpy array, also how to count number of rows & columns of a This function gives a new shape to an array without changing the data. It accepts the following parameters − numpy.reshape (arr, newshape, order')

**Python Numpy Tutorial (with Jupyter and Colab),** numpy.ndarray.shape¶. ndarray.shape¶. Tuple of array dimensions. Notes. May be used to “reshape” the array, as long as this would not require a change in the numpy.reshape () function. The reshape () function is used to give a new shape to an array without changing its data.

**How to get Numpy Array Dimensions using numpy.ndarray.shape ,** shape - Tuple of array dimensions. Notes May be used to "reshape" the array, as long as this would not require a change in the total number of … numpy.ndarray.tostring() is deprecated in favor of tobytes() ¶ ~numpy.ndarray.tobytes has existed since the 1.9 release, but until this release ~numpy.ndarray.tostring emitted no warning. The change to emit a warning brings NumPy in line with the builtin array.array methods of the same name.

##### Comments

- I think your explanation would be even more complete by adding in the documentation for
`.shape`

and probably including`.ndim`

as well: docs.scipy.org/doc/numpy-1.13.0/reference/generated/… - "you can get the dimensions of your array using yourarray.ndim or np.ndim()." --- I have tried and it only gives
**one of dimensions**, not the dimensions. - @DmitriZaitsev, I think they mistyped. ndim returns the number of dimensions, not the dimensions or even any of the dimensions. So for a 1D array, it would return 1; for 2D, 2, 3D, 3; and so on. The documentation already linked backs this up.
- Uuslaly M refers to rows, no? Otherwise this is super helpful.