NumPy Basics¶

Overview¶

Welcome to your first Python library - NumPy! NumPy is the fundamental package for numerical operations with Python. It contains among other things:

• a powerful N-dimensional array object
• sophisticated (broadcasting) functions
• useful linear algebra, Fourier transform, and random number capabilities

Let’s get you started with the basics! In this notebook we will cover

1. Creating an array
2. Math and calculations with arrays
3. Inspecting an array with slicing and indexing

Prerequisites¶

• Time to learn: 35 minutes

Imports¶

A common convention you might encounter is to rename numpy to np on import to shorten it for the many times we will be calling on numpy for functionality.

Create an array of ‘data’¶

The NumPy array represents a contiguous block of memory, holding entries of a given type (and hence fixed size). The entries are laid out in memory according to the shape, or list of dimension sizes. Let’s start by creating an array from a list of integers and taking a look at it,

We can inspect the number of dimensions our array is organized along with ndim, and how long each of these dimensions are with shape

So our 1-dimensional array has a shape of 3 along that dimension! Finally we can check out the underlying type of our underlying data,

Now, let’s expand this with a new data type, and by using a list of lists we can grow the dimensions of our array!

And as before we can use ndim, shape, and dtype to discover how many dimensions of what lengths are making up our array of floats.

Generation¶

NumPy also provides helper functions for generating arrays of data to save you typing for regularly spaced data. Don’t forget your Python indexing rules!

• arange(start, stop, step) creates a range of values in the interval [start,stop) with step spacing.
• linspace(start, stop, num) creates a range of num evenly spaced values over the range [start,stop].

arange¶

linspace¶

Perform calculations with NumPy¶

Arithmetic¶

In core Python, that is without NumPy, creating sequences of values and adding them together requires writing a lot of manual loops, just like one would do in C/C++:

That is very verbose and not very intuitive. Using NumPy this becomes:

Many major mathematical operations operate in the same way. They perform an element-by-element calculation of the two arrays.

Constants¶

NumPy provides us access to some useful constants as well - remember you should never be typing these in manually! Other libraries such as SciPy and MetPy have their own set of constants that are more domain specific.

You can use these for classic calculations you might be familiar with! Here we can create a range t = [0, 2 pi] by pi/4,

Array math functions¶

NumPy also has math functions that can operate on arrays. Similar to the math operations, these greatly simplify and speed up these operations. Let’s start with calculating $\sin(t)$!

and clean it up a bit by rounding to three decimal places.

We can convert between degrees and radians with only NumPy, by hand

or with built-in function rad2deg,

We are similarly provided algorithms for operations including integration, bulk summing, and cumulative summing.

Indexing and subsetting arrays¶

Indexing¶

We can use integer indexing to reach into our arrays and pull out individual elements. Let’s make a toy 2-d array to explore. Here we create a 12-value arange and reshape it into a 3x4 array.

Recall that Python indexing starts at 0, and we can begin indexing our array with the list-style list[element] notation,

to pull out just our first row of data within a. Similarly we can index in reverse with negative indices,

to pull out just the last row of data within a. This notation extends to as many dimensions as make up our array as array[m, n, p, ...]. The following diagram shows these indices for an example, 2-dimensional 6x6 array,

For example, let’s find the entry in our array corresponding to the 2nd row (m=1 in Python) and the 3rd column (n=2 in Python)

We can again use these negative indices to index backwards,

and even mix-and-match along dimensions,

Slices¶

Slicing syntax is written as array[start:stop:step]. Note that all numbers are optional. Importantly, the step parameter is optional and can be omitted, in which case the slice uses a default step of 1.

• defaults:
  • start = 0
  • stop = len(dim)
  • step = 1
• The second colon is also optional if no step is used.

Let’s pull out just the first row, m=0 of a and see how this works!

Laying out our default slice to see the entire array explicitly looks something like this,

where again, these default values are optional,

and even the second : is optional

Now to actually make our own slice, let’s select all elements from m=0 to m=2

This means that slices will include every value up to your stop index and not this index itself, like a half-open interval [start, end). For example,

reveals a different value than

Finally, a few more examples of this notation before reintroducing our 2-d array a.

Multidimensional slicing¶

This entire syntax can be extended to each dimension of multidimensional arrays.

First let’s pull out rows 0 through 2, and then every : column for each of those

Similarly, let’s get all rows for just column 2,

or just take a look at the full row :, for every second column, ::2,

For any shape of array, you can use ... to capture full slices of every non-specified dimension. Consider the 3-D array,

and so this is equivalent to

for extracting every dimension across our first row. We can also flip this around,

to investigate every preceding dimension along our the last entry of our last axis, the same as c[:, :, -1].

Summary¶

In this notebook we introduced NumPy and the ndarray that is so crucial to the entirety of the scientific Python community ecosystem. We created some arrays, used some of NumPy’s own mathematical functions to manipulate them, and then introduced the world of NumPy indexing and selecting for even multi-dimensional arrays.

What’s next?¶

This notebook is the gateway to nearly every other Pythia resource here. This information is crucial for understanding SciPy, pandas, xarray, and more. Continue into NumPy to explore some more intermediate and advanced topics!

Resources and references¶

• NumPy User Guide
• SciPy Lecture Notes