The important attributes of an ndarray object are:

ndarray.ndim - the number of axes (dimensions) of the array.

ndarray.shape - the dimensions of the array. This is a tuple of integers indicating the size of the array in each dimension. For a matrix with n rows and m columns, shape will be (n,m). The length of the shape tuple is therefore the number of axes, ndim.

ndarray.size - the total number of elements of the array. This is equal to the product of the elements of shape.

ndarray.dtype - an object describing the type of the elements in the array. One can create or specify dtype’s using standard Python types. Additionally NumPy provides types of its own. numpy.int32, numpy.int16, and numpy.float64 are some examples.

ndarray.itemsize - the size in bytes of each element of the array. For example, an array of elements of type float64 has itemsize 8 (=64/8), while one of type complex32 has itemsize 4 (=32/8). It is equivalent to ndarray.dtype.itemsize.

ndarray.data - the buffer containing the actual elements of the array. Normally, we won’t need to use this attribute because we will access the elements in an array using indexing facilities.

Overview

  • Array Creation

arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones,ones_like, r_, zeros, zeros_like

  • Conversions

ndarray.astype, atleast_1d, atleast_2d, atleast_3d, mat

  • Manipulations

array_split, column_stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, ndarray.item, newaxis, ravel,repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack

  • Questions

all, any, nonzero, where

  • Ordering

argmax, argmin, argsort, max, min, ptp, searchsorted, sort

  • Operations

choose, compress, cumprod, cumsum, inner, ndarray.fill, imag, prod, put, putmask, real, sum

  • Basic Statistics

cov, mean, std, var

  • Basic Linear Algebra

cross, dot, outer, linalg.svd, vdot

The Basics

  1. >>> import numpy as np
  2. >>> a = np.arange(15).reshape(3, 5)
  3. >>> a
  4. array([[ 0,  1,  2,  3,  4],
  5.        [ 5,  6,  7,  8,  9],
  6.        [10, 11, 12, 13, 14]])
  7. >>> a.shape
  8. (3, 5)
  9. >>> a.ndim
  10. 2
  11. >>> a.dtype.name
  12. 'int64'
  13. >>> a.itemsize
  14. 8
  15. >>> a.size
  16. 15
  17. >>> type(a)
  18. <class 'numpy.ndarray'>
  19. >>> b = np.array([6, 7, 8])
  20. >>> b
  21. array([6, 7, 8])
  22. >>> type(b)
  23. <class 'numpy.ndarray'>

Creation

The function zeros creates an array full of zeros, the function ones creates an array full of ones, and the function empty creates an array whose initial content is random and depends on the state of the memory. By default, the dtype of the created array is float64.

  1. >>> np.zeros((3, 4))
  2. array([[0., 0., 0., 0.],
  3.        [0., 0., 0., 0.],
  4.        [0., 0., 0., 0.]])
  5. >>> np.ones( (2,3,4), dtype=np.int16 )                # dtype can also be specified
  6. array([[[1, 1, 1, 1],
  7.         [1, 1, 1, 1],
  8.         [1, 1, 1, 1]],
  9.        [[1, 1, 1, 1],
  10.         [1, 1, 1, 1],
  11.         [1, 1, 1, 1]]], dtype=int16)
  12. >>> np.empty( (2,3) )                                 # uninitialized
  13. array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],  # may vary
  14.        [  5.30498948e-313,   3.14673309e-307,   1.00000000e+000]])

To create sequences of numbers, NumPy provides the arange function which is analogous to the Python built-in range, but returns an array.

  1. >>> np.arange( 10, 30, 5 )
  2. array([10, 15, 20, 25])
  3. >>> np.arange( 0, 2, 0.3 )                 # it accepts float arguments
  4. array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])

Operations

Arithmetic operators on arrays apply elementwise. A new array is created and filled with the result.

Functions

