We are now ready to start exploring NumPy, the fundamental package upon which the whole scientific Python stack is built. This chapter presents an introduction to the essential features of NumPy that are used in day-to-day scientific and data computations.

Built-in Python data structures, such as lists and dictionaries, are ill suited for scientific and data-oriented computing and their use results in programs that are significantly slower than numerical code written in compiled languages such as C, C++, and Fortran. NumPy was created to address this problem, and solves it by defining specialized array-oriented objects and methods designed for efficient numerical and data computing. The main data structure defined in NumPy with this purpose is ndarray, which represents a multidimensional array of data.

Objects of ndarray type differ from the native Python data structures...

There are several ways to create objects of ndarray type. The recipes in this chapter provide a comprehensive list of the possibilities.

Let's move on to learn how an array can be created from a list.

To create an array from an explicit list, use the following code:

x = np.array([2, 3.5, 5.2, 7.3])

This will assign to x the following array object:

array([ 2. , 3.5, -1. , 7.3, 0. ])

Notice that integer array entries are converted to floating point values. NumPy arrays are homogeneous, that is...

Since we have learnt various ways to create an array, we can now definitely learn how to query and change the shape of an array.

The shape of an array is stored in the shape field of the ndarray object, as shown in the following example:

x = np.array([[1,2,3,4,5,6],[7,8,9,10,11,12]])
x.shape

The shape field of an ndarray object contains a tuple with the size of each of the dimensions of the array, so the preceding code will produce the following output:

(2, 6)

It is possible to assign a to the field shape, which has the effect of reshaping the array, as shown in the following example:

x.shape = (4,3)

This statement will change the array to the following:

array...

Most realistic applications deal with large datasets and will require results to be stored in persistent media, such as a hard disk. NumPy arrays can be stored in either text or binary format and binary files can be optionally compressed. We start the section by showing you a recipe to store files in text format.

Let us proceed with getting our queries about storing and retrieving NumPy arrays resolved.

To store a single NumPy array to the disk in text format, use the savetxt...

In this section, we address the methods NumPy offers for access and modification of data in an array. Python itself provides a rich set of indexing modes, and NumPy extends these with a number of methods suitable for numerical computations.

To access items of an array a, NumPy, as Python, uses the a[...] bracket notation. In the background, NumPy defines the __getitem__, __setitem__, and __deleteitem__ methods to do the requested operations on the array items. The arguments inside the brackets are expressions that specify the locations of the items we want to access. For example, to access the element at position (1,2) of the two-dimensional array a, we use the expression a[1,2]. Since indexing starts at 0, the expression refers to the item in the second row and third column of the array.

NumPy defines a rich set of operations and functions for the ndarray type. NumPy defines the notion of a universal function, abbreviated as ufunc, which is a function object that can be applied to arbitrary arrays. Universal functions are objects of ufunc type, and NumPy provides a vast collection of built-in ufunc functions, covering all computations needed in scientific and data applications.

A ufunc is specialized towards the element by element application of a function. That is, if x is an array object, and f is a ufunc, the f(x) expression will apply the function f to every element of array x, and return a new object with the resulting values.

A common issue arising when working with data or doing computations is the presence of invalid values. Such values can arise either from data that is missing or as a result of operations that resulted in inconsistent data. We may also want to mask array elements that we know would raise errors in further computations.

Masked arrays in NumPy are supported by the masked_array class, which is defined in the numpy.ma module. To work with masked arrays, we need first to import this module, which can be done with the following code:

import numpy.ma as ma

In the following sections, we will get into the details of creating a masked array from the following:

• An explicit...

Up to this point, we only considered arrays that contained native elementary data types.

If we need an array containing heterogeneous data, we can create an array with arbitrary Python objects as elements, as shown in the following code:

x = np.array([2.5, 'a string', [2,4], {'a':0, 'b':1}])

This will result in an array with the np.object ;data type, as indicated in the output line as follows:

array([2.5, 'string', [2, 4], {'a': 0, 'b': 1}], dtype=object)

If the objects to be contained in the array are not known at construction time, we can create an empty array of objects with the following code...

Anybody that has written numerical code will know that a common source of mistakes is the definition of functions that evaluate a complicated formula. One way around this problem is to use a package for symbolic computations, and we will take advantage of sympy, which is a compact Python symbolic package.

To see the full results of the following recipe, we assume that the reader is running Jupyter. Before getting started, run the following code in a Jupyter cell:

from sympy import *
init_printing(use_latex=True)

This...