NumPy is the fundamental package supported for presenting and computing data with high performance in Python. It provides some interesting features as follows:
ndarrays
), various derived objects (such as masked arrays), matrices providing vectorization operations, and broadcasting capabilities. Vectorization can significantly increase the performance of array computations by taking advantage of Single Instruction Multiple Data (SIMD) instruction sets in modern CPUs.NumPy is a good starting package for you to get familiar with arrays and array-oriented computing in data analysis. Also, it is the basic step to learn other, more effective tools such as pandas, which we will see in the next chapter. We will be using NumPy version 1.9.1.
An array can be used to contain values of a data object in an experiment or simulation step, pixels of an image, or a signal recorded by a measurement device. For example, the latitude of the Eiffel Tower, Paris is 48.858598 and the longitude is 2.294495. It can be presented in a NumPy array object as p
:
>>> import numpy as np >>> p = np.array([48.858598, 2.294495]) >>> p Output: array([48.858598, 2.294495])
This is a manual construction of an array using the np.array
function. The standard convention to import NumPy is as follows:
>>> import numpy as np
You can, of course, put from numpy import *
in your code to avoid having to write np
. However, you should be careful with this habit because of the potential code conflicts (further information on code conventions can be found in the Python Style Guide, also known as PEP8, at https://www.python.org/dev/peps/pep-0008/).
There are two requirements of a NumPy array: a fixed size at creation and a uniform, fixed data type, with a fixed size in memory. The following functions help you to get information on the p
matrix:
>>> p.ndim # getting dimension of array p 1 >>> p.shape # getting size of each array dimension (2,) >>> len(p) # getting dimension length of array p 2 >>> p.dtype # getting data type of array p dtype('float64')
There are five basic numerical types including Booleans (bool
), integers (int
), unsigned integers (uint
), floating point (float
), and complex. They indicate how many bits are needed to represent elements of an array in memory. Besides that, NumPy also has some types, such as intc
and intp
, that have different bit sizes depending on the platform.
See the following table for a listing of NumPy's supported data types:
Type |
Type code |
Description |
Range of value |
---|---|---|---|
|
Boolean stored as a byte |
True/False | |
|
Similar to C int (int32 or int 64) | ||
|
Integer used for indexing (same as C size_t) | ||
|
i1, u1 |
Signed and unsigned 8-bit integer types |
int8: (-128 to 127) uint8: (0 to 255) |
|
i2, u2 |
Signed and unsigned 16-bit integer types |
int16: (-32768 to 32767) uint16: (0 to 65535) |
|
I4, u4 |
Signed and unsigned 32-bit integer types |
int32: (-2147483648 to 2147483647 uint32: (0 to 4294967295) |
|
i8, u8 |
Signed and unsigned 64-bit integer types |
Int64: (-9223372036854775808 to 9223372036854775807) uint64: (0 to 18446744073709551615) |
|
f2 |
Half precision float: sign bit, 5 bits exponent, and 10b bits mantissa | |
|
f4 / f |
Single precision float: sign bit, 8 bits exponent, and 23 bits mantissa | |
|
f8 / d |
Double precision float: sign bit, 11 bits exponent, and 52 bits mantissa | |
|
c8, c16, c32 |
Complex numbers represented by two 32-bit, 64-bit, and 128-bit floats | |
|
0 |
Python object type | |
|
S |
Fixed-length string type |
Declare a string |
|
U |
Fixed-length Unicode type |
Similar to string_ example, we have 'U10' |
We can easily convert or cast an array from one dtype
to another using the astype
method:
>>> a = np.array([1, 2, 3, 4]) >>> a.dtype dtype('int64') >>> float_b = a.astype(np.float64) >>> float_b.dtype dtype('float64')
There are various functions provided to create an array object. They are very useful for us to create and store data in a multidimensional array in different situations.
Now, in the following table we will summarize some of NumPy's common functions and their use by examples for array creation:
Function |
Description |
Example |
---|---|---|
|
Create a new array of the given shape and type, without initializing elements |
>>> np.empty([3,2], dtype=np.float64) array([[0., 0.], [0., 0.], [0., 0.]]) >>> a = np.array([[1, 2], [4, 3]]) >>> np.empty_like(a) array([[0, 0], [0, 0]])
|
|
Create a NxN identity matrix with ones on the diagonal and zero elsewhere |
>>> np.eye(2, dtype=np.int) array([[1, 0], [0, 1]])
|
|
Create a new array with the given shape and type, filled with 1s for all elements |
>>> np.ones(5) array([1., 1., 1., 1., 1.]) >>> np.ones(4, dtype=np.int) array([1, 1, 1, 1]) >>> x = np.array([[0,1,2], [3,4,5]]) >>> np.ones_like(x) array([[1, 1, 1],[1, 1, 1]])
|
|
This is similar to |
>>> np.zeros(5) array([0., 0., 0., 0-, 0.]) >>> np.zeros(4, dtype=np.int) array([0, 0, 0, 0]) >>> x = np.array([[0, 1, 2], [3, 4, 5]]) >>> np.zeros_like(x) array([[0, 0, 0],[0, 0, 0]])
|
|
Create an array with even spaced values in a given interval |
>>> np.arange(2, 5) array([2, 3, 4]) >>> np.arange(4, 12, 5) array([4, 9])
|
|
Create a new array with the given shape and type, filled with a selected value |
>>> np.full((2,2), 3, dtype=np.int) array([[3, 3], [3, 3]]) >>> x = np.ones(3) >>> np.full_like(x, 2) array([2., 2., 2.])
|
|
Create an array from the existing data |
>>> np.array([[1.1, 2.2, 3.3], [4.4, 5.5, 6.6]]) array([1.1, 2.2, 3.3], [4.4, 5.5, 6.6]])
|
|
Convert the input to an array |
>>> a = [3.14, 2.46] >>> np.asarray(a) array([3.14, 2.46])
|
|
Return an array copy of the given object |
>>> a = np.array([[1, 2], [3, 4]]) >>> np.copy(a) array([[1, 2], [3, 4]])
|
|
Create 1-D array from a string or text |
>>> np.fromstring('3.14 2.17', dtype=np.float, sep=' ') array([3.14, 2.17])
|
As with other Python sequence types, such as lists, it is very easy to access and assign a value of each array's element:
>>> a = np.arange(7) >>> a array([0, 1, 2, 3, 4, 5, 6]) >>> a[1], a [4], a[-1] (1, 4, 6)
As another example, if our array is multidimensional, we need tuples of integers to index an item:
>>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> a[0, 2] # first row, third column 3 >>> a[0, 2] = 10 >>> a array([[1, 2, 10], [4, 5, 6], [7, 8, 9]]) >>> b = a[2] >>> b array([7, 8, 9]) >>> c = a[:2] >>> c array([[1, 2, 10], [4, 5, 6]])
We call b
and c
as array slices, which are views on the original one. It means that the data is not copied to b
or c
, and whenever we modify their values, it will be reflected in the array a
as well:
>>> b[-1] = 11 >>> a array([[1, 2, 10], [4, 5, 6], [7, 8, 11]])
Besides indexing with slices, NumPy also supports indexing with Boolean or integer arrays (masks). This method is called fancy indexing. It creates copies, not views.
First, we take a look at an example of indexing with a Boolean mask array:
>>> a = np.array([3, 5, 1, 10]) >>> b = (a % 5 == 0) >>> b array([False, True, False, True], dtype=bool) >>> c = np.array([[0, 1], [2, 3], [4, 5], [6, 7]]) >>> c[b] array([[2, 3], [6, 7]])
The second example is an illustration of using integer masks on arrays:
>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]) >>> a[[2, 1]] array([[9, 10, 11, 12], [5, 6, 7, 8]]) >>> a[[-2, -1]] # select rows from the end array([[ 9, 10, 11, 12], [13, 14, 15, 16]]) >>> a[[2, 3], [0, 1]] # take elements at (2, 0) and (3, 1) array([9, 14])
We are getting familiar with creating and accessing ndarrays
. Now, we continue to the next step, applying some mathematical operations to array data without writing any for loops, of course, with higher performance.
Scalar operations will propagate the value to each element of the array:
>>> a = np.ones(4) >>> a * 2 array([2., 2., 2., 2.]) >>> a + 3 array([4., 4., 4., 4.])
All arithmetic operations between arrays apply the operation element wise:
>>> a = np.ones([2, 4]) >>> a * a array([[1., 1., 1., 1.], [1., 1., 1., 1.]]) >>> a + a array([[2., 2., 2., 2.], [2., 2., 2., 2.]])
Also, here are some examples of comparisons and logical operations:
>>> a = np.array([1, 2, 3, 4]) >>> b = np.array([1, 1, 5, 3]) >>> a == b array([True, False, False, False], dtype=bool) >>> np.array_equal(a, b) # array-wise comparison False >>> c = np.array([1, 0]) >>> d = np.array([1, 1]) >>> np.logical_and(c, d) # logical operations array([True, False])