NumPy provides familiar mathematical functions such as sin, cos, and exp. In NumPy, these are called “universal functions”(ufunc). Within NumPy, these functions operate elementwise on an array, producing an array as output.

  1. >>> B = np.arange(3)
  2. >>> B
  3. array([0, 1, 2])
  4. >>> np.exp(B)
  5. array([1.        , 2.71828183, 7.3890561 ])
  6. >>> np.sqrt(B)
  7. array([0.        , 1.        , 1.41421356])
  8. >>> C = np.array([2., -1., 4.])
  9. >>> np.add(B, C)
  10. array([2., 0., 6.])

Indexing, Slicing and Iterating

One-dimensional arrays can be indexed, sliced and iterated over, much like lists and other Python sequences.
image.png

  1. >>> a = np.arange(10)**3
  2. >>> a
  3. array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
  4. >>> a[2]
  5. 8
  6. >>> a[2:5]
  7. array([ 8, 27, 64])
  8. # equivalent to a[0:6:2] = 1000;
  9. # from start to position 6, exclusive, set every 2nd element to 1000
  10. >>> a[:6:2] = 1000
  11. >>> a
  12. array([1000,    1, 1000,   27, 1000,  125,  216,  343,  512,  729])
  13. >>> a[ : :-1]                                 # reversed a
  14. array([ 729,  512,  343,  216,  125, 1000,   27, 1000,    1, 1000])
  15. >>> for i in a:
  16. ...     print(i**(1/3.))
  17. ...
  18. 9.999999999999998
  19. 1.0
  20. 9.999999999999998
  21. 3.0
  22. 9.999999999999998
  23. 4.999999999999999
  24. 5.999999999999999
  25. 6.999999999999999
  26. 7.999999999999999
  27. 8.999999999999998

Changing the shape of an array

An array has a shape given by the number of elements along each axis:

  1. >>> a = np.floor(10*rg.random((3,4)))
  2. >>> a
  3. array([[3., 7., 3., 4.],
  4.        [1., 4., 2., 2.],
  5.        [7., 2., 4., 9.]])
  6. >>> a.shape
  7. (3, 4)

**
The shape of an array can be changed with various commands. Note that the following three commands all return a modified array, but do not change the original array:

  1. >>> a.ravel()  # returns the array, flattened
  2. array([3., 7., 3., 4., 1., 4., 2., 2., 7., 2., 4., 9.])
  3. >>> a.reshape(6,2)  # returns the array with a modified shape
  4. array([[3., 7.],
  5.        [3., 4.],
  6.        [1., 4.],
  7.        [2., 2.],
  8.        [7., 2.],
  9.        [4., 9.]])
  10. >>> a.T  # returns the array, transposed
  11. array([[3., 1., 7.],
  12.        [7., 4., 2.],
  13.        [3., 2., 4.],
  14.        [4., 2., 9.]])
  15. >>> a.T.shape
  16. (4, 3)
  17. >>> a.shape
  18. (3, 4)

**
The reshape function returns its argument with a modified shape, whereas the ndarray.resize method modifies the array itself:

  1. >>> a
  2. array([[3., 7., 3., 4.],
  3.        [1., 4., 2., 2.],
  4.        [7., 2., 4., 9.]])
  5. >>> a.resize((2,6))
  6. >>> a
  7. array([[3., 7., 3., 4., 1., 4.],
  8.        [2., 2., 7., 2., 4., 9.]])

**

Stacking together different arrays

Several arrays can be stacked together along different axes:

  1. >>> a = np.floor(10*rg.random((2,2)))
  2. >>> a
  3. array([[9., 7.],
  4.        [5., 2.]])
  5. >>> b = np.floor(10*rg.random((2,2)))
  6. >>> b
  7. array([[1., 9.],
  8.        [5., 1.]])
  9. >>> np.vstack((a,b))
  10. array([[9., 7.],
  11.        [5., 2.],
  12.        [1., 9.],
  13.        [5., 1.]])
  14. >>> np.hstack((a,b))
  15. array([[9., 7., 1., 9.],
  16.        [5., 2., 5., 1.]])

**

Splitting one array into several smaller ones

