< Previous Page | Home Page | Next Page >
The Basics of NumPy Arrays¶
Data manipulation in Python is nearly synonymous with NumPy array manipulation: even newer tools like Pandas are built around the NumPy array. This section will present several examples of using NumPy array manipulation to access data and subarrays, and to split, reshape, and join the arrays. While the types of operations shown here may seem a bit dry and pedantic, they comprise the building blocks of many other examples used throughout the book. Get to know them well!
We'll cover a few categories of basic array manipulations here:
- Attributes of arrays: Determining the size, shape, memory consumption, and data types of arrays
- Indexing of arrays: Getting and setting the value of individual array elements
- Slicing of arrays: Getting and setting smaller subarrays within a larger array
- Reshaping of arrays: Changing the shape of a given array
- Joining and splitting of arrays: Combining multiple arrays into one, and splitting one array into many
Before we do so, let's have another look at the many ways of creating arrays.
Creating Arrays¶
A Numpy Array is an iterable data type which is in essence very similar to a list. However, elements within an array must be of the same type!
Du to the many possible applications of arrays, they are one of the most used objects in the numpy library.
We can create an array by defining a list and passing this list into numpy's array function.
import numpy as np
mylist = [1, 2, 3]
x = np.array(mylist)
x
We can also directly pass a list into the array function
y = np.array([4, 5, 6])
y
Numpy can also create multidimensional arrays. They correspond to nested lists and are often used to represent rows and columns in a table.
multi_a = np.array([[7, 8, 9], [10, 11, 12]])
multi_a
We can find the number of rows and columns of a (multidimensional) array using the shape operator. The return will be (# rows, # columns)
multi_a.shape
# our array has two rows and three columns
In case we do not want to type in every single value of our array, we can use the arrange method to create an array with specific attributes.
np.arrange(start:end:step)
- The start parameter indicates the starting value of our array. This defaults to 0.
- The end parameter tells us before which value the array should stop
- The step parameter defines an intervall within the individual elements.
n = np.arange(0, 30, 2) # start at 0 count up by 2, stop before 30
n
One further option to arrange the content of our array is linspace
Simply said, linspace returns evenly spaced numbers over a specified interval.
While this sounds a lot like np.arrange, it's syntax is quite different:
np.linspace(start:end:num)
startindicates the starting value.Endindicates the end value.- The
numparameter indicates the amount of evenly spaced values you want between start and end. It defaults to50.
o = np.linspace(0, 4, 9) # return 9 evenly spaced values from 0 to 4
o
o = np.linspace(0, 4) # return 50 evenly spaced values from 0 to 4
o
If we want to work with several arrays, we must ensure that they have the same amount of rows and columns.
Let's change the shape of our array using the reshape method. Again you can specify the intended number of rows and columns of the desired multidimensional array. Be aware, however, that the shape of the multidimensional array must match the number of elements within the array.
n = n.reshape(3, 5) # reshape array to be 3x5
n
If we want to reshape our array "in-place", i.e. without assigning it to a variable first, we can use resize instead of reshape. Resize thus does not return a value, but exercises the changes directly.
n.resize(5,3 )
n
Numpy also includes the option to create an array with a specific shape and fill this array with either ones (np.ones) or zeros (np.zeros).
np.ones((3, 2)) #returns a new arre with given shape, filled with ones
np.zeros((2, 3)) # returns a new array of given shape and type, filled with zeros.
eye returns a 2-D array with ones on the diagonal and zeros elsewhere.
np.eye(3)
diag extracts a diagonal or constructs a diagonal array.
diag_ = np.array([4, 5, 6])
print(diag_)
np.diag(diag_)
NumPy Array Attributes¶
First let's discuss some useful array attributes. We'll start by defining three random arrays, a one-dimensional, two-dimensional, and three-dimensional array. We'll use NumPy's random number generator, which we will seed with a set value in order to ensure that the same random arrays are generated each time this code is run:
import numpy as np
np.random.seed(0) # seed for reproducibility
x1 = np.random.randint(10, size=6) # One-dimensional array
x2 = np.random.randint(10, size=(3, 4)) # Two-dimensional array
x3 = np.random.randint(10, size=(3, 4, 5)) # Three-dimensional array
Each array has attributes ndim (the number of dimensions), shape (the size of each dimension), and size (the total size of the array):
print("x3 ndim: ", x3.ndim)
print("x3 shape:", x3.shape)
print("x3 size: ", x3.size)
Another useful attribute is the dtype, the data type of the array (which we discussed previously in Understanding Data Types in Python):
print("dtype:", x3.dtype)
Other attributes include itemsize, which lists the size (in bytes) of each array element, and nbytes, which lists the total size (in bytes) of the array:
print("itemsize:", x3.itemsize, "bytes")
print("nbytes:", x3.nbytes, "bytes")
In general, we expect that nbytes is equal to itemsize times size.
Array Indexing: Accessing Single Elements¶
If you are familiar with Python's standard list indexing, indexing in NumPy will feel quite familiar. In a one-dimensional array, the $i^{th}$ value (counting from zero) can be accessed by specifying the desired index in square brackets, just as with Python lists:
x1
x1[0]
x1[4]
To index from the end of the array, you can use negative indices:
x1[-1]
x1[-2]
In a multi-dimensional array, items can be accessed using a comma-separated tuple of indices:
x2
x2[0, 0]
x2[2, 0]
x2[2, -1]
Values can also be modified using any of the above index notation:
x2[0, 0] = 12
x2
Keep in mind that, unlike Python lists, NumPy arrays have a fixed type. This means, for example, that if you attempt to insert a floating-point value to an integer array, the value will be silently truncated. Don't be caught unaware by this behavior!
x1[0] = 3.14159 # this will be truncated!
x1
Array Slicing: Accessing Subarrays¶
Just as we can use square brackets to access individual array elements, we can also use them to access subarrays with the slice notation, marked by the colon (:) character.
The NumPy slicing syntax follows that of the standard Python list; to access a slice of an array x, use this:
x[start:stop:step]
If any of these are unspecified, they default to the values start=0, stop=size of dimension, step=1.
We'll take a look at accessing sub-arrays in one dimension and in multiple dimensions.
One-dimensional subarrays¶
x = np.arange(10)
x
x[:5] # first five elements
x[5:] # elements after index 5
x[4:7] # middle sub-array
x[::2] # every other element
x[1::2] # every other element, starting at index 1
A potentially confusing case is when the step value is negative.
In this case, the defaults for start and stop are swapped.
This becomes a convenient way to reverse an array:
x[::-1] # all elements, reversed
x[5::-2] # reversed every other from index 5
Multi-dimensional subarrays¶
Multi-dimensional slices work in the same way, with multiple slices separated by commas. For example:
x2
x2[:2, :3] # two rows, three columns
x2[:3, ::2] # all rows, every other column
Finally, subarray dimensions can even be reversed together:
x2[::-1, ::-1]
Accessing array rows and columns¶
One commonly needed routine is accessing of single rows or columns of an array.
This can be done by combining indexing and slicing, using an empty slice marked by a single colon (:):
print(x2[:, 0]) # first column of x2
print(x2[0, :]) # first row of x2
In the case of row access, the empty slice can be omitted for a more compact syntax:
print(x2[0]) # equivalent to x2[0, :]
Subarrays as no-copy views¶
One important–and extremely useful–thing to know about array slices is that they return views rather than copies of the array data. This is one area in which NumPy array slicing differs from Python list slicing: in lists, slices will be copies. Consider our two-dimensional array from before:
print(x2)
Let's extract a $2 \times 2$ subarray from this:
x2_sub = x2[:2, :2]
print(x2_sub)
Now if we modify this subarray, we'll see that the original array is changed! Observe:
x2_sub[0, 0] = 99
print(x2_sub)
print(x2)
This default behavior is actually quite useful: it means that when we work with large datasets, we can access and process pieces of these datasets without the need to copy the underlying data buffer.
Creating copies of arrays¶
Despite the nice features of array views, it is sometimes useful to instead explicitly copy the data within an array or a subarray. This can be most easily done with the copy() method:
x2_sub_copy = x2[:2, :2].copy()
print(x2_sub_copy)
If we now modify this subarray, the original array is not touched:
x2_sub_copy[0, 0] = 42
print(x2_sub_copy)
print(x2)
Reshaping of Arrays¶
Another useful type of operation is reshaping of arrays.
The most flexible way of doing this is with the reshape method.
For example, if you want to put the numbers 1 through 9 in a $3 \times 3$ grid, you can do the following:
grid = np.arange(1, 10).reshape((3, 3))
print(grid)
Note that for this to work, the size of the initial array must match the size of the reshaped array.
Where possible, the reshape method will use a no-copy view of the initial array, but with non-contiguous memory buffers this is not always the case.
Another common reshaping pattern is the conversion of a one-dimensional array into a two-dimensional row or column matrix.
This can be done with the reshape method, or more easily done by making use of the newaxis keyword within a slice operation:
x = np.array([1, 2, 3])
# row vector via reshape
x.reshape((1, 3))
# row vector via newaxis
x[np.newaxis, :]
# column vector via reshape
x.reshape((3, 1))
# column vector via newaxis
x[:, np.newaxis]
We will see this type of transformation often throughout the remainder of the book.
Array Concatenation and Splitting¶
All of the preceding routines worked on single arrays. It's also possible to combine multiple arrays into one, and to conversely split a single array into multiple arrays. We'll take a look at those operations here.
Concatenation of arrays¶
Concatenation, or joining of two arrays in NumPy, is primarily accomplished using the routines np.concatenate, np.vstack, and np.hstack.
np.concatenate takes a tuple or list of arrays as its first argument, as we can see here:
x = np.array([1, 2, 3])
y = np.array([3, 2, 1])
np.concatenate([x, y])
You can also concatenate more than two arrays at once:
z = [99, 99, 99]
print(np.concatenate([x, y, z]))
It can also be used for two-dimensional arrays:
grid = np.array([[1, 2, 3],
[4, 5, 6]])
# concatenate along the first axis
np.concatenate([grid, grid])
# concatenate along the second axis (zero-indexed)
np.concatenate([grid, grid], axis=1)
For working with arrays of mixed dimensions, it can be clearer to use the np.vstack (vertical stack) and np.hstack (horizontal stack) functions:
x = np.array([1, 2, 3])
grid = np.array([[9, 8, 7],
[6, 5, 4]])
# vertically stack the arrays
np.vstack([x, grid])
# horizontally stack the arrays
y = np.array([[99],
[99]])
np.hstack([grid, y])
Similary, np.dstack will stack arrays along the third axis.
Splitting of arrays¶
The opposite of concatenation is splitting, which is implemented by the functions np.split, np.hsplit, and np.vsplit. For each of these, we can pass a list of indices giving the split points:
x = [1, 2, 3, 99, 99, 3, 2, 1]
x1, x2, x3 = np.split(x, [3, 5])
print(x1, x2, x3)
Notice that N split-points, leads to N + 1 subarrays.
The related functions np.hsplit and np.vsplit are similar:
grid = np.arange(16).reshape((4, 4))
grid
upper, lower = np.vsplit(grid, [2])
print(upper)
print(lower)
left, right = np.hsplit(grid, [2])
print(left)
print(right)
Similarly, np.dsplit will split arrays along the third axis.
Mathematical Operations with Arrays¶
As with vanilla python we have several possibilities to apply mathematical operations to our arrays. +, -, *, / and ** can be used to perform element wise addition, subtraction, multiplication, division and power.
To be able to do so, several conditions must hold:
- Array shapes must be identical (generally speaking)
- Arrays must encompass the same data type
x = np.array([1,2,3])
y = np.array([4,5,6])
print(x + y) # elementwise addition [1 2 3] + [4 5 6] = [5 7 9]
print(x - y) # elementwise subtraction [1 2 3] - [4 5 6] = [-3 -3 -3]
print(x * y) # elementwise multiplication [1 2 3] * [4 5 6] = [4 10 18]
print(x / y) # elementwise divison [1 2 3] / [4 5 6] = [0.25 0.4 0.5]
print(x**2) # elementwise power [1 2 3] ^2 = [1 4 9]
z = np.array(["1", "2", "3"])
print(x + z) # this will fail since array have different data type
Dot Product:
As you may have guessed, arrays are often used to represent vectors in linear algebra. We can therefore also do a dot products between a scalar and a vector.
$ \begin{bmatrix}x_1 \ x_2 \ x_3\end{bmatrix} \cdot \begin{bmatrix}y_1 \\ y_2 \\ y_3\end{bmatrix} = x_1 y_1 + x_2 y_2 + x_3 y_3$
print(x)
print(y)
x.dot(y) # dot product 1*4 + 2*5 + 3*6
< Previous Page | Home Page | Next Page >