Using hsplit, you can split an array along its horizontal axis, either by specifying the number of equally shaped arrays to return, or by specifying the columns after which the division should occur:

  1. >>> a = np.floor(10*rg.random((2,12)))
  2. >>> a
  3. array([[6., 7., 6., 9., 0., 5., 4., 0., 6., 8., 5., 2.],
  4.        [8., 5., 5., 7., 1., 8., 6., 7., 1., 8., 1., 0.]])
  5. # Split a into 3
  6. >>> np.hsplit(a,3)
  7. [array([[6., 7., 6., 9.],
  8.        [8., 5., 5., 7.]]), array([[0., 5., 4., 0.],
  9.        [1., 8., 6., 7.]]), array([[6., 8., 5., 2.],
  10.        [1., 8., 1., 0.]])]
  11. # Split a after the third and the fourth column
  12. >>> np.hsplit(a,(3,4))
  13. [array([[6., 7., 6.],
  14.        [8., 5., 5.]]), array([[9.],
  15.        [7.]]), array([[0., 5., 4., 0., 6., 8., 5., 2.],
  16.        [1., 8., 6., 7., 1., 8., 1., 0.]])]

vsplit splits along the vertical axis, and array_split allows one to specify along which axis to split.

**

Copies and Views

When operating and manipulating arrays, their data is sometimes copied into a new array and sometimes not. This is often a source of confusion for beginners. There are three cases:

No Copy at All

Simple assignments make no copy of objects or their data.

  1. >>> a = np.array([[ 0,  1,  2,  3],
  2. ...               [ 4,  5,  6,  7],
  3. ...               [ 8,  9, 10, 11]])
  4. >>> b = a            # no new object is created
  5. >>> b is a           # a and b are two names for the same ndarray object
  6. True

**
Python passes mutable objects as references, so function calls make no copy.

  1. >>> def f(x):
  2. ...     print(id(x))
  3. ...
  4. >>> id(a)                           # id is a unique identifier of an object
  5. 148293216  # may vary
  6. >>> f(a)
  7. 148293216  # may vary

**

View or Shallow Copy

Different array objects can share the same data. The view method creates a new array object that looks at the same data.

  1. >>> c = a.view()
  2. >>> c is a
  3. False
  4. >>> c.base is a                        # c is a view of the data owned by a
  5. True
  6. >>> c.flags.owndata
  7. False
  8. >>>
  9. >>> c = c.reshape((2, 6))                      # a's shape doesn't change
  10. >>> a.shape
  11. (3, 4)
  12. >>> c[0, 4] = 1234                      # a's data changes
  13. >>> a
  14. array([[   0,    1,    2,    3],
  15.        [1234,    5,    6,    7],
  16.        [   8,    9,   10,   11]])

Slicing an array returns a view of it:

  1. >>> s = a[ : , 1:3]     # spaces added for clarity; could also be written "s = a[:, 1:3]"
  2. >>> s[:] = 10           # s[:] is a view of s. Note the difference between s = 10 and s[:] = 10
  3. >>> a
  4. array([[   0,   10,   10,    3],
  5.        [1234,   10,   10,    7],
  6.        [   8,   10,   10,   11]])

**

Deep Copy

The copy method makes a complete copy of the array and its data.

  1. >>> d = a.copy()                          # a new array object with new data is created
  2. >>> d is a
  3. False
  4. >>> d.base is a                           # d doesn't share anything with a
  5. False
  6. >>> d[0,0] = 9999
  7. >>> a
  8. array([[   0,   10,   10,    3],
  9.        [1234,   10,   10,    7],
  10.        [   8,   10,   10,   11]])

**
Sometimes copy should be called after slicing if the original array is not required anymore. For example, suppose a is a huge intermediate result and the final result b only contains a small fraction of a, a deep copy should be made when constructing b with slicing:

  1. >>> a = np.arange(int(1e8))
  2. >>> b = a[:100].copy()
  3. >>> del a  # the memory of ``a`` can be released.

If b = a[:100] is used instead, a is referenced by b and will persist in memory even if del a is executed.